Merge branch 'bfa'

349 files changed, 176665 insertions, 57543 deletions

diff --git a/src/common/Configuration/Config.cpp b/src/common/Configuration/Config.cpp
index df4e5fd151d..a46f1ccaccc 100644
--- a/src/common/Configuration/Config.cpp
+++ b/src/common/Configuration/Config.cpp
@@ -135,7 +135,12 @@ bool ConfigMgr::GetBoolDefault(std::string const& name, bool def) const
     return StringToBool(val);
 }
 
-int ConfigMgr::GetIntDefault(std::string const& name, int def) const
+int32 ConfigMgr::GetIntDefault(std::string const& name, int32 def) const
+{
+    return GetValueDefault(name, def);
+}
+
+int64 ConfigMgr::GetInt64Default(std::string const& name, int64 def) const
 {
     return GetValueDefault(name, def);
 }
diff --git a/src/common/Configuration/Config.h b/src/common/Configuration/Config.h
index a6075008969..550e6db5d6e 100644
--- a/src/common/Configuration/Config.h
+++ b/src/common/Configuration/Config.h
@@ -40,7 +40,8 @@ public:
 
     std::string GetStringDefault(std::string const& name, const std::string& def) const;
     bool GetBoolDefault(std::string const& name, bool def) const;
-    int GetIntDefault(std::string const& name, int def) const;
+    int32 GetIntDefault(std::string const& name, int32 def) const;
+    int64 GetInt64Default(std::string const& name, int64 def) const;
     float GetFloatDefault(std::string const& name, float def) const;
 
     std::string const& GetFilename();
diff --git a/src/common/DataStores/DB2FileLoader.cpp b/src/common/DataStores/DB2FileLoader.cpp
index 712c96eb3fe..d6138fa492e 100644
--- a/src/common/DataStores/DB2FileLoader.cpp
+++ b/src/common/DataStores/DB2FileLoader.cpp
@@ -29,11 +29,24 @@ enum class DB2ColumnCompression : uint32
     Immediate,
     CommonData,
     Pallet,
-    PalletArray
+    PalletArray,
+    SignedImmediate
 };
 
 #pragma pack(push, 1)
 
+struct DB2SectionHeader
+{
+    uint64 TactKeyId;
+    uint32 FileOffset;
+    uint32 RecordCount;
+    uint32 StringTableSize;
+    uint32 CopyTableSize;
+    uint32 CatalogDataOffset;
+    uint32 IdTableSize;
+    uint32 ParentLookupDataSize;
+};
+
 struct DB2FieldEntry
 {
     int16 UnusedBits;
@@ -107,6 +120,11 @@ struct DB2IndexData
     std::unique_ptr<DB2IndexEntry[]> Entries;
 };
 
+DB2FieldMeta::DB2FieldMeta(bool isSigned, DBCFormer type, char const* name)
+    : IsSigned(isSigned), Type(type), Name(name)
+{
+}
+
 DB2FileLoadInfo::DB2FileLoadInfo() : Fields(nullptr), FieldCount(0), Meta(nullptr)
 {
 }
@@ -134,7 +152,7 @@ std::pair<int32, int32> DB2FileLoadInfo::GetFieldIndexByName(char const* fieldNa
     std::size_t ourIndex = Meta->HasIndexFieldInData() ? 0 : 1;
     for (uint32 i = 0; i < Meta->FieldCount; ++i)
     {
-        for (uint8 arr = 0; arr < Meta->ArraySizes[i]; ++arr)
+        for (uint8 arr = 0; arr < Meta->Fields[i].ArraySize; ++arr)
         {
             if (!strcmp(Fields[ourIndex].Name, fieldName))
                 return std::make_pair(int32(i), int32(arr));
@@ -154,12 +172,12 @@ class DB2FileLoaderImpl
 {
 public:
     virtual ~DB2FileLoaderImpl() { }
-    virtual bool LoadTableData(DB2FileSource* source) = 0;
-    virtual bool LoadCatalogData(DB2FileSource* source) = 0;
-    virtual void SetAdditionalData(std::unique_ptr<DB2FieldEntry[]> fields, std::unique_ptr<uint32[]> idTable, std::unique_ptr<DB2RecordCopy[]> copyTable,
-        std::unique_ptr<DB2ColumnMeta[]> columnMeta, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletValues,
-        std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletArrayValues, std::unique_ptr<std::unordered_map<uint32, uint32>[]> commonValues,
-        std::unique_ptr<DB2IndexData[]> parentIndexes) = 0;
+    virtual void LoadColumnData(std::unique_ptr<DB2SectionHeader[]> sections, std::unique_ptr<DB2FieldEntry[]> fields, std::unique_ptr<DB2ColumnMeta[]> columnMeta,
+        std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletValues, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletArrayValues,
+        std::unique_ptr<std::unordered_map<uint32, uint32>[]> commonValues) = 0;
+    virtual bool LoadTableData(DB2FileSource* source, uint32 section) = 0;
+    virtual bool LoadCatalogData(DB2FileSource* source, uint32 section) = 0;
+    virtual void SetAdditionalData(std::vector<uint32> idTable, std::vector<DB2RecordCopy> copyTable, std::vector<DB2IndexData> parentIndexes) = 0;
     virtual char* AutoProduceData(uint32& count, char**& indexTable, std::vector<char*>& stringPool) = 0;
     virtual char* AutoProduceStrings(char** indexTable, uint32 indexTableSize, uint32 locale) = 0;
     virtual void AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) = 0;
@@ -169,6 +187,8 @@ public:
     virtual uint32 GetRecordCopyCount() const = 0;
     virtual uint32 GetMaxId() const = 0;
     virtual DB2FileLoadInfo const* GetLoadInfo() const = 0;
+    virtual DB2SectionHeader const& GetSection(uint32 section) const = 0;
+    virtual bool IsSignedField(uint32 field) const = 0;
 
 private:
     friend class DB2Record;
@@ -191,12 +211,12 @@ public:
     DB2FileLoaderRegularImpl(char const* fileName, DB2FileLoadInfo const* loadInfo, DB2Header const* header);
     ~DB2FileLoaderRegularImpl();
 
-    bool LoadTableData(DB2FileSource* source) override;
-    bool LoadCatalogData(DB2FileSource* /*source*/) override { return true; }
-    void SetAdditionalData(std::unique_ptr<DB2FieldEntry[]> fields, std::unique_ptr<uint32[]> idTable, std::unique_ptr<DB2RecordCopy[]> copyTable,
-        std::unique_ptr<DB2ColumnMeta[]> columnMeta, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletValues,
-        std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletArrayValues, std::unique_ptr<std::unordered_map<uint32, uint32>[]> commonValues,
-        std::unique_ptr<DB2IndexData[]> parentIndexes) override;
+    void LoadColumnData(std::unique_ptr<DB2SectionHeader[]> sections, std::unique_ptr<DB2FieldEntry[]> fields, std::unique_ptr<DB2ColumnMeta[]> columnMeta,
+        std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletValues, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletArrayValues,
+        std::unique_ptr<std::unordered_map<uint32, uint32>[]> commonValues) override;
+    bool LoadTableData(DB2FileSource* source, uint32 section) override;
+    bool LoadCatalogData(DB2FileSource* /*source*/, uint32 /*section*/) override { return true; }
+    void SetAdditionalData(std::vector<uint32> idTable, std::vector<DB2RecordCopy> copyTable, std::vector<DB2IndexData> parentIndexes) override;
     char* AutoProduceData(uint32& count, char**& indexTable, std::vector<char*>& stringPool) override;
     char* AutoProduceStrings(char** indexTable, uint32 indexTableSize, uint32 locale) override;
     void AutoProduceRecordCopies(uint32 records, char** indexTable, char* dataTable) override;
@@ -206,6 +226,8 @@ public:
     uint32 GetRecordCopyCount() const override;
     uint32 GetMaxId() const override;
     DB2FileLoadInfo const* GetLoadInfo() const override;
+    DB2SectionHeader const& GetSection(uint32 section) const override;
+    bool IsSignedField(uint32 field) const override;
 
 private:
     void FillParentLookup(char* dataTable);
@@ -230,13 +252,14 @@ private:
     DB2Header const* _header;
     std::unique_ptr<uint8[]> _data;
     uint8* _stringTable;
-    std::unique_ptr<uint32[]> _idTable;
-    std::unique_ptr<DB2RecordCopy[]> _copyTable;
+    std::unique_ptr<DB2SectionHeader[]> _sections;
     std::unique_ptr<DB2ColumnMeta[]> _columnMeta;
     std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> _palletValues;
     std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> _palletArrayValues;
     std::unique_ptr<std::unordered_map<uint32, uint32>[]> _commonValues;
-    std::unique_ptr<DB2IndexData[]> _parentIndexes;
+    std::vector<uint32> _idTable;
+    std::vector<DB2RecordCopy> _copyTable;
+    std::vector<DB2IndexData> _parentIndexes;
 };
 
 class DB2FileLoaderSparseImpl final : public DB2FileLoaderImpl
@@ -245,12 +268,12 @@ public:
     DB2FileLoaderSparseImpl(char const* fileName, DB2FileLoadInfo const* loadInfo, DB2Header const* header);
     ~DB2FileLoaderSparseImpl();
 
-    bool LoadTableData(DB2FileSource* source) override;
-    bool LoadCatalogData(DB2FileSource* source) override;
-    void SetAdditionalData(std::unique_ptr<DB2FieldEntry[]> fields, std::unique_ptr<uint32[]> idTable, std::unique_ptr<DB2RecordCopy[]> copyTable,
-        std::unique_ptr<DB2ColumnMeta[]> columnMeta, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletValues,
-        std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletArrayValues, std::unique_ptr<std::unordered_map<uint32, uint32>[]> commonValues,
-        std::unique_ptr<DB2IndexData[]> parentIndexes) override;
+    void LoadColumnData(std::unique_ptr<DB2SectionHeader[]> sections, std::unique_ptr<DB2FieldEntry[]> fields, std::unique_ptr<DB2ColumnMeta[]> columnMeta,
+        std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletValues, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletArrayValues,
+        std::unique_ptr<std::unordered_map<uint32, uint32>[]> commonValues) override;
+    bool LoadTableData(DB2FileSource* source, uint32 section) override;
+    bool LoadCatalogData(DB2FileSource* source, uint32 section) override;
+    void SetAdditionalData(std::vector<uint32> /*idTable*/, std::vector<DB2RecordCopy> /*copyTable*/, std::vector<DB2IndexData> /*parentIndexes*/) override { }
     char* AutoProduceData(uint32& records, char**& indexTable, std::vector<char*>& stringPool) override;
     char* AutoProduceStrings(char** indexTable, uint32 indexTableSize, uint32 locale) override;
     void AutoProduceRecordCopies(uint32 /*records*/, char** /*indexTable*/, char* /*dataTable*/) override { }
@@ -260,6 +283,8 @@ public:
     uint32 GetRecordCopyCount() const override;
     uint32 GetMaxId() const override;
     DB2FileLoadInfo const* GetLoadInfo() const override;
+    DB2SectionHeader const& GetSection(uint32 section) const override;
+    bool IsSignedField(uint32 field) const override;
 
 private:
     uint8 const* GetRawRecordData(uint32 recordNumber) const override;
@@ -286,6 +311,7 @@ private:
     DB2Header const* _header;
     std::size_t _dataStart;
     std::unique_ptr<uint8[]> _data;
+    std::unique_ptr<DB2SectionHeader[]> _sections;
     std::unique_ptr<DB2FieldEntry[]> _fields;
     std::unique_ptr<std::size_t[]> _fieldAndArrayOffsets;
     std::unique_ptr<DB2CatalogEntry[]> _catalog;
@@ -299,24 +325,46 @@ DB2FileLoaderRegularImpl::DB2FileLoaderRegularImpl(char const* fileName, DB2File
 {
 }
 
-bool DB2FileLoaderRegularImpl::LoadTableData(DB2FileSource* source)
+void DB2FileLoaderRegularImpl::LoadColumnData(std::unique_ptr<DB2SectionHeader[]> sections, std::unique_ptr<DB2FieldEntry[]> /*fields*/, std::unique_ptr<DB2ColumnMeta[]> columnMeta,
+    std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletValues, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletArrayValues,
+    std::unique_ptr<std::unordered_map<uint32, uint32>[]> commonValues)
 {
-    _data = Trinity::make_unique<uint8[]>(_header->RecordSize * _header->RecordCount + _header->StringTableSize);
-    _stringTable = &_data[_header->RecordSize * _header->RecordCount];
-    return source->Read(_data.get(), _header->RecordSize * _header->RecordCount + _header->StringTableSize);
+    _sections = std::move(sections);
+    _columnMeta = std::move(columnMeta);
+    _palletValues = std::move(palletValues);
+    _palletArrayValues = std::move(palletArrayValues);
+    _commonValues = std::move(commonValues);
+}
+
+bool DB2FileLoaderRegularImpl::LoadTableData(DB2FileSource* source, uint32 section)
+{
+    if (!_data)
+    {
+        _data = Trinity::make_unique<uint8[]>(_header->RecordSize * _header->RecordCount + _header->StringTableSize + 8);
+        _stringTable = &_data[_header->RecordSize * _header->RecordCount];
+    }
+
+    uint32 sectionDataStart = 0;
+    uint32 sectionStringTableStart = 0;
+    for (uint32 i = 0; i < section; ++i)
+    {
+        sectionDataStart += _header->RecordSize * _sections[i].RecordCount;
+        sectionStringTableStart += _sections[i].StringTableSize;
+    }
+
+    if (_sections[section].RecordCount && !source->Read(&_data[sectionDataStart], _header->RecordSize * _sections[section].RecordCount))
+        return false;
+
+    if (_sections[section].StringTableSize && !source->Read(&_stringTable[sectionStringTableStart], _sections[section].StringTableSize))
+        return false;
+
+    return true;
 }
 
-void DB2FileLoaderRegularImpl::SetAdditionalData(std::unique_ptr<DB2FieldEntry[]> /*fields*/, std::unique_ptr<uint32[]> idTable, std::unique_ptr<DB2RecordCopy[]> copyTable,
-    std::unique_ptr<DB2ColumnMeta[]> columnMeta, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletValues,
-    std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletArrayValues, std::unique_ptr<std::unordered_map<uint32, uint32>[]> commonValues,
-    std::unique_ptr<DB2IndexData[]> parentIndexes)
+void DB2FileLoaderRegularImpl::SetAdditionalData(std::vector<uint32> idTable, std::vector<DB2RecordCopy> copyTable, std::vector<DB2IndexData> parentIndexes)
 {
     _idTable = std::move(idTable);
     _copyTable = std::move(copyTable);
-    _columnMeta = std::move(columnMeta);
-    _palletValues = std::move(palletValues);
-    _palletArrayValues = std::move(palletArrayValues);
-    _commonValues = std::move(commonValues);
     _parentIndexes = std::move(parentIndexes);
 }
 
@@ -339,7 +387,7 @@ char* DB2FileLoaderRegularImpl::AutoProduceData(uint32& records, char**& indexTa
     indexTable = new index_entry_t[maxi];
     memset(indexTable, 0, maxi * sizeof(index_entry_t));
 
-    char* dataTable = new char[(_header->RecordCount + (_header->CopyTableSize / 8)) * recordsize];
+    char* dataTable = new char[(_header->RecordCount + _copyTable.size()) * recordsize];
 
     // we store flat holders pool as single memory block
     std::size_t stringFields = _loadInfo->GetStringFieldCount(false);
@@ -384,7 +432,7 @@ char* DB2FileLoaderRegularImpl::AutoProduceData(uint32& records, char**& indexTa
 
         for (uint32 x = 0; x < _header->FieldCount; ++x)
         {
-            for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z)
+            for (uint32 z = 0; z < _loadInfo->Meta->Fields[x].ArraySize; ++z)
             {
                 switch (_loadInfo->TypesString[fieldIndex])
                 {
@@ -423,7 +471,8 @@ char* DB2FileLoaderRegularImpl::AutoProduceData(uint32& records, char**& indexTa
                         break;
                     }
                     default:
-                        ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _fileName);
+                        ASSERT(false, "Unknown format character '%c' found in %s meta for field %s",
+                            _loadInfo->TypesString[fieldIndex], _fileName, _loadInfo->Fields[fieldIndex].Name);
                         break;
                 }
                 ++fieldIndex;
@@ -432,7 +481,7 @@ char* DB2FileLoaderRegularImpl::AutoProduceData(uint32& records, char**& indexTa
 
         for (uint32 x = _header->FieldCount; x < _loadInfo->Meta->FieldCount; ++x)
         {
-            for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z)
+            for (uint32 z = 0; z < _loadInfo->Meta->Fields[x].ArraySize; ++z)
             {
                 switch (_loadInfo->TypesString[fieldIndex])
                 {
@@ -471,7 +520,8 @@ char* DB2FileLoaderRegularImpl::AutoProduceData(uint32& records, char**& indexTa
                         break;
                     }
                     default:
-                        ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _fileName);
+                        ASSERT(false, "Unknown format character '%c' found in %s meta for field %s",
+                            _loadInfo->TypesString[fieldIndex], _fileName, _loadInfo->Fields[fieldIndex].Name);
                         break;
                 }
                 ++fieldIndex;
@@ -479,7 +529,7 @@ char* DB2FileLoaderRegularImpl::AutoProduceData(uint32& records, char**& indexTa
         }
     }
 
-    if (_parentIndexes)
+    if (!_parentIndexes.empty())
         FillParentLookup(dataTable);
 
     return dataTable;
@@ -529,7 +579,7 @@ char* DB2FileLoaderRegularImpl::AutoProduceStrings(char** indexTable, uint32 ind
 
         for (uint32 x = 0; x < _loadInfo->Meta->FieldCount; ++x)
         {
-            for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z)
+            for (uint32 z = 0; z < _loadInfo->Meta->Fields[x].ArraySize; ++z)
             {
                 switch (_loadInfo->TypesString[fieldIndex])
                 {
@@ -568,7 +618,8 @@ char* DB2FileLoaderRegularImpl::AutoProduceStrings(char** indexTable, uint32 ind
                         break;
                     }
                     default:
-                        ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _fileName);
+                        ASSERT(false, "Unknown format character '%c' found in %s meta for field %s",
+                            _loadInfo->TypesString[fieldIndex], _fileName, _loadInfo->Fields[fieldIndex].Name);
                         break;
                 }
                 ++fieldIndex;
@@ -606,7 +657,7 @@ void DB2FileLoaderRegularImpl::FillParentLookup(char* dataTable)
         uint32 parentId = _parentIndexes[0].Entries[i].ParentId;
         char* recordData = &dataTable[_parentIndexes[0].Entries[i].RecordIndex * recordSize];
 
-        switch (_loadInfo->Meta->Types[_loadInfo->Meta->ParentIndexField])
+        switch (_loadInfo->Meta->Fields[_loadInfo->Meta->ParentIndexField].Type)
         {
             case FT_SHORT:
                 *reinterpret_cast<uint16*>(&recordData[parentIdOffset]) = uint16(parentId);
@@ -618,7 +669,7 @@ void DB2FileLoaderRegularImpl::FillParentLookup(char* dataTable)
                 *reinterpret_cast<uint32*>(&recordData[parentIdOffset]) = parentId;
                 break;
             default:
-                ASSERT(false, "Unhandled parent id type '%c' found in %s", _loadInfo->Meta->Types[_loadInfo->Meta->ParentIndexField], _fileName);
+                ASSERT(false, "Unhandled parent id type '%c' found in %s", _loadInfo->Meta->Fields[_loadInfo->Meta->ParentIndexField].Type, _fileName);
                 break;
         }
     }
@@ -644,7 +695,7 @@ uint32 DB2FileLoaderRegularImpl::GetRecordCount() const
 
 uint32 DB2FileLoaderRegularImpl::GetRecordCopyCount() const
 {
-    return _header->CopyTableSize / sizeof(DB2RecordCopy);
+    return _copyTable.size();
 }
 
 uint8 const* DB2FileLoaderRegularImpl::GetRawRecordData(uint32 recordNumber) const
@@ -695,16 +746,18 @@ float DB2FileLoaderRegularImpl::RecordGetFloat(uint8 const* record, uint32 field
 
 char const* DB2FileLoaderRegularImpl::RecordGetString(uint8 const* record, uint32 field, uint32 arrayIndex) const
 {
+    uint32 fieldOffset = GetFieldOffset(field) + sizeof(uint32) * arrayIndex;
     uint32 stringOffset = RecordGetVarInt<uint32>(record, field, arrayIndex);
-    ASSERT(stringOffset < _header->StringTableSize);
-    return reinterpret_cast<char*>(_stringTable + stringOffset);
+    ASSERT(stringOffset < _header->RecordSize * _header->RecordCount + _header->StringTableSize);
+    return reinterpret_cast<char const*>(record + fieldOffset + stringOffset);
 }
 
 template<typename T>
 T DB2FileLoaderRegularImpl::RecordGetVarInt(uint8 const* record, uint32 field, uint32 arrayIndex) const
 {
     ASSERT(field < _header->FieldCount);
-    switch (_columnMeta[field].CompressionType)
+    DB2ColumnCompression compressionType = _columnMeta ? _columnMeta[field].CompressionType : DB2ColumnCompression::None;
+    switch (compressionType)
     {
         case DB2ColumnCompression::None:
         {
@@ -718,11 +771,6 @@ T DB2FileLoaderRegularImpl::RecordGetVarInt(uint8 const* record, uint32 field, u
             uint64 immediateValue = RecordGetPackedValue(record + GetFieldOffset(field),
                 _columnMeta[field].CompressionData.immediate.BitWidth, _columnMeta[field].CompressionData.immediate.BitOffset);
             EndianConvert(immediateValue);
-            if (_columnMeta[field].CompressionData.immediate.Signed)
-            {
-                uint64 mask = UI64LIT(1) << (_columnMeta[field].CompressionData.immediate.BitWidth - 1);
-                immediateValue = (immediateValue ^ mask) - mask;
-            }
             T value;
             memcpy(&value, &immediateValue, std::min(sizeof(T), sizeof(immediateValue)));
             return value;
@@ -761,6 +809,18 @@ T DB2FileLoaderRegularImpl::RecordGetVarInt(uint8 const* record, uint32 field, u
             memcpy(&value, &palletValue, std::min(sizeof(T), sizeof(palletValue)));
             return value;
         }
+        case DB2ColumnCompression::SignedImmediate:
+        {
+            ASSERT(arrayIndex == 0);
+            uint64 immediateValue = RecordGetPackedValue(record + GetFieldOffset(field),
+                _columnMeta[field].CompressionData.immediate.BitWidth, _columnMeta[field].CompressionData.immediate.BitOffset);
+            EndianConvert(immediateValue);
+            uint64 mask = UI64LIT(1) << (_columnMeta[field].CompressionData.immediate.BitWidth - 1);
+            immediateValue = (immediateValue ^ mask) - mask;
+            T value;
+            memcpy(&value, &immediateValue, std::min(sizeof(T), sizeof(immediateValue)));
+            return value;
+        }
         default:
             ASSERT(false, "Unhandled compression type %u in %s", uint32(_columnMeta[field].CompressionType), _fileName);
             break;
@@ -778,11 +838,13 @@ uint64 DB2FileLoaderRegularImpl::RecordGetPackedValue(uint8 const* packedRecordD
 uint16 DB2FileLoaderRegularImpl::GetFieldOffset(uint32 field) const
 {
     ASSERT(field < _header->FieldCount);
-    switch (_columnMeta[field].CompressionType)
+    DB2ColumnCompression compressionType = _columnMeta ? _columnMeta[field].CompressionType : DB2ColumnCompression::None;
+    switch (compressionType)
     {
         case DB2ColumnCompression::None:
             return _columnMeta[field].BitOffset / 8;
         case DB2ColumnCompression::Immediate:
+        case DB2ColumnCompression::SignedImmediate:
             return _columnMeta[field].CompressionData.immediate.BitOffset / 8 + _header->PackedDataOffset;
         case DB2ColumnCompression::CommonData:
             return 0xFFFF;
@@ -831,6 +893,40 @@ DB2FileLoadInfo const* DB2FileLoaderRegularImpl::GetLoadInfo() const
     return _loadInfo;
 }
 
+DB2SectionHeader const& DB2FileLoaderRegularImpl::GetSection(uint32 section) const
+{
+    return _sections[section];
+}
+
+bool DB2FileLoaderRegularImpl::IsSignedField(uint32 field) const
+{
+    if (field >= _header->TotalFieldCount)
+    {
+        ASSERT(field == _header->TotalFieldCount);
+        ASSERT(int32(field) == _loadInfo->Meta->ParentIndexField);
+        return _loadInfo->Meta->IsSignedField(field);
+    }
+
+    DB2ColumnCompression compressionType = _columnMeta ? _columnMeta[field].CompressionType : DB2ColumnCompression::None;
+    switch (compressionType)
+    {
+        case DB2ColumnCompression::None:
+        case DB2ColumnCompression::CommonData:
+        case DB2ColumnCompression::Pallet:
+        case DB2ColumnCompression::PalletArray:
+            return _loadInfo->Meta->IsSignedField(field);
+        case DB2ColumnCompression::SignedImmediate:
+            return field != uint32(_loadInfo->Meta->IndexField);
+        case DB2ColumnCompression::Immediate:
+            return false;
+        default:
+            ASSERT(false, "Unhandled compression type %u in %s", uint32(_columnMeta[field].CompressionType), _fileName);
+            break;
+    }
+
+    return false;
+}
+
 DB2FileLoaderSparseImpl::DB2FileLoaderSparseImpl(char const* fileName, DB2FileLoadInfo const* loadInfo, DB2Header const* header) :
     _fileName(fileName),
     _loadInfo(loadInfo),
@@ -844,25 +940,31 @@ DB2FileLoaderSparseImpl::~DB2FileLoaderSparseImpl()
 {
 }
 
-bool DB2FileLoaderSparseImpl::LoadTableData(DB2FileSource* source)
+void DB2FileLoaderSparseImpl::LoadColumnData(std::unique_ptr<DB2SectionHeader[]> sections, std::unique_ptr<DB2FieldEntry[]> fields, std::unique_ptr<DB2ColumnMeta[]> /*columnMeta*/,
+    std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> /*palletValues*/, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> /*palletArrayValues*/,
+    std::unique_ptr<std::unordered_map<uint32, uint32>[]> /*commonValues*/)
 {
-    _dataStart = source->GetPosition();
-    _data = Trinity::make_unique<uint8[]>(_header->CatalogDataOffset - _dataStart);
-    return source->Read(_data.get(), _header->CatalogDataOffset - _dataStart);
+    _sections = std::move(sections);
+    _fields = std::move(fields);
 }
 
-bool DB2FileLoaderSparseImpl::LoadCatalogData(DB2FileSource* source)
+bool DB2FileLoaderSparseImpl::LoadTableData(DB2FileSource* source, uint32 section)
 {
-    _catalog = Trinity::make_unique<DB2CatalogEntry[]>(_header->MaxId - _header->MinId + 1);
-    return source->Read(_catalog.get(), sizeof(DB2CatalogEntry) * (_header->MaxId - _header->MinId + 1));
+    if (section != 0)
+        return false;
+
+    _dataStart = source->GetPosition();
+    _data = Trinity::make_unique<uint8[]>(_sections[0].CatalogDataOffset - _dataStart);
+    return source->Read(_data.get(), _sections[0].CatalogDataOffset - _dataStart);
 }
 
-void DB2FileLoaderSparseImpl::SetAdditionalData(std::unique_ptr<DB2FieldEntry[]> fields, std::unique_ptr<uint32[]> /*idTable*/, std::unique_ptr<DB2RecordCopy[]> /*copyTable*/,
-    std::unique_ptr<DB2ColumnMeta[]> /*columnMeta*/, std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> /*palletValues*/,
-    std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> /*palletArrayValues*/, std::unique_ptr<std::unordered_map<uint32, uint32>[]> /*commonValues*/,
-    std::unique_ptr<DB2IndexData[]> /*parentIndexes*/)
+bool DB2FileLoaderSparseImpl::LoadCatalogData(DB2FileSource* source, uint32 section)
 {
-    _fields = std::move(fields);
+    if (section != 0)
+        return false;
+
+    _catalog = Trinity::make_unique<DB2CatalogEntry[]>(_header->MaxId - _header->MinId + 1);
+    return source->Read(_catalog.get(), sizeof(DB2CatalogEntry) * (_header->MaxId - _header->MinId + 1));
 }
 
 char* DB2FileLoaderSparseImpl::AutoProduceData(uint32& maxId, char**& indexTable, std::vector<char*>& stringPool)
@@ -935,7 +1037,7 @@ char* DB2FileLoaderSparseImpl::AutoProduceData(uint32& maxId, char**& indexTable
         uint32 stringFieldOffset = 0;
         for (uint32 x = 0; x < _header->FieldCount; ++x)
         {
-            for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z)
+            for (uint32 z = 0; z < _loadInfo->Meta->Fields[x].ArraySize; ++z)
             {
                 switch (_loadInfo->TypesString[fieldIndex])
                 {
@@ -984,7 +1086,8 @@ char* DB2FileLoaderSparseImpl::AutoProduceData(uint32& maxId, char**& indexTable
                         break;
                     }
                     default:
-                        ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _fileName);
+                        ASSERT(false, "Unknown format character '%c' found in %s meta for field %s",
+                            _loadInfo->TypesString[fieldIndex], _fileName, _loadInfo->Fields[fieldIndex].Name);
                         break;
                 }
                 ++fieldIndex;
@@ -1027,8 +1130,8 @@ char* DB2FileLoaderSparseImpl::AutoProduceStrings(char** indexTable, uint32 inde
 
     uint32 recordsize = _loadInfo->Meta->GetRecordSize();
     std::size_t stringFields = _loadInfo->GetStringFieldCount(true);
-    char* stringTable = new char[_header->CatalogDataOffset - _dataStart - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))];
-    memset(stringTable, 0, _header->CatalogDataOffset - _dataStart - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*)));
+    char* stringTable = new char[_sections[0].CatalogDataOffset - _dataStart - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*))];
+    memset(stringTable, 0, _sections[0].CatalogDataOffset - _dataStart - records * ((recordsize - (!_loadInfo->Meta->HasIndexFieldInData() ? 4 : 0)) - stringFields * sizeof(char*)));
     char* stringPtr = stringTable;
 
     for (uint32 y = 0; y < offsetCount; y++)
@@ -1053,7 +1156,7 @@ char* DB2FileLoaderSparseImpl::AutoProduceStrings(char** indexTable, uint32 inde
 
         for (uint32 x = 0; x < _header->FieldCount; ++x)
         {
-            for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z)
+            for (uint32 z = 0; z < _loadInfo->Meta->Fields[x].ArraySize; ++z)
             {
                 switch (_loadInfo->TypesString[fieldIndex])
                 {
@@ -1085,7 +1188,8 @@ char* DB2FileLoaderSparseImpl::AutoProduceStrings(char** indexTable, uint32 inde
                         offset += sizeof(char*);
                         break;
                     default:
-                        ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _fileName);
+                        ASSERT(false, "Unknown format character '%c' found in %s meta for field %s",
+                            _loadInfo->TypesString[fieldIndex], _fileName, _loadInfo->Fields[fieldIndex].Name);
                         break;
                 }
                 ++fieldIndex;
@@ -1230,10 +1334,10 @@ void DB2FileLoaderSparseImpl::CalculateAndStoreFieldOffsets(uint8 const* rawReco
     for (uint32 field = 0; field < _loadInfo->Meta->FieldCount; ++field)
     {
         _fieldAndArrayOffsets[field] = combinedField;
-        for (uint32 arr = 0; arr < _loadInfo->Meta->ArraySizes[field]; ++arr)
+        for (uint32 arr = 0; arr < _loadInfo->Meta->Fields[field].ArraySize; ++arr)
         {
             _fieldAndArrayOffsets[combinedField] = offset;
-            switch (_loadInfo->Meta->Types[field])
+            switch (_loadInfo->Meta->Fields[field].Type)
             {
                 case FT_BYTE:
                 case FT_SHORT:
@@ -1245,10 +1349,11 @@ void DB2FileLoaderSparseImpl::CalculateAndStoreFieldOffsets(uint8 const* rawReco
                     offset += sizeof(float);
                     break;
                 case FT_STRING:
+                case FT_STRING_NOT_LOCALIZED:
                     offset += strlen(reinterpret_cast<char const*>(rawRecord) + offset) + 1;
                     break;
                 default:
-                    ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->Meta->Types[field], _fileName);
+                    ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->Meta->Fields[field].Type, _fileName);
                     break;
             }
             ++combinedField;
@@ -1266,6 +1371,17 @@ DB2FileLoadInfo const* DB2FileLoaderSparseImpl::GetLoadInfo() const
     return _loadInfo;
 }
 
+DB2SectionHeader const& DB2FileLoaderSparseImpl::GetSection(uint32 section) const
+{
+    return _sections[section];
+}
+
+bool DB2FileLoaderSparseImpl::IsSignedField(uint32 field) const
+{
+    ASSERT(field < _header->FieldCount);
+    return _loadInfo->Meta->IsSignedField(field);
+}
+
 DB2Record::DB2Record(DB2FileLoaderImpl const& db2, uint32 recordIndex, std::size_t* fieldOffsets)
     : _db2(db2), _recordIndex(recordIndex), _recordData(db2.GetRawRecordData(recordIndex)), _fieldOffsets(fieldOffsets)
 {
@@ -1402,86 +1518,66 @@ bool DB2FileLoader::Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo)
     EndianConvert(_header.MinId);
     EndianConvert(_header.MaxId);
     EndianConvert(_header.Locale);
-    EndianConvert(_header.CopyTableSize);
     EndianConvert(_header.Flags);
     EndianConvert(_header.IndexField);
     EndianConvert(_header.TotalFieldCount);
     EndianConvert(_header.PackedDataOffset);
     EndianConvert(_header.ParentLookupCount);
-    EndianConvert(_header.CatalogDataOffset);
-    EndianConvert(_header.IdTableSize);
     EndianConvert(_header.ColumnMetaSize);
     EndianConvert(_header.CommonDataSize);
     EndianConvert(_header.PalletDataSize);
-    EndianConvert(_header.ParentLookupDataSize);
+    EndianConvert(_header.SectionCount);
 
-    if (_header.Signature != 0x31434457)                        //'WDC1'
+    if (_header.Signature != 0x32434457)                        //'WDC2'
         return false;
 
     if (_header.LayoutHash != loadInfo->Meta->LayoutHash)
         return false;
 
+    if (_header.ParentLookupCount > 1)
+        return false;
+
+    if (_header.TotalFieldCount + (loadInfo->Meta->ParentIndexField >= int32(_header.TotalFieldCount) ? 1 : 0) != loadInfo->Meta->FieldCount)
+        return false;
+
+    if (_header.ParentLookupCount && loadInfo->Meta->ParentIndexField == -1)
+        return false;
+
+    std::unique_ptr<DB2SectionHeader[]> sections = Trinity::make_unique<DB2SectionHeader[]>(_header.SectionCount);
+    if (_header.SectionCount && !source->Read(sections.get(), sizeof(DB2SectionHeader) * _header.SectionCount))
+        return false;
+
+    uint32 totalCopyTableSize = 0;
+    uint32 totalParentLookupDataSize = 0;
+    for (uint32 i = 0; i < _header.SectionCount; ++i)
+    {
+        totalCopyTableSize += sections[i].CopyTableSize;
+        totalParentLookupDataSize += sections[i].ParentLookupDataSize;
+    }
+
     if (!(_header.Flags & 0x1))
     {
         std::size_t expectedFileSize =
             sizeof(DB2Header) +
+            sizeof(DB2SectionHeader) * _header.SectionCount +
             sizeof(DB2FieldEntry) * _header.FieldCount +
             _header.RecordCount * _header.RecordSize +
             _header.StringTableSize +
-            _header.IdTableSize +
-            _header.CopyTableSize +
+            (loadInfo->Meta->IndexField == -1 ? _header.RecordCount * sizeof(uint32) : 0) +
+            totalCopyTableSize +
             _header.ColumnMetaSize +
             _header.PalletDataSize +
             _header.CommonDataSize +
-            _header.ParentLookupDataSize;
+            totalParentLookupDataSize;
 
         if (source->GetFileSize() != expectedFileSize)
             return false;
     }
 
-    if (_header.ParentLookupCount > 1)
-        return false;
-
-    if (_header.TotalFieldCount + (loadInfo->Meta->ParentIndexField >= int32(_header.TotalFieldCount) ? 1 : 0) != loadInfo->Meta->FieldCount)
-        return false;
-
-    if (_header.ParentLookupCount && loadInfo->Meta->ParentIndexField == -1)
-        return false;
-
-    if (!(_header.Flags & 0x1))
-        _impl = new DB2FileLoaderRegularImpl(source->GetFileName(), loadInfo, &_header);
-    else
-        _impl = new DB2FileLoaderSparseImpl(source->GetFileName(), loadInfo, &_header);
-
     std::unique_ptr<DB2FieldEntry[]> fieldData = Trinity::make_unique<DB2FieldEntry[]>(_header.FieldCount);
     if (!source->Read(fieldData.get(), sizeof(DB2FieldEntry) * _header.FieldCount))
         return false;
 
-    if (!_impl->LoadTableData(source))
-        return false;
-
-    if (!_impl->LoadCatalogData(source))
-        return false;
-
-    ASSERT(!loadInfo->Meta->HasIndexFieldInData() || _header.IdTableSize == 0);
-    ASSERT(loadInfo->Meta->HasIndexFieldInData() || _header.IdTableSize == 4 * _header.RecordCount);
-
-    std::unique_ptr<uint32[]> idTable;
-    if (!loadInfo->Meta->HasIndexFieldInData() && _header.IdTableSize)
-    {
-        idTable = Trinity::make_unique<uint32[]>(_header.RecordCount);
-        if (!source->Read(idTable.get(), _header.IdTableSize))
-            return false;
-    }
-
-    std::unique_ptr<DB2RecordCopy[]> copyTable;
-    if (_header.CopyTableSize)
-    {
-        copyTable = Trinity::make_unique<DB2RecordCopy[]>(_header.CopyTableSize / sizeof(DB2RecordCopy));
-        if (!source->Read(copyTable.get(), _header.CopyTableSize))
-            return false;
-    }
-
     std::unique_ptr<DB2ColumnMeta[]> columnMeta;
     std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletValues;
     std::unique_ptr<std::unique_ptr<DB2PalletValue[]>[]> palletArrayValues;
@@ -1494,7 +1590,8 @@ bool DB2FileLoader::Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo)
 
         ASSERT(!loadInfo->Meta->HasIndexFieldInData() ||
             columnMeta[loadInfo->Meta->IndexField].CompressionType == DB2ColumnCompression::None ||
-            columnMeta[loadInfo->Meta->IndexField].CompressionType == DB2ColumnCompression::Immediate);
+            columnMeta[loadInfo->Meta->IndexField].CompressionType == DB2ColumnCompression::Immediate ||
+            columnMeta[loadInfo->Meta->IndexField].CompressionType == DB2ColumnCompression::SignedImmediate);
 
         palletValues = Trinity::make_unique<std::unique_ptr<DB2PalletValue[]>[]>(_header.TotalFieldCount);
         for (uint32 i = 0; i < _header.TotalFieldCount; ++i)
@@ -1543,26 +1640,82 @@ bool DB2FileLoader::Load(DB2FileSource* source, DB2FileLoadInfo const* loadInfo)
         }
     }
 
-    std::unique_ptr<DB2IndexData[]> parentIndexes;
-    if (_header.ParentLookupCount)
+    if (!(_header.Flags & 0x1))
+        _impl = new DB2FileLoaderRegularImpl(source->GetFileName(), loadInfo, &_header);
+    else
+        _impl = new DB2FileLoaderSparseImpl(source->GetFileName(), loadInfo, &_header);
+
+    _impl->LoadColumnData(std::move(sections), std::move(fieldData), std::move(columnMeta), std::move(palletValues), std::move(palletArrayValues), std::move(commonValues));
+
+    std::vector<uint32> idTable;
+    std::vector<DB2RecordCopy> copyTable;
+    std::vector<DB2IndexData> parentIndexes;
+    if (!loadInfo->Meta->HasIndexFieldInData() && _header.RecordCount)
+        idTable.reserve(_header.RecordCount);
+
+    for (uint32 i = 0; i < _header.SectionCount; ++i)
     {
-        parentIndexes = Trinity::make_unique<DB2IndexData[]>(_header.ParentLookupCount);
-        for (uint32 i = 0; i < _header.ParentLookupCount; ++i)
+        DB2SectionHeader const& section = _impl->GetSection(i);
+
+        if (!source->SetPosition(section.FileOffset))
+            return false;
+
+        if (!_impl->LoadTableData(source, i))
+            return false;
+
+        if (!_impl->LoadCatalogData(source, i))
+            return false;
+
+        ASSERT(!loadInfo->Meta->HasIndexFieldInData() || section.IdTableSize == 0);
+        ASSERT(loadInfo->Meta->HasIndexFieldInData() || section.IdTableSize == 4 * section.RecordCount);
+
+        if (!loadInfo->Meta->HasIndexFieldInData() && section.IdTableSize)
         {
-            if (!source->Read(&parentIndexes[i].Info, sizeof(DB2IndexDataInfo)))
+            std::size_t idTableSize = idTable.size();
+            idTable.resize(idTableSize + section.IdTableSize);
+            if (!source->Read(&idTable[idTableSize], section.IdTableSize))
                 return false;
+        }
 
-            if (!parentIndexes[i].Info.NumEntries)
-                continue;
-
-            parentIndexes[i].Entries = Trinity::make_unique<DB2IndexEntry[]>(parentIndexes[i].Info.NumEntries);
-            if (!source->Read(parentIndexes[i].Entries.get(), sizeof(DB2IndexEntry) * parentIndexes[i].Info.NumEntries))
+        if (section.CopyTableSize)
+        {
+            std::size_t copyTableSize = copyTable.size();
+            copyTable.resize(copyTableSize + section.CopyTableSize / sizeof(DB2RecordCopy));
+            if (!source->Read(&copyTable[copyTableSize], section.CopyTableSize))
                 return false;
         }
+
+        if (_header.ParentLookupCount)
+        {
+            parentIndexes.resize(_header.ParentLookupCount);
+            for (uint32 i = 0; i < _header.ParentLookupCount; ++i)
+            {
+                if (!source->Read(&parentIndexes[i].Info, sizeof(DB2IndexDataInfo)))
+                    return false;
+
+                if (!parentIndexes[i].Info.NumEntries)
+                    continue;
+
+                parentIndexes[i].Entries = Trinity::make_unique<DB2IndexEntry[]>(parentIndexes[i].Info.NumEntries);
+                if (!source->Read(parentIndexes[i].Entries.get(), sizeof(DB2IndexEntry) * parentIndexes[i].Info.NumEntries))
+                    return false;
+            }
+        }
     }
 
-    _impl->SetAdditionalData(std::move(fieldData), std::move(idTable), std::move(copyTable), std::move(columnMeta),
-        std::move(palletValues), std::move(palletArrayValues), std::move(commonValues), std::move(parentIndexes));
+    _impl->SetAdditionalData(std::move(idTable), std::move(copyTable), std::move(parentIndexes));
+
+    uint32 fieldIndex = 0;
+    if (!loadInfo->Meta->HasIndexFieldInData())
+    {
+        ASSERT(!loadInfo->Fields[0].IsSigned, "ID must be unsigned");
+        ++fieldIndex;
+    }
+    for (uint32 f = 0; f < loadInfo->Meta->FieldCount; ++f)
+    {
+        ASSERT(loadInfo->Fields[fieldIndex].IsSigned == _impl->IsSignedField(f), "Mismatched field signedness for field %u (%s)", f, loadInfo->Fields[fieldIndex].Name);
+        fieldIndex += loadInfo->Meta->Fields[f].ArraySize;
+    }
 
     return true;
 }
diff --git a/src/common/DataStores/DB2FileLoader.h b/src/common/DataStores/DB2FileLoader.h
index e1f8888dbe3..7be5dc1aa39 100644
--- a/src/common/DataStores/DB2FileLoader.h
+++ b/src/common/DataStores/DB2FileLoader.h
@@ -39,21 +39,27 @@ struct DB2Header
     uint32 MinId;
     uint32 MaxId;
     uint32 Locale;
-    uint32 CopyTableSize;
     uint16 Flags;
     int16 IndexField;
     uint32 TotalFieldCount;
     uint32 PackedDataOffset;
     uint32 ParentLookupCount;
-    uint32 CatalogDataOffset;
-    uint32 IdTableSize;
     uint32 ColumnMetaSize;
     uint32 CommonDataSize;
     uint32 PalletDataSize;
-    uint32 ParentLookupDataSize;
+    uint32 SectionCount;
 };
 #pragma pack(pop)
 
+struct TC_COMMON_API DB2FieldMeta
+{
+    DB2FieldMeta(bool isSigned, DBCFormer type, char const* name);
+
+    bool IsSigned;
+    DBCFormer Type;
+    char const* Name;
+};
+
 struct TC_COMMON_API DB2FileLoadInfo
 {
     DB2FileLoadInfo();
@@ -82,6 +88,8 @@ struct TC_COMMON_API DB2FileSource
     // Returns current read position in file
     virtual std::size_t GetPosition() const = 0;
 
+    virtual bool SetPosition(std::size_t position) = 0;
+
     virtual std::size_t GetFileSize() const = 0;
 
     virtual char const* GetFileName() const = 0;
diff --git a/src/common/DataStores/DB2FileSystemSource.cpp b/src/common/DataStores/DB2FileSystemSource.cpp
index 930100e8d38..9b929a8f5c9 100644
--- a/src/common/DataStores/DB2FileSystemSource.cpp
+++ b/src/common/DataStores/DB2FileSystemSource.cpp
@@ -45,6 +45,11 @@ std::size_t DB2FileSystemSource::GetPosition() const
     return ftell(_file);
 }
 
+bool DB2FileSystemSource::SetPosition(std::size_t position)
+{
+    return fseek(_file, position, SEEK_SET) == 0;
+}
+
 std::size_t DB2FileSystemSource::GetFileSize() const
 {
     boost::system::error_code error;
diff --git a/src/common/DataStores/DB2FileSystemSource.h b/src/common/DataStores/DB2FileSystemSource.h
index eb838bbb846..107aa2705fb 100644
--- a/src/common/DataStores/DB2FileSystemSource.h
+++ b/src/common/DataStores/DB2FileSystemSource.h
@@ -28,6 +28,7 @@ struct TC_COMMON_API DB2FileSystemSource : public DB2FileSource
     bool IsOpen() const override;
     bool Read(void* buffer, std::size_t numBytes) override;
     std::size_t GetPosition() const override;
+    bool SetPosition(std::size_t position) override;
     std::size_t GetFileSize() const override;
     char const* GetFileName() const override;
 
diff --git a/src/common/DataStores/DB2Meta.cpp b/src/common/DataStores/DB2Meta.cpp
index d948786cd1a..b744639fae6 100644
--- a/src/common/DataStores/DB2Meta.cpp
+++ b/src/common/DataStores/DB2Meta.cpp
@@ -18,8 +18,12 @@
 #include "DB2Meta.h"
 #include "Errors.h"
 
-DB2Meta::DB2Meta(int32 indexField, uint32 fieldCount, uint32 layoutHash, char const* types, uint8 const* arraySizes, int32 parentIndexField)
-    : IndexField(indexField), ParentIndexField(parentIndexField), FieldCount(fieldCount), LayoutHash(layoutHash), Types(types), ArraySizes(arraySizes)
+DB2MetaField::DB2MetaField(DBCFormer type, uint8 arraySize, bool isSigned) : Type(type), ArraySize(arraySize), IsSigned(isSigned)
+{
+}
+
+DB2Meta::DB2Meta(int32 indexField, uint32 fieldCount, uint32 layoutHash, DB2MetaField const* fields, int32 parentIndexField)
+    : IndexField(indexField), ParentIndexField(parentIndexField), FieldCount(fieldCount), LayoutHash(layoutHash), Fields(fields)
 {
 }
 
@@ -38,9 +42,9 @@ uint32 DB2Meta::GetRecordSize() const
     uint32 size = 0;
     for (uint32 i = 0; i < FieldCount; ++i)
     {
-        for (uint8 j = 0; j < ArraySizes[i]; ++j)
+        for (uint8 j = 0; j < Fields[i].ArraySize; ++j)
         {
-            switch (Types[i])
+            switch (Fields[i].Type)
             {
                 case FT_BYTE:
                     size += 1;
@@ -56,10 +60,11 @@ uint32 DB2Meta::GetRecordSize() const
                     size += 8;
                     break;
                 case FT_STRING:
+                case FT_STRING_NOT_LOCALIZED:
                     size += sizeof(char*);
                     break;
                 default:
-                    ASSERT(false, "Unsupported column type specified %c", Types[i]);
+                    ASSERT(false, "Unsupported column type specified %c", Fields[i].Type);
                     break;
             }
         }
@@ -82,9 +87,9 @@ int32 DB2Meta::GetParentIndexFieldOffset() const
 
     for (int32 i = 0; i < ParentIndexField; ++i)
     {
-        for (uint8 j = 0; j < ArraySizes[i]; ++j)
+        for (uint8 j = 0; j < Fields[i].ArraySize; ++j)
         {
-            switch (Types[i])
+            switch (Fields[i].Type)
             {
                 case FT_BYTE:
                     offset += 1;
@@ -100,10 +105,11 @@ int32 DB2Meta::GetParentIndexFieldOffset() const
                     offset += 8;
                     break;
                 case FT_STRING:
+                case FT_STRING_NOT_LOCALIZED:
                     offset += sizeof(char*);
                     break;
                 default:
-                    ASSERT(false, "Unsupported column type specified %c", Types[i]);
+                    ASSERT(false, "Unsupported column type specified %c", Fields[i].Type);
                     break;
             }
         }
@@ -119,7 +125,7 @@ uint32 DB2Meta::GetDbIndexField() const
 
     uint32 index = 0;
     for (uint32 i = 0; i < FieldCount && i < uint32(IndexField); ++i)
-        index += ArraySizes[i];
+        index += Fields[i].ArraySize;
 
     return index;
 }
@@ -128,7 +134,7 @@ uint32 DB2Meta::GetDbFieldCount() const
 {
     uint32 fields = 0;
     for (uint32 i = 0; i < FieldCount; ++i)
-        fields += ArraySizes[i];
+        fields += Fields[i].ArraySize;
 
     if (!HasIndexFieldInData())
         ++fields;
@@ -136,7 +142,23 @@ uint32 DB2Meta::GetDbFieldCount() const
     return fields;
 }
 
-DB2FieldMeta::DB2FieldMeta(bool isSigned, DBCFormer type, char const* name)
-    : IsSigned(isSigned), Type(type), Name(name)
+bool DB2Meta::IsSignedField(uint32 field) const
 {
+    switch (Fields[field].Type)
+    {
+        case FT_STRING:
+        case FT_STRING_NOT_LOCALIZED:
+        case FT_FLOAT:
+            return false;
+        case FT_INT:
+        case FT_BYTE:
+        case FT_SHORT:
+        case FT_LONG:
+        default:
+            break;
+    }
+    if (field == uint32(IndexField))
+        return false;
+
+    return Fields[field].IsSigned;
 }
diff --git a/src/common/DataStores/DB2Meta.h b/src/common/DataStores/DB2Meta.h
index dc98f59ca2a..47268d8a242 100644
--- a/src/common/DataStores/DB2Meta.h
+++ b/src/common/DataStores/DB2Meta.h
@@ -20,9 +20,18 @@
 
 #include "Define.h"
 
+struct TC_COMMON_API DB2MetaField
+{
+    DB2MetaField(DBCFormer type, uint8 arraySize, bool isSigned);
+
+    DBCFormer Type;
+    uint8 ArraySize;
+    bool IsSigned;
+};
+
 struct TC_COMMON_API DB2Meta
 {
-    DB2Meta(int32 indexField, uint32 fieldCount, uint32 layoutHash, char const* types, uint8 const* arraySizes, int32 parentIndexField);
+    DB2Meta(int32 indexField, uint32 fieldCount, uint32 layoutHash, DB2MetaField const* fields, int32 parentIndexField);
 
     bool HasIndexFieldInData() const;
 
@@ -37,21 +46,13 @@ struct TC_COMMON_API DB2Meta
     uint32 GetDbIndexField() const;
     uint32 GetDbFieldCount() const;
 
+    bool IsSignedField(uint32 field) const;
+
     int32 IndexField;
     int32 ParentIndexField;
     uint32 FieldCount;
     uint32 LayoutHash;
-    char const* Types;
-    uint8 const* ArraySizes;
-};
-
-struct TC_COMMON_API DB2FieldMeta
-{
-    DB2FieldMeta(bool isSigned, DBCFormer type, char const* name);
-
-    bool IsSigned;
-    DBCFormer Type;
-    char const* Name;
+    DB2MetaField const* Fields;
 };
 
 #endif // DB2Meta_h__
diff --git a/src/common/Utilities/Containers.h b/src/common/Utilities/Containers.h
index 581fbfabe6b..fb952c89b24 100644
--- a/src/common/Utilities/Containers.h
+++ b/src/common/Utilities/Containers.h
@@ -102,7 +102,7 @@ namespace Trinity
          * Note: container cannot be empty
          */
         template<class C>
-        inline auto SelectRandomWeightedContainerElement(C const& container, std::vector<double> weights) -> decltype(std::begin(container))
+        inline auto SelectRandomWeightedContainerElement(C const& container, std::vector<double> const& weights) -> decltype(std::begin(container))
         {
             auto it = std::begin(container);
             std::advance(it, urandweighted(weights.size(), weights.data()));
diff --git a/src/server/bnetserver/Server/Session.cpp b/src/server/bnetserver/Server/Session.cpp
index fd74128b458..6ddfabc3c60 100644
--- a/src/server/bnetserver/Server/Session.cpp
+++ b/src/server/bnetserver/Server/Session.cpp
@@ -407,7 +407,7 @@ uint32 Battlenet::Session::HandleGetAccountState(account::v1::GetAccountStateReq
     if (request->options().field_privacy_info())
     {
         response->mutable_state()->mutable_privacy_info()->set_is_using_rid(false);
-        response->mutable_state()->mutable_privacy_info()->set_is_real_id_visible_for_view_friends(false);
+        response->mutable_state()->mutable_privacy_info()->set_is_visible_for_view_friends(false);
         response->mutable_state()->mutable_privacy_info()->set_is_hidden_from_friend_finder(true);
 
         response->mutable_tags()->set_privacy_info_tag(0xD7CA834D);
diff --git a/src/server/bnetserver/Services/ServiceDispatcher.cpp b/src/server/bnetserver/Services/ServiceDispatcher.cpp
index 8b3449ead5e..c78afa4780f 100644
--- a/src/server/bnetserver/Services/ServiceDispatcher.cpp
+++ b/src/server/bnetserver/Services/ServiceDispatcher.cpp
@@ -21,13 +21,13 @@ Battlenet::ServiceDispatcher::ServiceDispatcher()
 {
     AddService<Services::Account>();
     AddService<Services::Authentication>();
-    AddService<Service<challenge::v1::ChallengeService>>();
-    AddService<Service<channel::v1::ChannelService>>();
+    AddService<Service<club::v1::membership::ClubMembershipService>>();
     AddService<Services::Connection>();
     AddService<Service<friends::v1::FriendsService>>();
     AddService<Services::GameUtilities>();
     AddService<Service<presence::v1::PresenceService>>();
     AddService<Service<report::v1::ReportService>>();
+    AddService<Service<report::v2::ReportService>>();
     AddService<Service<resources::v1::ResourcesService>>();
     AddService<Service<user_manager::v1::UserManagerService>>();
 }
diff --git a/src/server/bnetserver/Services/ServiceDispatcher.h b/src/server/bnetserver/Services/ServiceDispatcher.h
index 796bab6565b..42969da87cd 100644
--- a/src/server/bnetserver/Services/ServiceDispatcher.h
+++ b/src/server/bnetserver/Services/ServiceDispatcher.h
@@ -24,12 +24,15 @@
 #include "AccountService.h"
 #include "AuthenticationService.h"
 #include "challenge_service.pb.h"
-#include "channel_service.pb.h"
+#include "club_membership_listener.pb.h"
+#include "club_membership_service.pb.h"
 #include "ConnectionService.h"
 #include "friends_service.pb.h"
 #include "GameUtilitiesService.h"
+#include "presence_listener.pb.h"
 #include "presence_service.pb.h"
 #include "report_service.pb.h"
+#include "api/client/v2/report_service.pb.h"
 #include "resource_service.pb.h"
 #include "user_manager_service.pb.h"
 
diff --git a/src/server/database/Database/Implementation/CharacterDatabase.cpp b/src/server/database/Database/Implementation/CharacterDatabase.cpp
index 53e8ecde2f9..b822e4ecab3 100644
--- a/src/server/database/Database/Implementation/CharacterDatabase.cpp
+++ b/src/server/database/Database/Implementation/CharacterDatabase.cpp
@@ -84,7 +84,7 @@ void CharacterDatabaseConnection::DoPrepareStatements()
                      "resettalents_time, primarySpecialization, trans_x, trans_y, trans_z, trans_o, transguid, extra_flags, stable_slots, at_login, zone, online, death_expire_time, taxi_path, dungeonDifficulty, "
                      "totalKills, todayKills, yesterdayKills, chosenTitle, watchedFaction, drunk, "
                      "health, power1, power2, power3, power4, power5, power6, instance_id, activeTalentGroup, lootSpecId, exploredZones, knownTitles, actionBars, grantableLevels, raidDifficulty, legacyRaidDifficulty, fishingSteps, "
-                     "honor, honorLevel, prestigeLevel, honorRestState, honorRestBonus "
+                     "honor, honorLevel, honorRestState, honorRestBonus "
                      "FROM characters c LEFT JOIN character_fishingsteps cfs ON c.guid = cfs.guid WHERE c.guid = ?", CONNECTION_ASYNC);
 
     PrepareStatement(CHAR_SEL_GROUP_MEMBER, "SELECT guid FROM group_member WHERE memberGuid = ?", CONNECTION_BOTH);
@@ -139,7 +139,7 @@ void CharacterDatabaseConnection::DoPrepareStatements()
     PrepareStatement(CHAR_SEL_CHARACTER_BGDATA, "SELECT instanceId, team, joinX, joinY, joinZ, joinO, joinMapId, taxiStart, taxiEnd, mountSpell FROM character_battleground_data WHERE guid = ?", CONNECTION_ASYNC);
     PrepareStatement(CHAR_SEL_CHARACTER_GLYPHS, "SELECT talentGroup, glyphId FROM character_glyphs WHERE guid = ?", CONNECTION_ASYNC);
     PrepareStatement(CHAR_SEL_CHARACTER_TALENTS, "SELECT talentId, talentGroup FROM character_talent WHERE guid = ?", CONNECTION_ASYNC);
-    PrepareStatement(CHAR_SEL_CHARACTER_PVP_TALENTS, "SELECT talentId, talentGroup FROM character_pvp_talent WHERE guid = ?", CONNECTION_ASYNC);
+    PrepareStatement(CHAR_SEL_CHARACTER_PVP_TALENTS, "SELECT talentId0, talentId1, talentId2, talentId3, talentGroup FROM character_pvp_talent WHERE guid = ?", CONNECTION_ASYNC);
     PrepareStatement(CHAR_SEL_CHARACTER_SKILLS, "SELECT skill, value, max FROM character_skills WHERE guid = ?", CONNECTION_ASYNC);
     PrepareStatement(CHAR_SEL_CHARACTER_RANDOMBG, "SELECT guid FROM character_battleground_random WHERE guid = ?", CONNECTION_ASYNC);
     PrepareStatement(CHAR_SEL_CHARACTER_BANNED, "SELECT guid FROM character_banned WHERE guid = ? AND active = 1", CONNECTION_ASYNC);
@@ -437,7 +437,7 @@ void CharacterDatabaseConnection::DoPrepareStatements()
                      "logout_time=?,is_logout_resting=?,resettalents_cost=?,resettalents_time=?,primarySpecialization=?,extra_flags=?,stable_slots=?,at_login=?,zone=?,death_expire_time=?,taxi_path=?,"
                      "totalKills=?,todayKills=?,yesterdayKills=?,chosenTitle=?,"
                      "watchedFaction=?,drunk=?,health=?,power1=?,power2=?,power3=?,power4=?,power5=?,power6=?,latency=?,activeTalentGroup=?,lootSpecId=?,exploredZones=?,"
-                     "equipmentCache=?,knownTitles=?,actionBars=?,grantableLevels=?,online=?,honor=?,honorLevel=?,prestigeLevel=?,honorRestState=?,honorRestBonus=?,lastLoginBuild=? WHERE guid=?", CONNECTION_ASYNC);
+                     "equipmentCache=?,knownTitles=?,actionBars=?,grantableLevels=?,online=?,honor=?,honorLevel=?,honorRestState=?,honorRestBonus=?,lastLoginBuild=? WHERE guid=?", CONNECTION_ASYNC);
 
     PrepareStatement(CHAR_UPD_ADD_AT_LOGIN_FLAG, "UPDATE characters SET at_login = at_login | ? WHERE guid = ?", CONNECTION_ASYNC);
     PrepareStatement(CHAR_UPD_REM_AT_LOGIN_FLAG, "UPDATE characters set at_login = at_login & ~ ? WHERE guid = ?", CONNECTION_ASYNC);
@@ -625,7 +625,7 @@ void CharacterDatabaseConnection::DoPrepareStatements()
     PrepareStatement(CHAR_DEL_PETITION_SIGNATURE_BY_OWNER, "DELETE FROM petition_sign WHERE ownerguid = ?", CONNECTION_ASYNC);
     PrepareStatement(CHAR_INS_CHAR_GLYPHS, "INSERT INTO character_glyphs VALUES(?, ?, ?)", CONNECTION_ASYNC);
     PrepareStatement(CHAR_INS_CHAR_TALENT, "INSERT INTO character_talent (guid, talentId, talentGroup) VALUES (?, ?, ?)", CONNECTION_ASYNC);
-    PrepareStatement(CHAR_INS_CHAR_PVP_TALENT, "INSERT INTO character_pvp_talent (guid, talentId, talentGroup) VALUES (?, ?, ?)", CONNECTION_ASYNC);
+    PrepareStatement(CHAR_INS_CHAR_PVP_TALENT, "INSERT INTO character_pvp_talent (guid, talentId0, talentId1, talentId2, talentId3, talentGroup) VALUES (?, ?, ?, ?, ?, ?)", CONNECTION_ASYNC);
     PrepareStatement(CHAR_UPD_CHAR_LIST_SLOT, "UPDATE characters SET slot = ? WHERE guid = ? AND account = ?", CONNECTION_ASYNC);
     PrepareStatement(CHAR_INS_CHAR_FISHINGSTEPS, "INSERT INTO character_fishingsteps (guid, fishingSteps) VALUES (?, ?)", CONNECTION_ASYNC);
     PrepareStatement(CHAR_DEL_CHAR_FISHINGSTEPS, "DELETE FROM character_fishingsteps WHERE guid = ?", CONNECTION_ASYNC);
diff --git a/src/server/database/Database/Implementation/HotfixDatabase.cpp b/src/server/database/Database/Implementation/HotfixDatabase.cpp
index 8c1bb487363..967104b65cf 100644
--- a/src/server/database/Database/Implementation/HotfixDatabase.cpp
+++ b/src/server/database/Database/Implementation/HotfixDatabase.cpp
@@ -32,9 +32,12 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         m_stmts.resize(MAX_HOTFIXDATABASE_STATEMENTS);
 
     // Achievement.db2
-    PrepareStatement(HOTFIX_SEL_ACHIEVEMENT, "SELECT Title, Description, Reward, Flags, InstanceID, Supercedes, Category, UiOrder, SharesCriteria, "
-        "Faction, Points, MinimumCriteria, ID, IconFileID, CriteriaTree FROM achievement ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_ACHIEVEMENT, "SELECT ID, Title_lang, Description_lang, Reward_lang FROM achievement_locale WHERE locale = ?", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ACHIEVEMENT, "SELECT Description, Title, Reward, ID, InstanceID, Faction, Supercedes, Category, MinimumCriteria, "
+        "Points, Flags, UiOrder, IconFileID, CriteriaTree, SharesCriteria FROM achievement ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_ACHIEVEMENT, "SELECT ID, Description_lang, Title_lang, Reward_lang FROM achievement_locale WHERE locale = ?", CONNECTION_SYNCH);
+
+    // AnimationData.db2
+    PrepareStatement(HOTFIX_SEL_ANIMATION_DATA, "SELECT ID, Fallback, BehaviorTier, BehaviorID, Flags1, Flags2 FROM animation_data ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // AnimKit.db2
     PrepareStatement(HOTFIX_SEL_ANIM_KIT, "SELECT ID, OneShotDuration, OneShotStopAnimKitID, LowDefAnimKitID FROM anim_kit ORDER BY ID DESC", CONNECTION_SYNCH);
@@ -43,34 +46,34 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_AREA_GROUP_MEMBER, "SELECT ID, AreaID, AreaGroupID FROM area_group_member ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // AreaTable.db2
-    PrepareStatement(HOTFIX_SEL_AREA_TABLE, "SELECT ID, ZoneName, AreaName, Flags1, Flags2, AmbientMultiplier, ContinentID, ParentAreaID, AreaBit, "
-        "AmbienceID, ZoneMusic, IntroSound, LiquidTypeID1, LiquidTypeID2, LiquidTypeID3, LiquidTypeID4, UwZoneMusic, UwAmbience, "
-        "PvpCombatWorldStateID, SoundProviderPref, SoundProviderPrefUnderwater, ExplorationLevel, FactionGroupMask, MountFlags, "
-        "WildBattlePetLevelMin, WildBattlePetLevelMax, WindSettingsID, UwIntroSound FROM area_table ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_AREA_TABLE, "SELECT ID, ZoneName, AreaName, ContinentID, ParentAreaID, AreaBit, SoundProviderPref, "
+        "SoundProviderPrefUnderwater, AmbienceID, UwAmbience, ZoneMusic, UwZoneMusic, ExplorationLevel, IntroSound, UwIntroSound, FactionGroupMask, "
+        "AmbientMultiplier, MountFlags, PvpCombatWorldStateID, WildBattlePetLevelMin, WildBattlePetLevelMax, WindSettingsID, Flags1, Flags2, "
+        "LiquidTypeID1, LiquidTypeID2, LiquidTypeID3, LiquidTypeID4 FROM area_table ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_AREA_TABLE, "SELECT ID, AreaName_lang FROM area_table_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // AreaTrigger.db2
-    PrepareStatement(HOTFIX_SEL_AREA_TRIGGER, "SELECT PosX, PosY, PosZ, Radius, BoxLength, BoxWidth, BoxHeight, BoxYaw, ContinentID, PhaseID, "
-        "PhaseGroupID, ShapeID, AreaTriggerActionSetID, PhaseUseFlags, ShapeType, Flags, ID FROM area_trigger ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_AREA_TRIGGER, "SELECT PosX, PosY, PosZ, ID, ContinentID, PhaseUseFlags, PhaseID, PhaseGroupID, Radius, BoxLength, "
+        "BoxWidth, BoxHeight, BoxYaw, ShapeType, ShapeID, AreaTriggerActionSetID, Flags FROM area_trigger ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ArmorLocation.db2
     PrepareStatement(HOTFIX_SEL_ARMOR_LOCATION, "SELECT ID, Clothmodifier, Leathermodifier, Chainmodifier, Platemodifier, Modifier FROM armor_location"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Artifact.db2
-    PrepareStatement(HOTFIX_SEL_ARTIFACT, "SELECT ID, Name, UiBarOverlayColor, UiBarBackgroundColor, UiNameColor, UiTextureKitID, "
-        "ChrSpecializationID, ArtifactCategoryID, Flags, UiModelSceneID, SpellVisualKitID FROM artifact ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ARTIFACT, "SELECT Name, ID, UiTextureKitID, UiNameColor, UiBarOverlayColor, UiBarBackgroundColor, "
+        "ChrSpecializationID, Flags, ArtifactCategoryID, UiModelSceneID, SpellVisualKitID FROM artifact ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_ARTIFACT, "SELECT ID, Name_lang FROM artifact_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ArtifactAppearance.db2
-    PrepareStatement(HOTFIX_SEL_ARTIFACT_APPEARANCE, "SELECT Name, UiSwatchColor, UiModelSaturation, UiModelOpacity, OverrideShapeshiftDisplayID, "
-        "ArtifactAppearanceSetID, UiCameraID, DisplayIndex, ItemAppearanceModifierID, Flags, OverrideShapeshiftFormID, ID, UnlockPlayerConditionID, "
-        "UiItemAppearanceID, UiAltItemAppearanceID FROM artifact_appearance ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ARTIFACT_APPEARANCE, "SELECT Name, ID, ArtifactAppearanceSetID, DisplayIndex, UnlockPlayerConditionID, "
+        "ItemAppearanceModifierID, UiSwatchColor, UiModelSaturation, UiModelOpacity, OverrideShapeshiftFormID, OverrideShapeshiftDisplayID, "
+        "UiItemAppearanceID, UiAltItemAppearanceID, Flags, UiCameraID FROM artifact_appearance ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_ARTIFACT_APPEARANCE, "SELECT ID, Name_lang FROM artifact_appearance_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ArtifactAppearanceSet.db2
-    PrepareStatement(HOTFIX_SEL_ARTIFACT_APPEARANCE_SET, "SELECT Name, Description, UiCameraID, AltHandUICameraID, DisplayIndex, "
-        "ForgeAttachmentOverride, Flags, ID, ArtifactID FROM artifact_appearance_set ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ARTIFACT_APPEARANCE_SET, "SELECT Name, Description, ID, DisplayIndex, UiCameraID, AltHandUICameraID, "
+        "ForgeAttachmentOverride, Flags, ArtifactID FROM artifact_appearance_set ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_ARTIFACT_APPEARANCE_SET, "SELECT ID, Name_lang, Description_lang FROM artifact_appearance_set_locale"
         " WHERE locale = ?", CONNECTION_SYNCH);
 
@@ -78,8 +81,8 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_ARTIFACT_CATEGORY, "SELECT ID, XpMultCurrencyID, XpMultCurveID FROM artifact_category ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ArtifactPower.db2
-    PrepareStatement(HOTFIX_SEL_ARTIFACT_POWER, "SELECT PosX, PosY, ArtifactID, Flags, MaxPurchasableRank, Tier, ID, Label FROM artifact_power"
-        " ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ARTIFACT_POWER, "SELECT DisplayPosX, DisplayPosY, ID, ArtifactID, MaxPurchasableRank, Label, Flags, Tier"
+        " FROM artifact_power ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ArtifactPowerLink.db2
     PrepareStatement(HOTFIX_SEL_ARTIFACT_POWER_LINK, "SELECT ID, PowerA, PowerB FROM artifact_power_link ORDER BY ID DESC", CONNECTION_SYNCH);
@@ -88,7 +91,7 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_ARTIFACT_POWER_PICKER, "SELECT ID, PlayerConditionID FROM artifact_power_picker ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ArtifactPowerRank.db2
-    PrepareStatement(HOTFIX_SEL_ARTIFACT_POWER_RANK, "SELECT ID, SpellID, AuraPointsOverride, ItemBonusListID, RankIndex, ArtifactPowerID"
+    PrepareStatement(HOTFIX_SEL_ARTIFACT_POWER_RANK, "SELECT ID, RankIndex, SpellID, ItemBonusListID, AuraPointsOverride, ArtifactPowerID"
         " FROM artifact_power_rank ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ArtifactQuestXp.db2
@@ -100,7 +103,7 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         "MinimumEmpowerKnowledge FROM artifact_tier ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ArtifactUnlock.db2
-    PrepareStatement(HOTFIX_SEL_ARTIFACT_UNLOCK, "SELECT ID, ItemBonusListID, PowerRank, PowerID, PlayerConditionID, ArtifactID FROM artifact_unlock"
+    PrepareStatement(HOTFIX_SEL_ARTIFACT_UNLOCK, "SELECT ID, PowerID, PowerRank, ItemBonusListID, PlayerConditionID, ArtifactID FROM artifact_unlock"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // AuctionHouse.db2
@@ -114,7 +117,7 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_BANNED_ADDONS, "SELECT ID, Name, Version, Flags FROM banned_addons ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // BarberShopStyle.db2
-    PrepareStatement(HOTFIX_SEL_BARBER_SHOP_STYLE, "SELECT DisplayName, Description, CostModifier, Type, Race, Sex, Data, ID FROM barber_shop_style"
+    PrepareStatement(HOTFIX_SEL_BARBER_SHOP_STYLE, "SELECT DisplayName, Description, ID, Type, CostModifier, Race, Sex, Data FROM barber_shop_style"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_BARBER_SHOP_STYLE, "SELECT ID, DisplayName_lang, Description_lang FROM barber_shop_style_locale WHERE locale = ?", CONNECTION_SYNCH);
 
@@ -122,50 +125,50 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_BATTLE_PET_BREED_QUALITY, "SELECT ID, StateMultiplier, QualityEnum FROM battle_pet_breed_quality ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // BattlePetBreedState.db2
-    PrepareStatement(HOTFIX_SEL_BATTLE_PET_BREED_STATE, "SELECT ID, Value, BattlePetStateID, BattlePetBreedID FROM battle_pet_breed_state"
+    PrepareStatement(HOTFIX_SEL_BATTLE_PET_BREED_STATE, "SELECT ID, BattlePetStateID, Value, BattlePetBreedID FROM battle_pet_breed_state"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // BattlePetSpecies.db2
-    PrepareStatement(HOTFIX_SEL_BATTLE_PET_SPECIES, "SELECT SourceText, Description, CreatureID, IconFileDataID, SummonSpellID, Flags, PetTypeEnum, "
-        "SourceTypeEnum, ID, CardUIModelSceneID, LoadoutUIModelSceneID FROM battle_pet_species ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_BATTLE_PET_SPECIES, "SELECT ID, SourceText_lang, Description_lang FROM battle_pet_species_locale WHERE locale = ?", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_BATTLE_PET_SPECIES, "SELECT Description, SourceText, ID, CreatureID, SummonSpellID, IconFileDataID, PetTypeEnum, "
+        "Flags, SourceTypeEnum, CardUIModelSceneID, LoadoutUIModelSceneID FROM battle_pet_species ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_BATTLE_PET_SPECIES, "SELECT ID, Description_lang, SourceText_lang FROM battle_pet_species_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // BattlePetSpeciesState.db2
-    PrepareStatement(HOTFIX_SEL_BATTLE_PET_SPECIES_STATE, "SELECT ID, Value, BattlePetStateID, BattlePetSpeciesID FROM battle_pet_species_state"
+    PrepareStatement(HOTFIX_SEL_BATTLE_PET_SPECIES_STATE, "SELECT ID, BattlePetStateID, Value, BattlePetSpeciesID FROM battle_pet_species_state"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // BattlemasterList.db2
-    PrepareStatement(HOTFIX_SEL_BATTLEMASTER_LIST, "SELECT ID, Name, GameType, ShortDescription, LongDescription, IconFileDataID, MapID1, MapID2, "
-        "MapID3, MapID4, MapID5, MapID6, MapID7, MapID8, MapID9, MapID10, MapID11, MapID12, MapID13, MapID14, MapID15, MapID16, HolidayWorldState, "
-        "RequiredPlayerConditionID, InstanceType, GroupsAllowed, MaxGroupSize, MinLevel, MaxLevel, RatedPlayers, MinPlayers, MaxPlayers, Flags"
+    PrepareStatement(HOTFIX_SEL_BATTLEMASTER_LIST, "SELECT ID, Name, GameType, ShortDescription, LongDescription, InstanceType, MinLevel, MaxLevel, "
+        "RatedPlayers, MinPlayers, MaxPlayers, GroupsAllowed, MaxGroupSize, HolidayWorldState, Flags, IconFileDataID, RequiredPlayerConditionID, "
+        "MapID1, MapID2, MapID3, MapID4, MapID5, MapID6, MapID7, MapID8, MapID9, MapID10, MapID11, MapID12, MapID13, MapID14, MapID15, MapID16"
         " FROM battlemaster_list ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_BATTLEMASTER_LIST, "SELECT ID, Name_lang, GameType_lang, ShortDescription_lang, LongDescription_lang"
         " FROM battlemaster_list_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // BroadcastText.db2
-    PrepareStatement(HOTFIX_SEL_BROADCAST_TEXT, "SELECT ID, Text, Text1, EmoteID1, EmoteID2, EmoteID3, EmoteDelay1, EmoteDelay2, EmoteDelay3, "
-        "EmotesID, LanguageID, Flags, ConditionID, SoundEntriesID1, SoundEntriesID2 FROM broadcast_text ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_BROADCAST_TEXT, "SELECT Text, Text1, ID, LanguageID, ConditionID, EmotesID, Flags, ChatBubbleDurationMs, "
+        "SoundEntriesID1, SoundEntriesID2, EmoteID1, EmoteID2, EmoteID3, EmoteDelay1, EmoteDelay2, EmoteDelay3 FROM broadcast_text ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_BROADCAST_TEXT, "SELECT ID, Text_lang, Text1_lang FROM broadcast_text_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // CfgRegions.db2
-    PrepareStatement(HOTFIX_SEL_CFG_REGIONS, "SELECT ID, Tag, Raidorigin, ChallengeOrigin, RegionID, RegionGroupMask FROM cfg_regions ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CFG_REGIONS, "SELECT ID, Tag, RegionID, Raidorigin, RegionGroupMask, ChallengeOrigin FROM cfg_regions ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CharacterFacialHairStyles.db2
     PrepareStatement(HOTFIX_SEL_CHARACTER_FACIAL_HAIR_STYLES, "SELECT ID, Geoset1, Geoset2, Geoset3, Geoset4, Geoset5, RaceID, SexID, VariationID"
         " FROM character_facial_hair_styles ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CharBaseSection.db2
-    PrepareStatement(HOTFIX_SEL_CHAR_BASE_SECTION, "SELECT ID, VariationEnum, ResolutionVariationEnum, LayoutResType FROM char_base_section"
+    PrepareStatement(HOTFIX_SEL_CHAR_BASE_SECTION, "SELECT ID, LayoutResType, VariationEnum, ResolutionVariationEnum FROM char_base_section"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CharSections.db2
-    PrepareStatement(HOTFIX_SEL_CHAR_SECTIONS, "SELECT ID, MaterialResourcesID1, MaterialResourcesID2, MaterialResourcesID3, Flags, RaceID, SexID, "
-        "BaseSection, VariationIndex, ColorIndex FROM char_sections ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CHAR_SECTIONS, "SELECT ID, RaceID, SexID, BaseSection, VariationIndex, ColorIndex, Flags, MaterialResourcesID1, "
+        "MaterialResourcesID2, MaterialResourcesID3 FROM char_sections ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CharStartOutfit.db2
-    PrepareStatement(HOTFIX_SEL_CHAR_START_OUTFIT, "SELECT ID, ItemID1, ItemID2, ItemID3, ItemID4, ItemID5, ItemID6, ItemID7, ItemID8, ItemID9, "
-        "ItemID10, ItemID11, ItemID12, ItemID13, ItemID14, ItemID15, ItemID16, ItemID17, ItemID18, ItemID19, ItemID20, ItemID21, ItemID22, ItemID23, "
-        "ItemID24, PetDisplayID, ClassID, SexID, OutfitID, PetFamilyID, RaceID FROM char_start_outfit ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CHAR_START_OUTFIT, "SELECT ID, ClassID, SexID, OutfitID, PetDisplayID, PetFamilyID, ItemID1, ItemID2, ItemID3, "
+        "ItemID4, ItemID5, ItemID6, ItemID7, ItemID8, ItemID9, ItemID10, ItemID11, ItemID12, ItemID13, ItemID14, ItemID15, ItemID16, ItemID17, "
+        "ItemID18, ItemID19, ItemID20, ItemID21, ItemID22, ItemID23, ItemID24, RaceID FROM char_start_outfit ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CharTitles.db2
     PrepareStatement(HOTFIX_SEL_CHAR_TITLES, "SELECT ID, Name, Name1, MaskID, Flags FROM char_titles ORDER BY ID DESC", CONNECTION_SYNCH);
@@ -176,85 +179,90 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PREPARE_LOCALE_STMT(HOTFIX_SEL_CHAT_CHANNELS, "SELECT ID, Name_lang, Shortcut_lang FROM chat_channels_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ChrClasses.db2
-    PrepareStatement(HOTFIX_SEL_CHR_CLASSES, "SELECT PetNameToken, Name, NameFemale, NameMale, Filename, CreateScreenFileDataID, "
-        "SelectScreenFileDataID, LowResScreenFileDataID, IconFileDataID, StartingLevel, Flags, CinematicSequenceID, DefaultSpec, DisplayPower, "
-        "SpellClassSet, AttackPowerPerStrength, AttackPowerPerAgility, RangedAttackPowerPerAgility, PrimaryStatPriority, ID FROM chr_classes"
-        " ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_CHR_CLASSES, "SELECT ID, Name_lang, NameFemale_lang, NameMale_lang FROM chr_classes_locale WHERE locale = ?", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CHR_CLASSES, "SELECT Name, Filename, NameMale, NameFemale, PetNameToken, ID, CreateScreenFileDataID, "
+        "SelectScreenFileDataID, IconFileDataID, LowResScreenFileDataID, StartingLevel, Flags, CinematicSequenceID, DefaultSpec, PrimaryStatPriority, "
+        "DisplayPower, RangedAttackPowerPerAgility, AttackPowerPerAgility, AttackPowerPerStrength, SpellClassSet FROM chr_classes ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_CHR_CLASSES, "SELECT ID, Name_lang, NameMale_lang, NameFemale_lang FROM chr_classes_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ChrClassesXPowerTypes.db2
     PrepareStatement(HOTFIX_SEL_CHR_CLASSES_X_POWER_TYPES, "SELECT ID, PowerType, ClassID FROM chr_classes_x_power_types ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ChrRaces.db2
-    PrepareStatement(HOTFIX_SEL_CHR_RACES, "SELECT ClientPrefix, ClientFileString, Name, NameFemale, NameLowercase, NameFemaleLowercase, Flags, "
-        "MaleDisplayId, FemaleDisplayId, CreateScreenFileDataID, SelectScreenFileDataID, MaleCustomizeOffset1, MaleCustomizeOffset2, "
-        "MaleCustomizeOffset3, FemaleCustomizeOffset1, FemaleCustomizeOffset2, FemaleCustomizeOffset3, LowResScreenFileDataID, StartingLevel, "
-        "UiDisplayOrder, FactionID, ResSicknessSpellID, SplashSoundID, CinematicSequenceID, BaseLanguage, CreatureType, Alliance, RaceRelated, "
-        "UnalteredVisualRaceID, CharComponentTextureLayoutID, DefaultClassID, NeutralRaceID, DisplayRaceID, CharComponentTexLayoutHiResID, ID, "
-        "HighResMaleDisplayId, HighResFemaleDisplayId, HeritageArmorAchievementID, MaleSkeletonFileDataID, FemaleSkeletonFileDataID, "
-        "AlteredFormStartVisualKitID1, AlteredFormStartVisualKitID2, AlteredFormStartVisualKitID3, AlteredFormFinishVisualKitID1, "
-        "AlteredFormFinishVisualKitID2, AlteredFormFinishVisualKitID3 FROM chr_races ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CHR_RACES, "SELECT ClientPrefix, ClientFileString, Name, NameFemale, NameLowercase, NameFemaleLowercase, ID, Flags, "
+        "MaleDisplayId, FemaleDisplayId, HighResMaleDisplayId, HighResFemaleDisplayId, CreateScreenFileDataID, SelectScreenFileDataID, "
+        "MaleCustomizeOffset1, MaleCustomizeOffset2, MaleCustomizeOffset3, FemaleCustomizeOffset1, FemaleCustomizeOffset2, FemaleCustomizeOffset3, "
+        "LowResScreenFileDataID, AlteredFormStartVisualKitID1, AlteredFormStartVisualKitID2, AlteredFormStartVisualKitID3, "
+        "AlteredFormFinishVisualKitID1, AlteredFormFinishVisualKitID2, AlteredFormFinishVisualKitID3, HeritageArmorAchievementID, StartingLevel, "
+        "UiDisplayOrder, FemaleSkeletonFileDataID, MaleSkeletonFileDataID, HelmVisFallbackRaceID, FactionID, CinematicSequenceID, ResSicknessSpellID, "
+        "SplashSoundID, BaseLanguage, CreatureType, Alliance, RaceRelated, UnalteredVisualRaceID, CharComponentTextureLayoutID, "
+        "CharComponentTexLayoutHiResID, DefaultClassID, NeutralRaceID, MaleModelFallbackRaceID, MaleModelFallbackSex, FemaleModelFallbackRaceID, "
+        "FemaleModelFallbackSex, MaleTextureFallbackRaceID, MaleTextureFallbackSex, FemaleTextureFallbackRaceID, FemaleTextureFallbackSex"
+        " FROM chr_races ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_CHR_RACES, "SELECT ID, Name_lang, NameFemale_lang, NameLowercase_lang, NameFemaleLowercase_lang"
         " FROM chr_races_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ChrSpecialization.db2
-    PrepareStatement(HOTFIX_SEL_CHR_SPECIALIZATION, "SELECT Name, FemaleName, Description, MasterySpellID1, MasterySpellID2, ClassID, OrderIndex, "
-        "PetTalentType, Role, PrimaryStatPriority, ID, SpellIconFileID, Flags, AnimReplacements FROM chr_specialization ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CHR_SPECIALIZATION, "SELECT Name, FemaleName, Description, ID, ClassID, OrderIndex, PetTalentType, Role, Flags, "
+        "SpellIconFileID, PrimaryStatPriority, AnimReplacements, MasterySpellID1, MasterySpellID2 FROM chr_specialization ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_CHR_SPECIALIZATION, "SELECT ID, Name_lang, FemaleName_lang, Description_lang FROM chr_specialization_locale"
         " WHERE locale = ?", CONNECTION_SYNCH);
 
     // CinematicCamera.db2
-    PrepareStatement(HOTFIX_SEL_CINEMATIC_CAMERA, "SELECT ID, SoundID, OriginX, OriginY, OriginZ, OriginFacing, FileDataID FROM cinematic_camera"
+    PrepareStatement(HOTFIX_SEL_CINEMATIC_CAMERA, "SELECT ID, OriginX, OriginY, OriginZ, SoundID, OriginFacing, FileDataID FROM cinematic_camera"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CinematicSequences.db2
     PrepareStatement(HOTFIX_SEL_CINEMATIC_SEQUENCES, "SELECT ID, SoundID, Camera1, Camera2, Camera3, Camera4, Camera5, Camera6, Camera7, Camera8"
         " FROM cinematic_sequences ORDER BY ID DESC", CONNECTION_SYNCH);
 
+    // ContentTuning.db2
+    PrepareStatement(HOTFIX_SEL_CONTENT_TUNING, "SELECT ID, MinLevel, MaxLevel, Flags, ExpectedStatModID, DifficultyESMID FROM content_tuning"
+        " ORDER BY ID DESC", CONNECTION_SYNCH);
+
     // ConversationLine.db2
     PrepareStatement(HOTFIX_SEL_CONVERSATION_LINE, "SELECT ID, BroadcastTextID, SpellVisualKitID, AdditionalDuration, NextConversationLineID, "
         "AnimKitID, SpeechType, StartAnimation, EndAnimation FROM conversation_line ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CreatureDisplayInfo.db2
-    PrepareStatement(HOTFIX_SEL_CREATURE_DISPLAY_INFO, "SELECT ID, CreatureModelScale, ModelID, NPCSoundID, SizeClass, Flags, Gender, "
-        "ExtendedDisplayInfoID, PortraitTextureFileDataID, CreatureModelAlpha, SoundID, PlayerOverrideScale, PortraitCreatureDisplayInfoID, BloodID, "
-        "ParticleColorID, CreatureGeosetData, ObjectEffectPackageID, AnimReplacementSetID, UnarmedWeaponType, StateSpellVisualKitID, "
-        "PetInstanceScale, MountPoofSpellVisualKitID, TextureVariationFileDataID1, TextureVariationFileDataID2, TextureVariationFileDataID3"
-        " FROM creature_display_info ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CREATURE_DISPLAY_INFO, "SELECT ID, ModelID, SoundID, SizeClass, CreatureModelScale, CreatureModelAlpha, BloodID, "
+        "ExtendedDisplayInfoID, NPCSoundID, ParticleColorID, PortraitCreatureDisplayInfoID, PortraitTextureFileDataID, ObjectEffectPackageID, "
+        "AnimReplacementSetID, Flags, StateSpellVisualKitID, PlayerOverrideScale, PetInstanceScale, UnarmedWeaponType, MountPoofSpellVisualKitID, "
+        "DissolveEffectID, Gender, DissolveOutEffectID, CreatureModelMinLod, TextureVariationFileDataID1, TextureVariationFileDataID2, "
+        "TextureVariationFileDataID3 FROM creature_display_info ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CreatureDisplayInfoExtra.db2
-    PrepareStatement(HOTFIX_SEL_CREATURE_DISPLAY_INFO_EXTRA, "SELECT ID, BakeMaterialResourcesID, HDBakeMaterialResourcesID, DisplayRaceID, "
-        "DisplaySexID, DisplayClassID, SkinID, FaceID, HairStyleID, HairColorID, FacialHairID, CustomDisplayOption1, CustomDisplayOption2, "
-        "CustomDisplayOption3, Flags FROM creature_display_info_extra ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CREATURE_DISPLAY_INFO_EXTRA, "SELECT ID, DisplayRaceID, DisplaySexID, DisplayClassID, SkinID, FaceID, HairStyleID, "
+        "HairColorID, FacialHairID, Flags, BakeMaterialResourcesID, HDBakeMaterialResourcesID, CustomDisplayOption1, CustomDisplayOption2, "
+        "CustomDisplayOption3 FROM creature_display_info_extra ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CreatureFamily.db2
-    PrepareStatement(HOTFIX_SEL_CREATURE_FAMILY, "SELECT ID, Name, MinScale, MaxScale, IconFileID, SkillLine1, SkillLine2, PetFoodMask, "
-        "MinScaleLevel, MaxScaleLevel, PetTalentType FROM creature_family ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CREATURE_FAMILY, "SELECT ID, Name, MinScale, MinScaleLevel, MaxScale, MaxScaleLevel, PetFoodMask, PetTalentType, "
+        "IconFileID, SkillLine1, SkillLine2 FROM creature_family ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_CREATURE_FAMILY, "SELECT ID, Name_lang FROM creature_family_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // CreatureModelData.db2
-    PrepareStatement(HOTFIX_SEL_CREATURE_MODEL_DATA, "SELECT ID, ModelScale, FootprintTextureLength, FootprintTextureWidth, FootprintParticleScale, "
-        "CollisionWidth, CollisionHeight, MountHeight, GeoBox1, GeoBox2, GeoBox3, GeoBox4, GeoBox5, GeoBox6, WorldEffectScale, AttachedEffectScale, "
-        "MissileCollisionRadius, MissileCollisionPush, MissileCollisionRaise, OverrideLootEffectScale, OverrideNameScale, OverrideSelectionRadius, "
-        "TamedPetBaseScale, HoverHeight, Flags, FileDataID, SizeClass, BloodID, FootprintTextureID, FoleyMaterialID, FootstepCameraEffectID, "
-        "DeathThudCameraEffectID, SoundID, CreatureGeosetDataID FROM creature_model_data ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CREATURE_MODEL_DATA, "SELECT ID, GeoBox1, GeoBox2, GeoBox3, GeoBox4, GeoBox5, GeoBox6, Flags, FileDataID, BloodID, "
+        "FootprintTextureID, FootprintTextureLength, FootprintTextureWidth, FootprintParticleScale, FoleyMaterialID, FootstepCameraEffectID, "
+        "DeathThudCameraEffectID, SoundID, SizeClass, CollisionWidth, CollisionHeight, WorldEffectScale, CreatureGeosetDataID, HoverHeight, "
+        "AttachedEffectScale, ModelScale, MissileCollisionRadius, MissileCollisionPush, MissileCollisionRaise, MountHeight, OverrideLootEffectScale, "
+        "OverrideNameScale, OverrideSelectionRadius, TamedPetBaseScale FROM creature_model_data ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CreatureType.db2
     PrepareStatement(HOTFIX_SEL_CREATURE_TYPE, "SELECT ID, Name, Flags FROM creature_type ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_CREATURE_TYPE, "SELECT ID, Name_lang FROM creature_type_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // Criteria.db2
-    PrepareStatement(HOTFIX_SEL_CRITERIA, "SELECT ID, Asset, StartAsset, FailAsset, ModifierTreeId, StartTimer, EligibilityWorldStateID, Type, "
-        "StartEvent, FailEvent, Flags, EligibilityWorldStateValue FROM criteria ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CRITERIA, "SELECT ID, Type, Asset, ModifierTreeId, StartEvent, StartAsset, StartTimer, FailEvent, FailAsset, Flags, "
+        "EligibilityWorldStateID, EligibilityWorldStateValue FROM criteria ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // CriteriaTree.db2
-    PrepareStatement(HOTFIX_SEL_CRITERIA_TREE, "SELECT ID, Description, Amount, Flags, Operator, CriteriaID, Parent, OrderIndex FROM criteria_tree"
+    PrepareStatement(HOTFIX_SEL_CRITERIA_TREE, "SELECT ID, Description, Parent, Amount, Operator, CriteriaID, OrderIndex, Flags FROM criteria_tree"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_CRITERIA_TREE, "SELECT ID, Description_lang FROM criteria_tree_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // CurrencyTypes.db2
-    PrepareStatement(HOTFIX_SEL_CURRENCY_TYPES, "SELECT ID, Name, Description, MaxQty, MaxEarnablePerWeek, Flags, CategoryID, SpellCategory, Quality, "
-        "InventoryIconFileID, SpellWeight FROM currency_types ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_CURRENCY_TYPES, "SELECT ID, Name, Description, CategoryID, InventoryIconFileID, SpellWeight, SpellCategory, MaxQty, "
+        "MaxEarnablePerWeek, Flags, Quality, FactionID FROM currency_types ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_CURRENCY_TYPES, "SELECT ID, Name_lang, Description_lang FROM currency_types_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // Curve.db2
@@ -264,20 +272,20 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_CURVE_POINT, "SELECT ID, PosX, PosY, CurveID, OrderIndex FROM curve_point ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // DestructibleModelData.db2
-    PrepareStatement(HOTFIX_SEL_DESTRUCTIBLE_MODEL_DATA, "SELECT ID, State0Wmo, State1Wmo, State2Wmo, State3Wmo, HealEffectSpeed, "
-        "State0ImpactEffectDoodadSet, State0AmbientDoodadSet, State0NameSet, State1DestructionDoodadSet, State1ImpactEffectDoodadSet, "
-        "State1AmbientDoodadSet, State1NameSet, State2DestructionDoodadSet, State2ImpactEffectDoodadSet, State2AmbientDoodadSet, State2NameSet, "
-        "State3InitDoodadSet, State3AmbientDoodadSet, State3NameSet, EjectDirection, DoNotHighlight, HealEffect FROM destructible_model_data"
+    PrepareStatement(HOTFIX_SEL_DESTRUCTIBLE_MODEL_DATA, "SELECT ID, State0ImpactEffectDoodadSet, State0AmbientDoodadSet, State1Wmo, "
+        "State1DestructionDoodadSet, State1ImpactEffectDoodadSet, State1AmbientDoodadSet, State2Wmo, State2DestructionDoodadSet, "
+        "State2ImpactEffectDoodadSet, State2AmbientDoodadSet, State3Wmo, State3InitDoodadSet, State3AmbientDoodadSet, EjectDirection, DoNotHighlight, "
+        "State0Wmo, HealEffect, HealEffectSpeed, State0NameSet, State1NameSet, State2NameSet, State3NameSet FROM destructible_model_data"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Difficulty.db2
-    PrepareStatement(HOTFIX_SEL_DIFFICULTY, "SELECT ID, Name, GroupSizeHealthCurveID, GroupSizeDmgCurveID, GroupSizeSpellPointsCurveID, "
-        "FallbackDifficultyID, InstanceType, MinPlayers, MaxPlayers, OldEnumValue, Flags, ToggleDifficultyID, ItemContext, OrderIndex FROM difficulty"
+    PrepareStatement(HOTFIX_SEL_DIFFICULTY, "SELECT ID, Name, InstanceType, OrderIndex, OldEnumValue, FallbackDifficultyID, MinPlayers, MaxPlayers, "
+        "Flags, ItemContext, ToggleDifficultyID, GroupSizeHealthCurveID, GroupSizeDmgCurveID, GroupSizeSpellPointsCurveID FROM difficulty"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_DIFFICULTY, "SELECT ID, Name_lang FROM difficulty_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // DungeonEncounter.db2
-    PrepareStatement(HOTFIX_SEL_DUNGEON_ENCOUNTER, "SELECT Name, CreatureDisplayID, MapID, DifficultyID, Bit, Flags, ID, OrderIndex, SpellIconFileID"
+    PrepareStatement(HOTFIX_SEL_DUNGEON_ENCOUNTER, "SELECT Name, ID, MapID, DifficultyID, OrderIndex, Bit, CreatureDisplayID, Flags, SpellIconFileID"
         " FROM dungeon_encounter ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_DUNGEON_ENCOUNTER, "SELECT ID, Name_lang FROM dungeon_encounter_locale WHERE locale = ?", CONNECTION_SYNCH);
 
@@ -293,78 +301,85 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_DURABILITY_QUALITY, "SELECT ID, Data FROM durability_quality ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Emotes.db2
-    PrepareStatement(HOTFIX_SEL_EMOTES, "SELECT ID, RaceMask, EmoteSlashCommand, EmoteFlags, SpellVisualKitID, AnimID, EmoteSpecProc, ClassMask, "
-        "EmoteSpecProcParam, EventSoundID FROM emotes ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_EMOTES, "SELECT ID, RaceMask, EmoteSlashCommand, AnimID, EmoteFlags, EmoteSpecProc, EmoteSpecProcParam, EventSoundID, "
+        "SpellVisualKitID, ClassMask FROM emotes ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // EmotesText.db2
     PrepareStatement(HOTFIX_SEL_EMOTES_TEXT, "SELECT ID, Name, EmoteID FROM emotes_text ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // EmotesTextSound.db2
-    PrepareStatement(HOTFIX_SEL_EMOTES_TEXT_SOUND, "SELECT ID, RaceID, SexID, ClassID, SoundID, EmotesTextID FROM emotes_text_sound ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_EMOTES_TEXT_SOUND, "SELECT ID, RaceID, ClassID, SexID, SoundID, EmotesTextID FROM emotes_text_sound ORDER BY ID DESC", CONNECTION_SYNCH);
+
+    // ExpectedStat.db2
+    PrepareStatement(HOTFIX_SEL_EXPECTED_STAT, "SELECT ID, ExpansionID, CreatureHealth, PlayerHealth, CreatureAutoAttackDps, CreatureArmor, "
+        "PlayerMana, PlayerPrimaryStat, PlayerSecondaryStat, ArmorConstant, CreatureSpellDamage, Lvl FROM expected_stat ORDER BY ID DESC", CONNECTION_SYNCH);
+
+    // ExpectedStatMod.db2
+    PrepareStatement(HOTFIX_SEL_EXPECTED_STAT_MOD, "SELECT ID, CreatureHealthMod, PlayerHealthMod, CreatureAutoAttackDPSMod, CreatureArmorMod, "
+        "PlayerManaMod, PlayerPrimaryStatMod, PlayerSecondaryStatMod, ArmorConstantMod, CreatureSpellDamageMod FROM expected_stat_mod ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Faction.db2
     PrepareStatement(HOTFIX_SEL_FACTION, "SELECT ReputationRaceMask1, ReputationRaceMask2, ReputationRaceMask3, ReputationRaceMask4, Name, "
-        "Description, ID, ReputationBase1, ReputationBase2, ReputationBase3, ReputationBase4, ParentFactionMod1, ParentFactionMod2, ReputationMax1, "
-        "ReputationMax2, ReputationMax3, ReputationMax4, ReputationIndex, ReputationClassMask1, ReputationClassMask2, ReputationClassMask3, "
-        "ReputationClassMask4, ReputationFlags1, ReputationFlags2, ReputationFlags3, ReputationFlags4, ParentFactionID, ParagonFactionID, "
-        "ParentFactionCap1, ParentFactionCap2, Expansion, Flags, FriendshipRepID FROM faction ORDER BY ID DESC", CONNECTION_SYNCH);
+        "Description, ID, ReputationIndex, ParentFactionID, Expansion, FriendshipRepID, Flags, ParagonFactionID, ReputationClassMask1, "
+        "ReputationClassMask2, ReputationClassMask3, ReputationClassMask4, ReputationFlags1, ReputationFlags2, ReputationFlags3, ReputationFlags4, "
+        "ReputationBase1, ReputationBase2, ReputationBase3, ReputationBase4, ReputationMax1, ReputationMax2, ReputationMax3, ReputationMax4, "
+        "ParentFactionMod1, ParentFactionMod2, ParentFactionCap1, ParentFactionCap2 FROM faction ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_FACTION, "SELECT ID, Name_lang, Description_lang FROM faction_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // FactionTemplate.db2
-    PrepareStatement(HOTFIX_SEL_FACTION_TEMPLATE, "SELECT ID, Faction, Flags, Enemies1, Enemies2, Enemies3, Enemies4, Friend1, Friend2, Friend3, "
-        "Friend4, FactionGroup, FriendGroup, EnemyGroup FROM faction_template ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_FACTION_TEMPLATE, "SELECT ID, Faction, Flags, FactionGroup, FriendGroup, EnemyGroup, Enemies1, Enemies2, Enemies3, "
+        "Enemies4, Friend1, Friend2, Friend3, Friend4 FROM faction_template ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GameobjectDisplayInfo.db2
-    PrepareStatement(HOTFIX_SEL_GAMEOBJECT_DISPLAY_INFO, "SELECT ID, FileDataID, GeoBoxMinX, GeoBoxMinY, GeoBoxMinZ, GeoBoxMaxX, GeoBoxMaxY, "
-        "GeoBoxMaxZ, OverrideLootEffectScale, OverrideNameScale, ObjectEffectPackageID FROM gameobject_display_info ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GAMEOBJECT_DISPLAY_INFO, "SELECT ID, GeoBoxMinX, GeoBoxMinY, GeoBoxMinZ, GeoBoxMaxX, GeoBoxMaxY, GeoBoxMaxZ, "
+        "FileDataID, ObjectEffectPackageID, OverrideLootEffectScale, OverrideNameScale FROM gameobject_display_info ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Gameobjects.db2
-    PrepareStatement(HOTFIX_SEL_GAMEOBJECTS, "SELECT Name, PosX, PosY, PosZ, Rot1, Rot2, Rot3, Rot4, Scale, PropValue1, PropValue2, PropValue3, "
-        "PropValue4, PropValue5, PropValue6, PropValue7, PropValue8, OwnerID, DisplayID, PhaseID, PhaseGroupID, PhaseUseFlags, TypeID, ID"
+    PrepareStatement(HOTFIX_SEL_GAMEOBJECTS, "SELECT Name, PosX, PosY, PosZ, Rot1, Rot2, Rot3, Rot4, ID, OwnerID, DisplayID, Scale, TypeID, "
+        "PhaseUseFlags, PhaseID, PhaseGroupID, PropValue1, PropValue2, PropValue3, PropValue4, PropValue5, PropValue6, PropValue7, PropValue8"
         " FROM gameobjects ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_GAMEOBJECTS, "SELECT ID, Name_lang FROM gameobjects_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // GarrAbility.db2
-    PrepareStatement(HOTFIX_SEL_GARR_ABILITY, "SELECT Name, Description, IconFileDataID, Flags, FactionChangeGarrAbilityID, GarrAbilityCategoryID, "
-        "GarrFollowerTypeID, ID FROM garr_ability ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GARR_ABILITY, "SELECT Name, Description, ID, GarrAbilityCategoryID, GarrFollowerTypeID, IconFileDataID, "
+        "FactionChangeGarrAbilityID, Flags FROM garr_ability ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_GARR_ABILITY, "SELECT ID, Name_lang, Description_lang FROM garr_ability_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // GarrBuilding.db2
-    PrepareStatement(HOTFIX_SEL_GARR_BUILDING, "SELECT ID, AllianceName, HordeName, Description, Tooltip, HordeGameObjectID, AllianceGameObjectID, "
-        "IconFileDataID, CurrencyTypeID, HordeUiTextureKitID, AllianceUiTextureKitID, AllianceSceneScriptPackageID, HordeSceneScriptPackageID, "
-        "GarrAbilityID, BonusGarrAbilityID, GoldCost, GarrSiteID, BuildingType, UpgradeLevel, Flags, ShipmentCapacity, GarrTypeID, BuildSeconds, "
-        "CurrencyQty, MaxAssignments FROM garr_building ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_GARR_BUILDING, "SELECT ID, AllianceName_lang, HordeName_lang, Description_lang, Tooltip_lang"
+    PrepareStatement(HOTFIX_SEL_GARR_BUILDING, "SELECT ID, HordeName, AllianceName, Description, Tooltip, GarrTypeID, BuildingType, "
+        "HordeGameObjectID, AllianceGameObjectID, GarrSiteID, UpgradeLevel, BuildSeconds, CurrencyTypeID, CurrencyQty, HordeUiTextureKitID, "
+        "AllianceUiTextureKitID, IconFileDataID, AllianceSceneScriptPackageID, HordeSceneScriptPackageID, MaxAssignments, ShipmentCapacity, "
+        "GarrAbilityID, BonusGarrAbilityID, GoldCost, Flags FROM garr_building ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_GARR_BUILDING, "SELECT ID, HordeName_lang, AllianceName_lang, Description_lang, Tooltip_lang"
         " FROM garr_building_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // GarrBuildingPlotInst.db2
-    PrepareStatement(HOTFIX_SEL_GARR_BUILDING_PLOT_INST, "SELECT MapOffsetX, MapOffsetY, UiTextureAtlasMemberID, GarrSiteLevelPlotInstID, "
-        "GarrBuildingID, ID FROM garr_building_plot_inst ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GARR_BUILDING_PLOT_INST, "SELECT MapOffsetX, MapOffsetY, ID, GarrBuildingID, GarrSiteLevelPlotInstID, "
+        "UiTextureAtlasMemberID FROM garr_building_plot_inst ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GarrClassSpec.db2
-    PrepareStatement(HOTFIX_SEL_GARR_CLASS_SPEC, "SELECT ClassSpec, ClassSpecMale, ClassSpecFemale, UiTextureAtlasMemberID, GarrFollItemSetID, "
-        "FollowerClassLimit, Flags, ID FROM garr_class_spec ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GARR_CLASS_SPEC, "SELECT ClassSpec, ClassSpecMale, ClassSpecFemale, ID, UiTextureAtlasMemberID, GarrFollItemSetID, "
+        "FollowerClassLimit, Flags FROM garr_class_spec ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_GARR_CLASS_SPEC, "SELECT ID, ClassSpec_lang, ClassSpecMale_lang, ClassSpecFemale_lang FROM garr_class_spec_locale"
         " WHERE locale = ?", CONNECTION_SYNCH);
 
     // GarrFollower.db2
-    PrepareStatement(HOTFIX_SEL_GARR_FOLLOWER, "SELECT HordeSourceText, AllianceSourceText, TitleName, HordeCreatureID, AllianceCreatureID, "
-        "HordeIconFileDataID, AllianceIconFileDataID, HordeSlottingBroadcastTextID, AllySlottingBroadcastTextID, HordeGarrFollItemSetID, "
-        "AllianceGarrFollItemSetID, ItemLevelWeapon, ItemLevelArmor, HordeUITextureKitID, AllianceUITextureKitID, GarrFollowerTypeID, "
-        "HordeGarrFollRaceID, AllianceGarrFollRaceID, Quality, HordeGarrClassSpecID, AllianceGarrClassSpecID, FollowerLevel, Gender, Flags, "
-        "HordeSourceTypeEnum, AllianceSourceTypeEnum, GarrTypeID, Vitality, ChrClassID, HordeFlavorGarrStringID, AllianceFlavorGarrStringID, ID"
-        " FROM garr_follower ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GARR_FOLLOWER, "SELECT HordeSourceText, AllianceSourceText, TitleName, ID, GarrTypeID, GarrFollowerTypeID, "
+        "HordeCreatureID, AllianceCreatureID, HordeGarrFollRaceID, AllianceGarrFollRaceID, HordeGarrClassSpecID, AllianceGarrClassSpecID, Quality, "
+        "FollowerLevel, ItemLevelWeapon, ItemLevelArmor, HordeSourceTypeEnum, AllianceSourceTypeEnum, HordeIconFileDataID, AllianceIconFileDataID, "
+        "HordeGarrFollItemSetID, AllianceGarrFollItemSetID, HordeUITextureKitID, AllianceUITextureKitID, Vitality, HordeFlavorGarrStringID, "
+        "AllianceFlavorGarrStringID, HordeSlottingBroadcastTextID, AllySlottingBroadcastTextID, ChrClassID, Flags, Gender FROM garr_follower"
+        " ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_GARR_FOLLOWER, "SELECT ID, HordeSourceText_lang, AllianceSourceText_lang, TitleName_lang FROM garr_follower_locale"
         " WHERE locale = ?", CONNECTION_SYNCH);
 
     // GarrFollowerXAbility.db2
-    PrepareStatement(HOTFIX_SEL_GARR_FOLLOWER_X_ABILITY, "SELECT ID, GarrAbilityID, FactionIndex, GarrFollowerID FROM garr_follower_x_ability"
-        " ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GARR_FOLLOWER_X_ABILITY, "SELECT ID, OrderIndex, FactionIndex, GarrAbilityID, GarrFollowerID"
+        " FROM garr_follower_x_ability ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GarrPlot.db2
-    PrepareStatement(HOTFIX_SEL_GARR_PLOT, "SELECT ID, Name, AllianceConstructObjID, HordeConstructObjID, UiCategoryID, PlotType, Flags, "
+    PrepareStatement(HOTFIX_SEL_GARR_PLOT, "SELECT ID, Name, PlotType, HordeConstructObjID, AllianceConstructObjID, Flags, UiCategoryID, "
         "UpgradeRequirement1, UpgradeRequirement2 FROM garr_plot ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_GARR_PLOT, "SELECT ID, Name_lang FROM garr_plot_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // GarrPlotBuilding.db2
     PrepareStatement(HOTFIX_SEL_GARR_PLOT_BUILDING, "SELECT ID, GarrPlotID, GarrBuildingID FROM garr_plot_building ORDER BY ID DESC", CONNECTION_SYNCH);
@@ -373,15 +388,15 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_GARR_PLOT_INSTANCE, "SELECT ID, Name, GarrPlotID FROM garr_plot_instance ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GarrSiteLevel.db2
-    PrepareStatement(HOTFIX_SEL_GARR_SITE_LEVEL, "SELECT ID, TownHallUiPosX, TownHallUiPosY, MapID, UiTextureKitID, UpgradeMovieID, UpgradeCost, "
-        "UpgradeGoldCost, GarrLevel, GarrSiteID, MaxBuildingLevel FROM garr_site_level ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GARR_SITE_LEVEL, "SELECT ID, TownHallUiPosX, TownHallUiPosY, GarrSiteID, GarrLevel, MapID, UpgradeMovieID, "
+        "UiTextureKitID, MaxBuildingLevel, UpgradeCost, UpgradeGoldCost FROM garr_site_level ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GarrSiteLevelPlotInst.db2
     PrepareStatement(HOTFIX_SEL_GARR_SITE_LEVEL_PLOT_INST, "SELECT ID, UiMarkerPosX, UiMarkerPosY, GarrSiteLevelID, GarrPlotInstanceID, UiMarkerSize"
         " FROM garr_site_level_plot_inst ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GemProperties.db2
-    PrepareStatement(HOTFIX_SEL_GEM_PROPERTIES, "SELECT ID, Type, EnchantId, MinItemLevel FROM gem_properties ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GEM_PROPERTIES, "SELECT ID, EnchantId, Type, MinItemLevel FROM gem_properties ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GlyphBindableSpell.db2
     PrepareStatement(HOTFIX_SEL_GLYPH_BINDABLE_SPELL, "SELECT ID, SpellID, GlyphPropertiesID FROM glyph_bindable_spell ORDER BY ID DESC", CONNECTION_SYNCH);
@@ -394,29 +409,29 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_GLYPH_REQUIRED_SPEC, "SELECT ID, ChrSpecializationID, GlyphPropertiesID FROM glyph_required_spec ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GuildColorBackground.db2
-    PrepareStatement(HOTFIX_SEL_GUILD_COLOR_BACKGROUND, "SELECT ID, Red, Green, Blue FROM guild_color_background ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GUILD_COLOR_BACKGROUND, "SELECT ID, Red, Blue, Green FROM guild_color_background ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GuildColorBorder.db2
-    PrepareStatement(HOTFIX_SEL_GUILD_COLOR_BORDER, "SELECT ID, Red, Green, Blue FROM guild_color_border ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GUILD_COLOR_BORDER, "SELECT ID, Red, Blue, Green FROM guild_color_border ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GuildColorEmblem.db2
-    PrepareStatement(HOTFIX_SEL_GUILD_COLOR_EMBLEM, "SELECT ID, Red, Green, Blue FROM guild_color_emblem ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_GUILD_COLOR_EMBLEM, "SELECT ID, Red, Blue, Green FROM guild_color_emblem ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // GuildPerkSpells.db2
     PrepareStatement(HOTFIX_SEL_GUILD_PERK_SPELLS, "SELECT ID, SpellID FROM guild_perk_spells ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Heirloom.db2
-    PrepareStatement(HOTFIX_SEL_HEIRLOOM, "SELECT SourceText, ItemID, LegacyItemID, LegacyUpgradedItemID, StaticUpgradedItemID, UpgradeItemID1, "
-        "UpgradeItemID2, UpgradeItemID3, UpgradeItemBonusListID1, UpgradeItemBonusListID2, UpgradeItemBonusListID3, Flags, SourceTypeEnum, ID"
+    PrepareStatement(HOTFIX_SEL_HEIRLOOM, "SELECT SourceText, ID, ItemID, LegacyUpgradedItemID, StaticUpgradedItemID, SourceTypeEnum, Flags, "
+        "LegacyItemID, UpgradeItemID1, UpgradeItemID2, UpgradeItemID3, UpgradeItemBonusListID1, UpgradeItemBonusListID2, UpgradeItemBonusListID3"
         " FROM heirloom ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_HEIRLOOM, "SELECT ID, SourceText_lang FROM heirloom_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // Holidays.db2
-    PrepareStatement(HOTFIX_SEL_HOLIDAYS, "SELECT ID, Date1, Date2, Date3, Date4, Date5, Date6, Date7, Date8, Date9, Date10, Date11, Date12, Date13, "
-        "Date14, Date15, Date16, Duration1, Duration2, Duration3, Duration4, Duration5, Duration6, Duration7, Duration8, Duration9, Duration10, "
-        "Region, Looping, CalendarFlags1, CalendarFlags2, CalendarFlags3, CalendarFlags4, CalendarFlags5, CalendarFlags6, CalendarFlags7, "
-        "CalendarFlags8, CalendarFlags9, CalendarFlags10, Priority, CalendarFilterType, Flags, HolidayNameID, HolidayDescriptionID, "
-        "TextureFileDataID1, TextureFileDataID2, TextureFileDataID3 FROM holidays ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_HOLIDAYS, "SELECT ID, Region, Looping, HolidayNameID, HolidayDescriptionID, Priority, CalendarFilterType, Flags, "
+        "Duration1, Duration2, Duration3, Duration4, Duration5, Duration6, Duration7, Duration8, Duration9, Duration10, Date1, Date2, Date3, Date4, "
+        "Date5, Date6, Date7, Date8, Date9, Date10, Date11, Date12, Date13, Date14, Date15, Date16, CalendarFlags1, CalendarFlags2, CalendarFlags3, "
+        "CalendarFlags4, CalendarFlags5, CalendarFlags6, CalendarFlags7, CalendarFlags8, CalendarFlags9, CalendarFlags10, TextureFileDataID1, "
+        "TextureFileDataID2, TextureFileDataID3 FROM holidays ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ImportPriceArmor.db2
     PrepareStatement(HOTFIX_SEL_IMPORT_PRICE_ARMOR, "SELECT ID, ClothModifier, LeatherModifier, ChainModifier, PlateModifier FROM import_price_armor"
@@ -432,23 +447,23 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_IMPORT_PRICE_WEAPON, "SELECT ID, Data FROM import_price_weapon ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Item.db2
-    PrepareStatement(HOTFIX_SEL_ITEM, "SELECT ID, IconFileDataID, ClassID, SubclassID, SoundOverrideSubclassID, Material, InventoryType, SheatheType, "
+    PrepareStatement(HOTFIX_SEL_ITEM, "SELECT ID, ClassID, SubclassID, Material, InventoryType, SheatheType, SoundOverrideSubclassID, IconFileDataID, "
         "ItemGroupSoundsID FROM item ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemAppearance.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_APPEARANCE, "SELECT ID, ItemDisplayInfoID, DefaultIconFileDataID, UiOrder, DisplayType FROM item_appearance"
+    PrepareStatement(HOTFIX_SEL_ITEM_APPEARANCE, "SELECT ID, DisplayType, ItemDisplayInfoID, DefaultIconFileDataID, UiOrder FROM item_appearance"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemArmorQuality.db2
     PrepareStatement(HOTFIX_SEL_ITEM_ARMOR_QUALITY, "SELECT ID, Qualitymod1, Qualitymod2, Qualitymod3, Qualitymod4, Qualitymod5, Qualitymod6, "
-        "Qualitymod7, ItemLevel FROM item_armor_quality ORDER BY ID DESC", CONNECTION_SYNCH);
+        "Qualitymod7 FROM item_armor_quality ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemArmorShield.db2
     PrepareStatement(HOTFIX_SEL_ITEM_ARMOR_SHIELD, "SELECT ID, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, Quality7, ItemLevel"
         " FROM item_armor_shield ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemArmorTotal.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_ARMOR_TOTAL, "SELECT ID, Cloth, Leather, Mail, Plate, ItemLevel FROM item_armor_total ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ITEM_ARMOR_TOTAL, "SELECT ID, ItemLevel, Cloth, Leather, Mail, Plate FROM item_armor_total ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemBagFamily.db2
     PrepareStatement(HOTFIX_SEL_ITEM_BAG_FAMILY, "SELECT ID, Name FROM item_bag_family ORDER BY ID DESC", CONNECTION_SYNCH);
@@ -462,7 +477,7 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_ITEM_BONUS_LIST_LEVEL_DELTA, "SELECT ItemLevelDelta, ID FROM item_bonus_list_level_delta ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemBonusTreeNode.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_BONUS_TREE_NODE, "SELECT ID, ChildItemBonusTreeID, ChildItemBonusListID, ChildItemLevelSelectorID, ItemContext, "
+    PrepareStatement(HOTFIX_SEL_ITEM_BONUS_TREE_NODE, "SELECT ID, ItemContext, ChildItemBonusTreeID, ChildItemBonusListID, ChildItemLevelSelectorID, "
         "ParentItemBonusTreeID FROM item_bonus_tree_node ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemChildEquipment.db2
@@ -470,44 +485,44 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemClass.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_CLASS, "SELECT ID, ClassName, PriceModifier, ClassID, Flags FROM item_class ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ITEM_CLASS, "SELECT ID, ClassName, ClassID, PriceModifier, Flags FROM item_class ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_ITEM_CLASS, "SELECT ID, ClassName_lang FROM item_class_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ItemCurrencyCost.db2
     PrepareStatement(HOTFIX_SEL_ITEM_CURRENCY_COST, "SELECT ID, ItemID FROM item_currency_cost ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemDamageAmmo.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_AMMO, "SELECT ID, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, Quality7, ItemLevel"
+    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_AMMO, "SELECT ID, ItemLevel, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, Quality7"
         " FROM item_damage_ammo ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemDamageOneHand.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND, "SELECT ID, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, Quality7, ItemLevel"
+    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND, "SELECT ID, ItemLevel, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, Quality7"
         " FROM item_damage_one_hand ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemDamageOneHandCaster.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND_CASTER, "SELECT ID, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, Quality7, "
-        "ItemLevel FROM item_damage_one_hand_caster ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND_CASTER, "SELECT ID, ItemLevel, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, "
+        "Quality7 FROM item_damage_one_hand_caster ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemDamageTwoHand.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND, "SELECT ID, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, Quality7, ItemLevel"
+    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND, "SELECT ID, ItemLevel, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, Quality7"
         " FROM item_damage_two_hand ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemDamageTwoHandCaster.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND_CASTER, "SELECT ID, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, Quality7, "
-        "ItemLevel FROM item_damage_two_hand_caster ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND_CASTER, "SELECT ID, ItemLevel, Quality1, Quality2, Quality3, Quality4, Quality5, Quality6, "
+        "Quality7 FROM item_damage_two_hand_caster ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemDisenchantLoot.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_DISENCHANT_LOOT, "SELECT ID, MinLevel, MaxLevel, SkillRequired, Subclass, Quality, ExpansionID, Class"
+    PrepareStatement(HOTFIX_SEL_ITEM_DISENCHANT_LOOT, "SELECT ID, Subclass, Quality, MinLevel, MaxLevel, SkillRequired, ExpansionID, Class"
         " FROM item_disenchant_loot ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemEffect.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_EFFECT, "SELECT ID, SpellID, CoolDownMSec, CategoryCoolDownMSec, Charges, SpellCategoryID, ChrSpecializationID, "
-        "LegacySlotIndex, TriggerType, ParentItemID FROM item_effect ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ITEM_EFFECT, "SELECT ID, LegacySlotIndex, TriggerType, Charges, CoolDownMSec, CategoryCoolDownMSec, SpellCategoryID, "
+        "SpellID, ChrSpecializationID, ParentItemID FROM item_effect ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemExtendedCost.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_EXTENDED_COST, "SELECT ID, ItemID1, ItemID2, ItemID3, ItemID4, ItemID5, CurrencyCount1, CurrencyCount2, "
-        "CurrencyCount3, CurrencyCount4, CurrencyCount5, ItemCount1, ItemCount2, ItemCount3, ItemCount4, ItemCount5, RequiredArenaRating, "
-        "CurrencyID1, CurrencyID2, CurrencyID3, CurrencyID4, CurrencyID5, ArenaBracket, MinFactionID, MinReputation, Flags, RequiredAchievement"
+    PrepareStatement(HOTFIX_SEL_ITEM_EXTENDED_COST, "SELECT ID, RequiredArenaRating, ArenaBracket, Flags, MinFactionID, MinReputation, "
+        "RequiredAchievement, ItemID1, ItemID2, ItemID3, ItemID4, ItemID5, ItemCount1, ItemCount2, ItemCount3, ItemCount4, ItemCount5, CurrencyID1, "
+        "CurrencyID2, CurrencyID3, CurrencyID4, CurrencyID5, CurrencyCount1, CurrencyCount2, CurrencyCount3, CurrencyCount4, CurrencyCount5"
         " FROM item_extended_cost ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemLevelSelector.db2
@@ -529,11 +544,11 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         " FROM item_limit_category_condition ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemModifiedAppearance.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_MODIFIED_APPEARANCE, "SELECT ItemID, ID, ItemAppearanceModifierID, ItemAppearanceID, OrderIndex, "
+    PrepareStatement(HOTFIX_SEL_ITEM_MODIFIED_APPEARANCE, "SELECT ID, ItemID, ItemAppearanceModifierID, ItemAppearanceID, OrderIndex, "
         "TransmogSourceTypeEnum FROM item_modified_appearance ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemPriceBase.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_PRICE_BASE, "SELECT ID, Armor, Weapon, ItemLevel FROM item_price_base ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ITEM_PRICE_BASE, "SELECT ID, ItemLevel, Armor, Weapon FROM item_price_base ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemRandomProperties.db2
     PrepareStatement(HOTFIX_SEL_ITEM_RANDOM_PROPERTIES, "SELECT ID, Name, Enchantment1, Enchantment2, Enchantment3, Enchantment4, Enchantment5"
@@ -546,47 +561,46 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PREPARE_LOCALE_STMT(HOTFIX_SEL_ITEM_RANDOM_SUFFIX, "SELECT ID, Name_lang FROM item_random_suffix_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ItemSearchName.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_SEARCH_NAME, "SELECT AllowableRace, Display, ID, Flags1, Flags2, Flags3, ItemLevel, OverallQualityID, "
-        "ExpansionID, RequiredLevel, MinFactionID, MinReputation, AllowableClass, RequiredSkill, RequiredSkillRank, RequiredAbility"
+    PrepareStatement(HOTFIX_SEL_ITEM_SEARCH_NAME, "SELECT AllowableRace, Display, ID, OverallQualityID, ExpansionID, MinFactionID, MinReputation, "
+        "AllowableClass, RequiredLevel, RequiredSkill, RequiredSkillRank, RequiredAbility, ItemLevel, Flags1, Flags2, Flags3, Flags4"
         " FROM item_search_name ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_ITEM_SEARCH_NAME, "SELECT ID, Display_lang FROM item_search_name_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ItemSet.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_SET, "SELECT ID, Name, ItemID1, ItemID2, ItemID3, ItemID4, ItemID5, ItemID6, ItemID7, ItemID8, ItemID9, "
-        "ItemID10, ItemID11, ItemID12, ItemID13, ItemID14, ItemID15, ItemID16, ItemID17, RequiredSkillRank, RequiredSkill, SetFlags FROM item_set"
+    PrepareStatement(HOTFIX_SEL_ITEM_SET, "SELECT ID, Name, SetFlags, RequiredSkill, RequiredSkillRank, ItemID1, ItemID2, ItemID3, ItemID4, ItemID5, "
+        "ItemID6, ItemID7, ItemID8, ItemID9, ItemID10, ItemID11, ItemID12, ItemID13, ItemID14, ItemID15, ItemID16, ItemID17 FROM item_set"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_ITEM_SET, "SELECT ID, Name_lang FROM item_set_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ItemSetSpell.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_SET_SPELL, "SELECT ID, SpellID, ChrSpecID, Threshold, ItemSetID FROM item_set_spell ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_ITEM_SET_SPELL, "SELECT ID, ChrSpecID, SpellID, Threshold, ItemSetID FROM item_set_spell ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemSparse.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_SPARSE, "SELECT ID, AllowableRace, Display, Display1, Display2, Display3, Description, Flags1, Flags2, Flags3, "
-        "Flags4, PriceRandomValue, PriceVariance, VendorStackCount, BuyPrice, SellPrice, RequiredAbility, MaxCount, Stackable, StatPercentEditor1, "
-        "StatPercentEditor2, StatPercentEditor3, StatPercentEditor4, StatPercentEditor5, StatPercentEditor6, StatPercentEditor7, StatPercentEditor8, "
-        "StatPercentEditor9, StatPercentEditor10, StatPercentageOfSocket1, StatPercentageOfSocket2, StatPercentageOfSocket3, StatPercentageOfSocket4, "
-        "StatPercentageOfSocket5, StatPercentageOfSocket6, StatPercentageOfSocket7, StatPercentageOfSocket8, StatPercentageOfSocket9, "
-        "StatPercentageOfSocket10, ItemRange, BagFamily, QualityModifier, DurationInInventory, DmgVariance, AllowableClass, ItemLevel, RequiredSkill, "
-        "RequiredSkillRank, MinFactionID, ItemStatValue1, ItemStatValue2, ItemStatValue3, ItemStatValue4, ItemStatValue5, ItemStatValue6, "
-        "ItemStatValue7, ItemStatValue8, ItemStatValue9, ItemStatValue10, ScalingStatDistributionID, ItemDelay, PageID, StartQuestID, LockID, "
-        "RandomSelect, ItemRandomSuffixGroupID, ItemSet, ZoneBound, InstanceBound, TotemCategoryID, SocketMatchEnchantmentId, GemProperties, "
-        "LimitCategory, RequiredHoliday, RequiredTransmogHoliday, ItemNameDescriptionID, OverallQualityID, InventoryType, RequiredLevel, "
-        "RequiredPVPRank, RequiredPVPMedal, MinReputation, ContainerSlots, StatModifierBonusStat1, StatModifierBonusStat2, StatModifierBonusStat3, "
-        "StatModifierBonusStat4, StatModifierBonusStat5, StatModifierBonusStat6, StatModifierBonusStat7, StatModifierBonusStat8, "
-        "StatModifierBonusStat9, StatModifierBonusStat10, DamageDamageType, Bonding, LanguageID, PageMaterialID, Material, SheatheType, SocketType1, "
-        "SocketType2, SocketType3, SpellWeightCategory, SpellWeight, ArtifactID, ExpansionID FROM item_sparse ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_ITEM_SPARSE, "SELECT ID, Display_lang, Display1_lang, Display2_lang, Display3_lang, Description_lang"
+    PrepareStatement(HOTFIX_SEL_ITEM_SPARSE, "SELECT ID, AllowableRace, Description, Display3, Display2, Display1, Display, DmgVariance, "
+        "DurationInInventory, QualityModifier, BagFamily, ItemRange, StatPercentageOfSocket1, StatPercentageOfSocket2, StatPercentageOfSocket3, "
+        "StatPercentageOfSocket4, StatPercentageOfSocket5, StatPercentageOfSocket6, StatPercentageOfSocket7, StatPercentageOfSocket8, "
+        "StatPercentageOfSocket9, StatPercentageOfSocket10, StatPercentEditor1, StatPercentEditor2, StatPercentEditor3, StatPercentEditor4, "
+        "StatPercentEditor5, StatPercentEditor6, StatPercentEditor7, StatPercentEditor8, StatPercentEditor9, StatPercentEditor10, Stackable, "
+        "MaxCount, RequiredAbility, SellPrice, BuyPrice, VendorStackCount, PriceVariance, PriceRandomValue, Flags1, Flags2, Flags3, Flags4, "
+        "FactionRelated, ItemNameDescriptionID, RequiredTransmogHoliday, RequiredHoliday, LimitCategory, GemProperties, SocketMatchEnchantmentId, "
+        "TotemCategoryID, InstanceBound, ZoneBound, ItemSet, ItemRandomSuffixGroupID, RandomSelect, LockID, StartQuestID, PageID, ItemDelay, "
+        "ScalingStatDistributionID, MinFactionID, RequiredSkillRank, RequiredSkill, ItemLevel, AllowableClass, ExpansionID, ArtifactID, SpellWeight, "
+        "SpellWeightCategory, SocketType1, SocketType2, SocketType3, SheatheType, Material, PageMaterialID, LanguageID, Bonding, DamageDamageType, "
+        "StatModifierBonusStat1, StatModifierBonusStat2, StatModifierBonusStat3, StatModifierBonusStat4, StatModifierBonusStat5, "
+        "StatModifierBonusStat6, StatModifierBonusStat7, StatModifierBonusStat8, StatModifierBonusStat9, StatModifierBonusStat10, ContainerSlots, "
+        "MinReputation, RequiredPVPMedal, RequiredPVPRank, RequiredLevel, InventoryType, OverallQualityID FROM item_sparse ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_ITEM_SPARSE, "SELECT ID, Description_lang, Display3_lang, Display2_lang, Display1_lang, Display_lang"
         " FROM item_sparse_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ItemSpec.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_SPEC, "SELECT ID, SpecializationID, MinLevel, MaxLevel, ItemType, PrimaryStat, SecondaryStat FROM item_spec"
+    PrepareStatement(HOTFIX_SEL_ITEM_SPEC, "SELECT ID, MinLevel, MaxLevel, ItemType, PrimaryStat, SecondaryStat, SpecializationID FROM item_spec"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemSpecOverride.db2
     PrepareStatement(HOTFIX_SEL_ITEM_SPEC_OVERRIDE, "SELECT ID, SpecID, ItemID FROM item_spec_override ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemUpgrade.db2
-    PrepareStatement(HOTFIX_SEL_ITEM_UPGRADE, "SELECT ID, CurrencyAmount, PrerequisiteID, CurrencyType, ItemUpgradePathID, ItemLevelIncrement"
+    PrepareStatement(HOTFIX_SEL_ITEM_UPGRADE, "SELECT ID, ItemUpgradePathID, ItemLevelIncrement, PrerequisiteID, CurrencyType, CurrencyAmount"
         " FROM item_upgrade ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // ItemXBonusTree.db2
@@ -598,10 +612,10 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // LfgDungeons.db2
-    PrepareStatement(HOTFIX_SEL_LFG_DUNGEONS, "SELECT ID, Name, Description, Flags, MinGear, MaxLevel, TargetLevelMax, MapID, RandomID, ScenarioID, "
-        "FinalEncounterID, BonusReputationAmount, MentorItemLevel, RequiredPlayerConditionId, MinLevel, TargetLevel, TargetLevelMin, DifficultyID, "
-        "TypeID, Faction, ExpansionLevel, OrderIndex, GroupID, CountTank, CountHealer, CountDamage, MinCountTank, MinCountHealer, MinCountDamage, "
-        "Subtype, MentorCharLevel, IconTextureFileID, RewardsBgTextureFileID, PopupBgTextureFileID FROM lfg_dungeons ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_LFG_DUNGEONS, "SELECT ID, Name, Description, MinLevel, MaxLevel, TypeID, Subtype, Faction, IconTextureFileID, "
+        "RewardsBgTextureFileID, PopupBgTextureFileID, ExpansionLevel, MapID, DifficultyID, MinGear, GroupID, OrderIndex, RequiredPlayerConditionId, "
+        "TargetLevel, TargetLevelMin, TargetLevelMax, RandomID, ScenarioID, FinalEncounterID, CountTank, CountHealer, CountDamage, MinCountTank, "
+        "MinCountHealer, MinCountDamage, BonusReputationAmount, MentorItemLevel, MentorCharLevel, Flags1, Flags2 FROM lfg_dungeons ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_LFG_DUNGEONS, "SELECT ID, Name_lang, Description_lang FROM lfg_dungeons_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // Light.db2
@@ -610,11 +624,12 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // LiquidType.db2
-    PrepareStatement(HOTFIX_SEL_LIQUID_TYPE, "SELECT ID, Name, Texture1, Texture2, Texture3, Texture4, Texture5, Texture6, SpellID, MaxDarkenDepth, "
-        "FogDarkenIntensity, AmbDarkenIntensity, DirDarkenIntensity, ParticleScale, Color1, Color2, Float1, Float2, Float3, `Float4`, Float5, Float6, "
-        "Float7, `Float8`, Float9, Float10, Float11, Float12, Float13, Float14, Float15, Float16, Float17, Float18, `Int1`, `Int2`, `Int3`, `Int4`, "
-        "Flags, LightID, SoundBank, ParticleMovement, ParticleTexSlots, MaterialID, FrameCountTexture1, FrameCountTexture2, FrameCountTexture3, "
-        "FrameCountTexture4, FrameCountTexture5, FrameCountTexture6, SoundID FROM liquid_type ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_LIQUID_TYPE, "SELECT ID, Name, Texture1, Texture2, Texture3, Texture4, Texture5, Texture6, Flags, SoundBank, SoundID, "
+        "SpellID, MaxDarkenDepth, FogDarkenIntensity, AmbDarkenIntensity, DirDarkenIntensity, LightID, ParticleScale, ParticleMovement, "
+        "ParticleTexSlots, MaterialID, MinimapStaticCol, FrameCountTexture1, FrameCountTexture2, FrameCountTexture3, FrameCountTexture4, "
+        "FrameCountTexture5, FrameCountTexture6, Color1, Color2, Float1, Float2, Float3, `Float4`, Float5, Float6, Float7, `Float8`, Float9, Float10, "
+        "Float11, Float12, Float13, Float14, Float15, Float16, Float17, Float18, `Int1`, `Int2`, `Int3`, `Int4`, Coefficient1, Coefficient2, "
+        "Coefficient3, Coefficient4 FROM liquid_type ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Lock.db2
     PrepareStatement(HOTFIX_SEL_LOCK, "SELECT ID, Index1, Index2, Index3, Index4, Index5, Index6, Index7, Index8, Skill1, Skill2, Skill3, Skill4, "
@@ -627,28 +642,28 @@ void HotfixDatabaseConnection::DoPrepareStatements()
 
     // Map.db2
     PrepareStatement(HOTFIX_SEL_MAP, "SELECT ID, Directory, MapName, MapDescription0, MapDescription1, PvpShortDescription, PvpLongDescription, "
-        "Flags1, Flags2, MinimapIconScale, CorpseX, CorpseY, AreaTableID, LoadingScreenID, CorpseMapID, TimeOfDayOverride, ParentMapID, "
-        "CosmeticParentMapID, WindSettingsID, InstanceType, MapType, ExpansionID, MaxPlayers, TimeOffset FROM map ORDER BY ID DESC", CONNECTION_SYNCH);
+        "CorpseX, CorpseY, MapType, InstanceType, ExpansionID, AreaTableID, LoadingScreenID, TimeOfDayOverride, ParentMapID, CosmeticParentMapID, "
+        "TimeOffset, MinimapIconScale, CorpseMapID, MaxPlayers, WindSettingsID, ZmpFileDataID, Flags1, Flags2 FROM map ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_MAP, "SELECT ID, MapName_lang, MapDescription0_lang, MapDescription1_lang, PvpShortDescription_lang, "
         "PvpLongDescription_lang FROM map_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // MapDifficulty.db2
-    PrepareStatement(HOTFIX_SEL_MAP_DIFFICULTY, "SELECT ID, Message, DifficultyID, ResetInterval, MaxPlayers, LockID, Flags, ItemContext, "
-        "ItemContextPickerID, MapID FROM map_difficulty ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_MAP_DIFFICULTY, "SELECT ID, Message, ItemContextPickerID, ContentTuningID, DifficultyID, LockID, ResetInterval, "
+        "MaxPlayers, ItemContext, Flags, MapID FROM map_difficulty ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_MAP_DIFFICULTY, "SELECT ID, Message_lang FROM map_difficulty_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ModifierTree.db2
-    PrepareStatement(HOTFIX_SEL_MODIFIER_TREE, "SELECT ID, Asset, SecondaryAsset, Parent, Type, TertiaryAsset, Operator, Amount FROM modifier_tree"
+    PrepareStatement(HOTFIX_SEL_MODIFIER_TREE, "SELECT ID, Parent, Operator, Amount, Type, Asset, SecondaryAsset, TertiaryAsset FROM modifier_tree"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Mount.db2
-    PrepareStatement(HOTFIX_SEL_MOUNT, "SELECT Name, Description, SourceText, SourceSpellID, MountFlyRideHeight, MountTypeID, Flags, SourceTypeEnum, "
-        "ID, PlayerConditionID, UiModelSceneID FROM mount ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_MOUNT, "SELECT ID, Name_lang, Description_lang, SourceText_lang FROM mount_locale WHERE locale = ?", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_MOUNT, "SELECT Name, SourceText, Description, ID, MountTypeID, Flags, SourceTypeEnum, SourceSpellID, "
+        "PlayerConditionID, MountFlyRideHeight, UiModelSceneID FROM mount ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_MOUNT, "SELECT ID, Name_lang, SourceText_lang, Description_lang FROM mount_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // MountCapability.db2
-    PrepareStatement(HOTFIX_SEL_MOUNT_CAPABILITY, "SELECT ReqSpellKnownID, ModSpellAuraID, ReqRidingSkill, ReqAreaID, ReqMapID, Flags, ID, "
-        "ReqSpellAuraID FROM mount_capability ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_MOUNT_CAPABILITY, "SELECT ID, Flags, ReqRidingSkill, ReqAreaID, ReqSpellAuraID, ReqSpellKnownID, ModSpellAuraID, "
+        "ReqMapID FROM mount_capability ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // MountTypeXCapability.db2
     PrepareStatement(HOTFIX_SEL_MOUNT_TYPE_X_CAPABILITY, "SELECT ID, MountTypeID, MountCapabilityID, OrderIndex FROM mount_type_x_capability"
@@ -658,7 +673,7 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_MOUNT_X_DISPLAY, "SELECT ID, CreatureDisplayInfoID, PlayerConditionID, MountID FROM mount_x_display ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Movie.db2
-    PrepareStatement(HOTFIX_SEL_MOVIE, "SELECT ID, AudioFileDataID, SubtitleFileDataID, Volume, KeyID FROM movie ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_MOVIE, "SELECT ID, Volume, KeyID, AudioFileDataID, SubtitleFileDataID FROM movie ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // NameGen.db2
     PrepareStatement(HOTFIX_SEL_NAME_GEN, "SELECT ID, Name, RaceID, Sex FROM name_gen ORDER BY ID DESC", CONNECTION_SYNCH);
@@ -672,6 +687,10 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     // NamesReservedLocale.db2
     PrepareStatement(HOTFIX_SEL_NAMES_RESERVED_LOCALE, "SELECT ID, Name, LocaleMask FROM names_reserved_locale ORDER BY ID DESC", CONNECTION_SYNCH);
 
+    // NumTalentsAtLevel.db2
+    PrepareStatement(HOTFIX_SEL_NUM_TALENTS_AT_LEVEL, "SELECT ID, NumTalents, NumTalentsDeathKnight, NumTalentsDemonHunter FROM num_talents_at_level"
+        " ORDER BY ID DESC", CONNECTION_SYNCH);
+
     // OverrideSpellData.db2
     PrepareStatement(HOTFIX_SEL_OVERRIDE_SPELL_DATA, "SELECT ID, Spells1, Spells2, Spells3, Spells4, Spells5, Spells6, Spells7, Spells8, Spells9, "
         "Spells10, PlayerActionBarFileDataID, Flags FROM override_spell_data ORDER BY ID DESC", CONNECTION_SYNCH);
@@ -683,35 +702,35 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_PHASE_X_PHASE_GROUP, "SELECT ID, PhaseID, PhaseGroupID FROM phase_x_phase_group ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // PlayerCondition.db2
-    PrepareStatement(HOTFIX_SEL_PLAYER_CONDITION, "SELECT RaceMask, FailureDescription, ID, Flags, MinLevel, MaxLevel, ClassMask, Gender, "
-        "NativeGender, SkillLogic, LanguageID, MinLanguage, MaxLanguage, MaxFactionID, MaxReputation, ReputationLogic, CurrentPvpFaction, MinPVPRank, "
-        "MaxPVPRank, PvpMedal, PrevQuestLogic, CurrQuestLogic, CurrentCompletedQuestLogic, SpellLogic, ItemLogic, ItemFlags, AuraSpellLogic, "
-        "WorldStateExpressionID, WeatherID, PartyStatus, LifetimeMaxPVPRank, AchievementLogic, LfgLogic, AreaLogic, CurrencyLogic, QuestKillID, "
-        "QuestKillLogic, MinExpansionLevel, MaxExpansionLevel, MinExpansionTier, MaxExpansionTier, MinGuildLevel, MaxGuildLevel, PhaseUseFlags, "
-        "PhaseID, PhaseGroupID, MinAvgItemLevel, MaxAvgItemLevel, MinAvgEquippedItemLevel, MaxAvgEquippedItemLevel, ChrSpecializationIndex, "
-        "ChrSpecializationRole, PowerType, PowerTypeComp, PowerTypeValue, ModifierTreeID, WeaponSubclassMask, SkillID1, SkillID2, SkillID3, SkillID4, "
-        "MinSkill1, MinSkill2, MinSkill3, MinSkill4, MaxSkill1, MaxSkill2, MaxSkill3, MaxSkill4, MinFactionID1, MinFactionID2, MinFactionID3, "
-        "MinReputation1, MinReputation2, MinReputation3, PrevQuestID1, PrevQuestID2, PrevQuestID3, PrevQuestID4, CurrQuestID1, CurrQuestID2, "
-        "CurrQuestID3, CurrQuestID4, CurrentCompletedQuestID1, CurrentCompletedQuestID2, CurrentCompletedQuestID3, CurrentCompletedQuestID4, "
-        "SpellID1, SpellID2, SpellID3, SpellID4, ItemID1, ItemID2, ItemID3, ItemID4, ItemCount1, ItemCount2, ItemCount3, ItemCount4, Explored1, "
-        "Explored2, Time1, Time2, AuraSpellID1, AuraSpellID2, AuraSpellID3, AuraSpellID4, AuraStacks1, AuraStacks2, AuraStacks3, AuraStacks4, "
-        "Achievement1, Achievement2, Achievement3, Achievement4, LfgStatus1, LfgStatus2, LfgStatus3, LfgStatus4, LfgCompare1, LfgCompare2, "
-        "LfgCompare3, LfgCompare4, LfgValue1, LfgValue2, LfgValue3, LfgValue4, AreaID1, AreaID2, AreaID3, AreaID4, CurrencyID1, CurrencyID2, "
-        "CurrencyID3, CurrencyID4, CurrencyCount1, CurrencyCount2, CurrencyCount3, CurrencyCount4, QuestKillMonster1, QuestKillMonster2, "
-        "QuestKillMonster3, QuestKillMonster4, QuestKillMonster5, QuestKillMonster6, MovementFlags1, MovementFlags2 FROM player_condition"
-        " ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_PLAYER_CONDITION, "SELECT RaceMask, FailureDescription, ID, MinLevel, MaxLevel, ClassMask, SkillLogic, LanguageID, "
+        "MinLanguage, MaxLanguage, MaxFactionID, MaxReputation, ReputationLogic, CurrentPvpFaction, PvpMedal, PrevQuestLogic, CurrQuestLogic, "
+        "CurrentCompletedQuestLogic, SpellLogic, ItemLogic, ItemFlags, AuraSpellLogic, WorldStateExpressionID, WeatherID, PartyStatus, "
+        "LifetimeMaxPVPRank, AchievementLogic, Gender, NativeGender, AreaLogic, LfgLogic, CurrencyLogic, QuestKillID, QuestKillLogic, "
+        "MinExpansionLevel, MaxExpansionLevel, MinAvgItemLevel, MaxAvgItemLevel, MinAvgEquippedItemLevel, MaxAvgEquippedItemLevel, PhaseUseFlags, "
+        "PhaseID, PhaseGroupID, Flags, ChrSpecializationIndex, ChrSpecializationRole, ModifierTreeID, PowerType, PowerTypeComp, PowerTypeValue, "
+        "WeaponSubclassMask, MaxGuildLevel, MinGuildLevel, MaxExpansionTier, MinExpansionTier, MinPVPRank, MaxPVPRank, SkillID1, SkillID2, SkillID3, "
+        "SkillID4, MinSkill1, MinSkill2, MinSkill3, MinSkill4, MaxSkill1, MaxSkill2, MaxSkill3, MaxSkill4, MinFactionID1, MinFactionID2, "
+        "MinFactionID3, MinReputation1, MinReputation2, MinReputation3, PrevQuestID1, PrevQuestID2, PrevQuestID3, PrevQuestID4, CurrQuestID1, "
+        "CurrQuestID2, CurrQuestID3, CurrQuestID4, CurrentCompletedQuestID1, CurrentCompletedQuestID2, CurrentCompletedQuestID3, "
+        "CurrentCompletedQuestID4, SpellID1, SpellID2, SpellID3, SpellID4, ItemID1, ItemID2, ItemID3, ItemID4, ItemCount1, ItemCount2, ItemCount3, "
+        "ItemCount4, Explored1, Explored2, Time1, Time2, AuraSpellID1, AuraSpellID2, AuraSpellID3, AuraSpellID4, AuraStacks1, AuraStacks2, "
+        "AuraStacks3, AuraStacks4, Achievement1, Achievement2, Achievement3, Achievement4, AreaID1, AreaID2, AreaID3, AreaID4, LfgStatus1, "
+        "LfgStatus2, LfgStatus3, LfgStatus4, LfgCompare1, LfgCompare2, LfgCompare3, LfgCompare4, LfgValue1, LfgValue2, LfgValue3, LfgValue4, "
+        "CurrencyID1, CurrencyID2, CurrencyID3, CurrencyID4, CurrencyCount1, CurrencyCount2, CurrencyCount3, CurrencyCount4, QuestKillMonster1, "
+        "QuestKillMonster2, QuestKillMonster3, QuestKillMonster4, QuestKillMonster5, QuestKillMonster6, MovementFlags1, MovementFlags2"
+        " FROM player_condition ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_PLAYER_CONDITION, "SELECT ID, FailureDescription_lang FROM player_condition_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // PowerDisplay.db2
     PrepareStatement(HOTFIX_SEL_POWER_DISPLAY, "SELECT ID, GlobalStringBaseTag, ActualType, Red, Green, Blue FROM power_display ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // PowerType.db2
-    PrepareStatement(HOTFIX_SEL_POWER_TYPE, "SELECT ID, NameGlobalStringTag, CostGlobalStringTag, RegenPeace, RegenCombat, MaxBasePower, "
-        "RegenInterruptTimeMS, Flags, PowerTypeEnum, MinPower, CenterPower, DefaultPower, DisplayModifier FROM power_type ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_POWER_TYPE, "SELECT ID, NameGlobalStringTag, CostGlobalStringTag, PowerTypeEnum, MinPower, MaxBasePower, CenterPower, "
+        "DefaultPower, DisplayModifier, RegenInterruptTimeMS, RegenPeace, RegenCombat, Flags FROM power_type ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // PrestigeLevelInfo.db2
-    PrepareStatement(HOTFIX_SEL_PRESTIGE_LEVEL_INFO, "SELECT ID, Name, BadgeTextureFileDataID, PrestigeLevel, Flags FROM prestige_level_info"
-        " ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_PRESTIGE_LEVEL_INFO, "SELECT ID, Name, PrestigeLevel, BadgeTextureFileDataID, Flags, AwardedAchievementID"
+        " FROM prestige_level_info ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_PRESTIGE_LEVEL_INFO, "SELECT ID, Name_lang FROM prestige_level_info_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // PvpDifficulty.db2
@@ -720,16 +739,17 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     // PvpItem.db2
     PrepareStatement(HOTFIX_SEL_PVP_ITEM, "SELECT ID, ItemID, ItemLevelDelta FROM pvp_item ORDER BY ID DESC", CONNECTION_SYNCH);
 
-    // PvpReward.db2
-    PrepareStatement(HOTFIX_SEL_PVP_REWARD, "SELECT ID, HonorLevel, PrestigeLevel, RewardPackID FROM pvp_reward ORDER BY ID DESC", CONNECTION_SYNCH);
-
     // PvpTalent.db2
-    PrepareStatement(HOTFIX_SEL_PVP_TALENT, "SELECT ID, Description, SpellID, OverridesSpellID, ActionBarSpellID, TierID, ColumnIndex, Flags, "
-        "ClassID, SpecID, Role FROM pvp_talent ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_PVP_TALENT, "SELECT Description, ID, SpecID, SpellID, OverridesSpellID, Flags, ActionBarSpellID, PvpTalentCategoryID, "
+        "LevelRequired FROM pvp_talent ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_PVP_TALENT, "SELECT ID, Description_lang FROM pvp_talent_locale WHERE locale = ?", CONNECTION_SYNCH);
 
-    // PvpTalentUnlock.db2
-    PrepareStatement(HOTFIX_SEL_PVP_TALENT_UNLOCK, "SELECT ID, TierID, ColumnIndex, HonorLevel FROM pvp_talent_unlock ORDER BY ID DESC", CONNECTION_SYNCH);
+    // PvpTalentCategory.db2
+    PrepareStatement(HOTFIX_SEL_PVP_TALENT_CATEGORY, "SELECT ID, TalentSlotMask FROM pvp_talent_category ORDER BY ID DESC", CONNECTION_SYNCH);
+
+    // PvpTalentSlotUnlock.db2
+    PrepareStatement(HOTFIX_SEL_PVP_TALENT_SLOT_UNLOCK, "SELECT ID, Slot, LevelRequired, DeathKnightLevelRequired, DemonHunterLevelRequired"
+        " FROM pvp_talent_slot_unlock ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // QuestFactionReward.db2
     PrepareStatement(HOTFIX_SEL_QUEST_FACTION_REWARD, "SELECT ID, Difficulty1, Difficulty2, Difficulty3, Difficulty4, Difficulty5, Difficulty6, "
@@ -740,7 +760,7 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         "Difficulty7, Difficulty8, Difficulty9, Difficulty10 FROM quest_money_reward ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // QuestPackageItem.db2
-    PrepareStatement(HOTFIX_SEL_QUEST_PACKAGE_ITEM, "SELECT ID, ItemID, PackageID, DisplayType, ItemQuantity FROM quest_package_item ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_QUEST_PACKAGE_ITEM, "SELECT ID, PackageID, ItemID, ItemQuantity, DisplayType FROM quest_package_item ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // QuestSort.db2
     PrepareStatement(HOTFIX_SEL_QUEST_SORT, "SELECT ID, SortName, UiOrderIndex FROM quest_sort ORDER BY ID DESC", CONNECTION_SYNCH);
@@ -754,11 +774,11 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         "Difficulty8, Difficulty9, Difficulty10 FROM quest_xp ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // RandPropPoints.db2
-    PrepareStatement(HOTFIX_SEL_RAND_PROP_POINTS, "SELECT ID, Epic1, Epic2, Epic3, Epic4, Epic5, Superior1, Superior2, Superior3, Superior4, "
-        "Superior5, Good1, Good2, Good3, Good4, Good5 FROM rand_prop_points ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_RAND_PROP_POINTS, "SELECT ID, DamageReplaceStat, Epic1, Epic2, Epic3, Epic4, Epic5, Superior1, Superior2, Superior3, "
+        "Superior4, Superior5, Good1, Good2, Good3, Good4, Good5 FROM rand_prop_points ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // RewardPack.db2
-    PrepareStatement(HOTFIX_SEL_REWARD_PACK, "SELECT ID, Money, ArtifactXPMultiplier, ArtifactXPDifficulty, ArtifactXPCategoryID, CharTitleID, "
+    PrepareStatement(HOTFIX_SEL_REWARD_PACK, "SELECT ID, CharTitleID, Money, ArtifactXPDifficulty, ArtifactXPMultiplier, ArtifactXPCategoryID, "
         "TreasurePickerID FROM reward_pack ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // RewardPackXCurrencyType.db2
@@ -771,20 +791,17 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     // RulesetItemUpgrade.db2
     PrepareStatement(HOTFIX_SEL_RULESET_ITEM_UPGRADE, "SELECT ID, ItemID, ItemUpgradeID FROM ruleset_item_upgrade ORDER BY ID DESC", CONNECTION_SYNCH);
 
-    // SandboxScaling.db2
-    PrepareStatement(HOTFIX_SEL_SANDBOX_SCALING, "SELECT ID, MinLevel, MaxLevel, Flags FROM sandbox_scaling ORDER BY ID DESC", CONNECTION_SYNCH);
-
     // ScalingStatDistribution.db2
     PrepareStatement(HOTFIX_SEL_SCALING_STAT_DISTRIBUTION, "SELECT ID, PlayerLevelToItemLevelCurveID, MinLevel, MaxLevel"
         " FROM scaling_stat_distribution ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Scenario.db2
-    PrepareStatement(HOTFIX_SEL_SCENARIO, "SELECT ID, Name, AreaTableID, Flags, Type FROM scenario ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SCENARIO, "SELECT ID, Name, AreaTableID, Type, Flags, UiTextureKitID FROM scenario ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_SCENARIO, "SELECT ID, Name_lang FROM scenario_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // ScenarioStep.db2
-    PrepareStatement(HOTFIX_SEL_SCENARIO_STEP, "SELECT ID, Description, Title, ScenarioID, Supersedes, RewardQuestID, OrderIndex, Flags, "
-        "Criteriatreeid, RelatedStep FROM scenario_step ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SCENARIO_STEP, "SELECT ID, Description, Title, ScenarioID, Criteriatreeid, RewardQuestID, RelatedStep, Supersedes, "
+        "OrderIndex, Flags, VisibilityPlayerConditionID, WidgetSetID FROM scenario_step ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_SCENARIO_STEP, "SELECT ID, Description_lang, Title_lang FROM scenario_step_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // SceneScript.db2
@@ -800,81 +817,76 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_SCENE_SCRIPT_TEXT, "SELECT ID, Name, Script FROM scene_script_text ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SkillLine.db2
-    PrepareStatement(HOTFIX_SEL_SKILL_LINE, "SELECT ID, DisplayName, Description, AlternateVerb, Flags, CategoryID, CanLink, SpellIconFileID, "
-        "ParentSkillLineID FROM skill_line ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_SKILL_LINE, "SELECT ID, DisplayName_lang, Description_lang, AlternateVerb_lang FROM skill_line_locale"
-        " WHERE locale = ?", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SKILL_LINE, "SELECT DisplayName, AlternateVerb, Description, HordeDisplayName, OverrideSourceInfoDisplayName, ID, "
+        "CategoryID, SpellIconFileID, CanLink, ParentSkillLineID, ParentTierIndex, Flags, SpellBookSpellID FROM skill_line ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_SKILL_LINE, "SELECT ID, DisplayName_lang, AlternateVerb_lang, Description_lang, HordeDisplayName_lang"
+        " FROM skill_line_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // SkillLineAbility.db2
-    PrepareStatement(HOTFIX_SEL_SKILL_LINE_ABILITY, "SELECT RaceMask, ID, Spell, SupercedesSpell, SkillLine, TrivialSkillLineRankHigh, "
-        "TrivialSkillLineRankLow, UniqueBit, TradeSkillCategoryID, NumSkillUps, ClassMask, MinSkillLineRank, AcquireMethod, Flags"
+    PrepareStatement(HOTFIX_SEL_SKILL_LINE_ABILITY, "SELECT RaceMask, ID, SkillLine, Spell, MinSkillLineRank, ClassMask, SupercedesSpell, "
+        "AcquireMethod, TrivialSkillLineRankHigh, TrivialSkillLineRankLow, Flags, NumSkillUps, UniqueBit, TradeSkillCategoryID, SkillupSkillLineID"
         " FROM skill_line_ability ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SkillRaceClassInfo.db2
-    PrepareStatement(HOTFIX_SEL_SKILL_RACE_CLASS_INFO, "SELECT ID, RaceMask, SkillID, Flags, SkillTierID, Availability, MinLevel, ClassMask"
+    PrepareStatement(HOTFIX_SEL_SKILL_RACE_CLASS_INFO, "SELECT ID, RaceMask, SkillID, ClassMask, Flags, Availability, MinLevel, SkillTierID"
         " FROM skill_race_class_info ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SoundKit.db2
-    PrepareStatement(HOTFIX_SEL_SOUND_KIT, "SELECT ID, VolumeFloat, MinDistance, DistanceCutoff, Flags, SoundEntriesAdvancedID, SoundType, "
-        "DialogType, EAXDef, VolumeVariationPlus, VolumeVariationMinus, PitchVariationPlus, PitchVariationMinus, PitchAdjust, BusOverwriteID, "
-        "MaxInstances FROM sound_kit ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SOUND_KIT, "SELECT ID, SoundType, VolumeFloat, Flags, MinDistance, DistanceCutoff, EAXDef, SoundKitAdvancedID, "
+        "VolumeVariationPlus, VolumeVariationMinus, PitchVariationPlus, PitchVariationMinus, DialogType, PitchAdjust, BusOverwriteID, MaxInstances"
+        " FROM sound_kit ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpecializationSpells.db2
-    PrepareStatement(HOTFIX_SEL_SPECIALIZATION_SPELLS, "SELECT Description, SpellID, OverridesSpellID, SpecID, DisplayOrder, ID"
+    PrepareStatement(HOTFIX_SEL_SPECIALIZATION_SPELLS, "SELECT Description, ID, SpecID, SpellID, OverridesSpellID, DisplayOrder"
         " FROM specialization_spells ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_SPECIALIZATION_SPELLS, "SELECT ID, Description_lang FROM specialization_spells_locale WHERE locale = ?", CONNECTION_SYNCH);
 
-    // Spell.db2
-    PrepareStatement(HOTFIX_SEL_SPELL, "SELECT ID, Name, NameSubtext, Description, AuraDescription FROM spell ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_SPELL, "SELECT ID, Name_lang, NameSubtext_lang, Description_lang, AuraDescription_lang FROM spell_locale"
-        " WHERE locale = ?", CONNECTION_SYNCH);
-
     // SpellAuraOptions.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_AURA_OPTIONS, "SELECT ID, ProcCharges, ProcTypeMask, ProcCategoryRecovery, CumulativeAura, "
-        "SpellProcsPerMinuteID, DifficultyID, ProcChance, SpellID FROM spell_aura_options ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_AURA_OPTIONS, "SELECT ID, DifficultyID, CumulativeAura, ProcCategoryRecovery, ProcChance, ProcCharges, "
+        "SpellProcsPerMinuteID, ProcTypeMask1, ProcTypeMask2, SpellID FROM spell_aura_options ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellAuraRestrictions.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_AURA_RESTRICTIONS, "SELECT ID, CasterAuraSpell, TargetAuraSpell, ExcludeCasterAuraSpell, "
-        "ExcludeTargetAuraSpell, DifficultyID, CasterAuraState, TargetAuraState, ExcludeCasterAuraState, ExcludeTargetAuraState, SpellID"
+    PrepareStatement(HOTFIX_SEL_SPELL_AURA_RESTRICTIONS, "SELECT ID, DifficultyID, CasterAuraState, TargetAuraState, ExcludeCasterAuraState, "
+        "ExcludeTargetAuraState, CasterAuraSpell, TargetAuraSpell, ExcludeCasterAuraSpell, ExcludeTargetAuraSpell, SpellID"
         " FROM spell_aura_restrictions ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellCastTimes.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_CAST_TIMES, "SELECT ID, Base, Minimum, PerLevel FROM spell_cast_times ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_CAST_TIMES, "SELECT ID, Base, PerLevel, Minimum FROM spell_cast_times ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellCastingRequirements.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_CASTING_REQUIREMENTS, "SELECT ID, SpellID, MinFactionID, RequiredAreasID, RequiresSpellFocus, "
-        "FacingCasterFlags, MinReputation, RequiredAuraVision FROM spell_casting_requirements ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_CASTING_REQUIREMENTS, "SELECT ID, SpellID, FacingCasterFlags, MinFactionID, MinReputation, RequiredAreasID, "
+        "RequiredAuraVision, RequiresSpellFocus FROM spell_casting_requirements ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellCategories.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_CATEGORIES, "SELECT ID, Category, StartRecoveryCategory, ChargeCategory, DifficultyID, DefenseType, DispelType, "
-        "Mechanic, PreventionType, SpellID FROM spell_categories ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_CATEGORIES, "SELECT ID, DifficultyID, Category, DefenseType, DispelType, Mechanic, PreventionType, "
+        "StartRecoveryCategory, ChargeCategory, SpellID FROM spell_categories ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellCategory.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_CATEGORY, "SELECT ID, Name, ChargeRecoveryTime, Flags, UsesPerWeek, MaxCharges, TypeMask FROM spell_category"
+    PrepareStatement(HOTFIX_SEL_SPELL_CATEGORY, "SELECT ID, Name, Flags, UsesPerWeek, MaxCharges, ChargeRecoveryTime, TypeMask FROM spell_category"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_SPELL_CATEGORY, "SELECT ID, Name_lang FROM spell_category_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // SpellClassOptions.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_CLASS_OPTIONS, "SELECT ID, SpellID, SpellClassMask1, SpellClassMask2, SpellClassMask3, SpellClassMask4, "
-        "SpellClassSet, ModalNextSpell FROM spell_class_options ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_CLASS_OPTIONS, "SELECT ID, SpellID, ModalNextSpell, SpellClassSet, SpellClassMask1, SpellClassMask2, "
+        "SpellClassMask3, SpellClassMask4 FROM spell_class_options ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellCooldowns.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_COOLDOWNS, "SELECT ID, CategoryRecoveryTime, RecoveryTime, StartRecoveryTime, DifficultyID, SpellID"
+    PrepareStatement(HOTFIX_SEL_SPELL_COOLDOWNS, "SELECT ID, DifficultyID, CategoryRecoveryTime, RecoveryTime, StartRecoveryTime, SpellID"
         " FROM spell_cooldowns ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellDuration.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_DURATION, "SELECT ID, Duration, MaxDuration, DurationPerLevel FROM spell_duration ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_DURATION, "SELECT ID, Duration, DurationPerLevel, MaxDuration FROM spell_duration ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellEffect.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_EFFECT, "SELECT ID, Effect, EffectBasePoints, EffectIndex, EffectAura, DifficultyID, EffectAmplitude, "
-        "EffectAuraPeriod, EffectBonusCoefficient, EffectChainAmplitude, EffectChainTargets, EffectDieSides, EffectItemType, EffectMechanic, "
-        "EffectPointsPerResource, EffectRealPointsPerLevel, EffectTriggerSpell, EffectPosFacing, EffectAttributes, BonusCoefficientFromAP, "
-        "PvpMultiplier, Coefficient, Variance, ResourceCoefficient, GroupSizeBasePointsCoefficient, EffectSpellClassMask1, EffectSpellClassMask2, "
-        "EffectSpellClassMask3, EffectSpellClassMask4, EffectMiscValue1, EffectMiscValue2, EffectRadiusIndex1, EffectRadiusIndex2, ImplicitTarget1, "
+    PrepareStatement(HOTFIX_SEL_SPELL_EFFECT, "SELECT ID, DifficultyID, EffectIndex, Effect, EffectAmplitude, EffectAttributes, EffectAura, "
+        "EffectAuraPeriod, EffectBonusCoefficient, EffectChainAmplitude, EffectChainTargets, EffectItemType, EffectMechanic, EffectPointsPerResource, "
+        "EffectPosFacing, EffectRealPointsPerLevel, EffectTriggerSpell, BonusCoefficientFromAP, PvpMultiplier, Coefficient, Variance, "
+        "ResourceCoefficient, GroupSizeBasePointsCoefficient, EffectBasePoints, EffectMiscValue1, EffectMiscValue2, EffectRadiusIndex1, "
+        "EffectRadiusIndex2, EffectSpellClassMask1, EffectSpellClassMask2, EffectSpellClassMask3, EffectSpellClassMask4, ImplicitTarget1, "
         "ImplicitTarget2, SpellID FROM spell_effect ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellEquippedItems.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_EQUIPPED_ITEMS, "SELECT ID, SpellID, EquippedItemInvTypes, EquippedItemSubclass, EquippedItemClass"
+    PrepareStatement(HOTFIX_SEL_SPELL_EQUIPPED_ITEMS, "SELECT ID, SpellID, EquippedItemClass, EquippedItemInvTypes, EquippedItemSubclass"
         " FROM spell_equipped_items ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellFocusObject.db2
@@ -886,15 +898,15 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         "ChannelInterruptFlags1, ChannelInterruptFlags2, SpellID FROM spell_interrupts ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellItemEnchantment.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT, "SELECT ID, Name, EffectArg1, EffectArg2, EffectArg3, EffectScalingPoints1, "
-        "EffectScalingPoints2, EffectScalingPoints3, TransmogCost, IconFileDataID, EffectPointsMin1, EffectPointsMin2, EffectPointsMin3, ItemVisual, "
-        "Flags, RequiredSkillID, RequiredSkillRank, ItemLevel, Charges, Effect1, Effect2, Effect3, ConditionID, MinLevel, MaxLevel, ScalingClass, "
-        "ScalingClassRestricted, TransmogPlayerConditionID FROM spell_item_enchantment ORDER BY ID DESC", CONNECTION_SYNCH);
-    PREPARE_LOCALE_STMT(HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT, "SELECT ID, Name_lang FROM spell_item_enchantment_locale WHERE locale = ?", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT, "SELECT ID, Name, HordeName, EffectArg1, EffectArg2, EffectArg3, EffectScalingPoints1, "
+        "EffectScalingPoints2, EffectScalingPoints3, TransmogCost, IconFileDataID, TransmogPlayerConditionID, EffectPointsMin1, EffectPointsMin2, "
+        "EffectPointsMin3, ItemVisual, Flags, RequiredSkillID, RequiredSkillRank, ItemLevel, Charges, Effect1, Effect2, Effect3, ScalingClass, "
+        "ScalingClassRestricted, ConditionID, MinLevel, MaxLevel FROM spell_item_enchantment ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT, "SELECT ID, Name_lang, HordeName_lang FROM spell_item_enchantment_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // SpellItemEnchantmentCondition.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT_CONDITION, "SELECT ID, LtOperand1, LtOperand2, LtOperand3, LtOperand4, LtOperand5, "
-        "LtOperandType1, LtOperandType2, LtOperandType3, LtOperandType4, LtOperandType5, Operator1, Operator2, Operator3, Operator4, Operator5, "
+    PrepareStatement(HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT_CONDITION, "SELECT ID, LtOperandType1, LtOperandType2, LtOperandType3, LtOperandType4, "
+        "LtOperandType5, LtOperand1, LtOperand2, LtOperand3, LtOperand4, LtOperand5, Operator1, Operator2, Operator3, Operator4, Operator5, "
         "RtOperandType1, RtOperandType2, RtOperandType3, RtOperandType4, RtOperandType5, RtOperand1, RtOperand2, RtOperand3, RtOperand4, RtOperand5, "
         "Logic1, Logic2, Logic3, Logic4, Logic5 FROM spell_item_enchantment_condition ORDER BY ID DESC", CONNECTION_SYNCH);
 
@@ -902,33 +914,38 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_SPELL_LEARN_SPELL, "SELECT ID, SpellID, LearnSpellID, OverridesSpellID FROM spell_learn_spell ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellLevels.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_LEVELS, "SELECT ID, BaseLevel, MaxLevel, SpellLevel, DifficultyID, MaxPassiveAuraLevel, SpellID"
+    PrepareStatement(HOTFIX_SEL_SPELL_LEVELS, "SELECT ID, DifficultyID, BaseLevel, MaxLevel, SpellLevel, MaxPassiveAuraLevel, SpellID"
         " FROM spell_levels ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellMisc.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_MISC, "SELECT ID, CastingTimeIndex, DurationIndex, RangeIndex, SchoolMask, SpellIconFileDataID, Speed, "
-        "ActiveIconFileDataID, LaunchDelay, DifficultyID, Attributes1, Attributes2, Attributes3, Attributes4, Attributes5, Attributes6, Attributes7, "
-        "Attributes8, Attributes9, Attributes10, Attributes11, Attributes12, Attributes13, Attributes14, SpellID FROM spell_misc ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_MISC, "SELECT ID, DifficultyID, CastingTimeIndex, DurationIndex, RangeIndex, SchoolMask, Speed, LaunchDelay, "
+        "MinDuration, SpellIconFileDataID, ActiveIconFileDataID, Attributes1, Attributes2, Attributes3, Attributes4, Attributes5, Attributes6, "
+        "Attributes7, Attributes8, Attributes9, Attributes10, Attributes11, Attributes12, Attributes13, Attributes14, SpellID FROM spell_misc"
+        " ORDER BY ID DESC", CONNECTION_SYNCH);
+
+    // SpellName.db2
+    PrepareStatement(HOTFIX_SEL_SPELL_NAME, "SELECT ID, Name FROM spell_name ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_SPELL_NAME, "SELECT ID, Name_lang FROM spell_name_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // SpellPower.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_POWER, "SELECT ManaCost, PowerCostPct, PowerPctPerSecond, RequiredAuraSpellID, PowerCostMaxPct, OrderIndex, "
-        "PowerType, ID, ManaCostPerLevel, ManaPerSecond, OptionalCost, PowerDisplayID, AltPowerBarID, SpellID FROM spell_power ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_POWER, "SELECT ID, OrderIndex, ManaCost, ManaCostPerLevel, ManaPerSecond, PowerDisplayID, AltPowerBarID, "
+        "PowerCostPct, PowerCostMaxPct, PowerPctPerSecond, PowerType, RequiredAuraSpellID, OptionalCost, SpellID FROM spell_power ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellPowerDifficulty.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_POWER_DIFFICULTY, "SELECT DifficultyID, OrderIndex, ID FROM spell_power_difficulty ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_POWER_DIFFICULTY, "SELECT ID, DifficultyID, OrderIndex FROM spell_power_difficulty ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellProcsPerMinute.db2
     PrepareStatement(HOTFIX_SEL_SPELL_PROCS_PER_MINUTE, "SELECT ID, BaseProcRate, Flags FROM spell_procs_per_minute ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellProcsPerMinuteMod.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_PROCS_PER_MINUTE_MOD, "SELECT ID, Coeff, Param, Type, SpellProcsPerMinuteID FROM spell_procs_per_minute_mod"
+    PrepareStatement(HOTFIX_SEL_SPELL_PROCS_PER_MINUTE_MOD, "SELECT ID, Type, Param, Coeff, SpellProcsPerMinuteID FROM spell_procs_per_minute_mod"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellRadius.db2
     PrepareStatement(HOTFIX_SEL_SPELL_RADIUS, "SELECT ID, Radius, RadiusPerLevel, RadiusMin, RadiusMax FROM spell_radius ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellRange.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_RANGE, "SELECT ID, DisplayName, DisplayNameShort, RangeMin1, RangeMin2, RangeMax1, RangeMax2, Flags"
+    PrepareStatement(HOTFIX_SEL_SPELL_RANGE, "SELECT ID, DisplayName, DisplayNameShort, Flags, RangeMin1, RangeMin2, RangeMax1, RangeMax2"
         " FROM spell_range ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_SPELL_RANGE, "SELECT ID, DisplayName_lang, DisplayNameShort_lang FROM spell_range_locale WHERE locale = ?", CONNECTION_SYNCH);
 
@@ -938,72 +955,71 @@ void HotfixDatabaseConnection::DoPrepareStatements()
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellScaling.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_SCALING, "SELECT ID, SpellID, ScalesFromItemLevel, Class, MinScalingLevel, MaxScalingLevel FROM spell_scaling"
+    PrepareStatement(HOTFIX_SEL_SPELL_SCALING, "SELECT ID, SpellID, Class, MinScalingLevel, MaxScalingLevel, ScalesFromItemLevel FROM spell_scaling"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellShapeshift.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_SHAPESHIFT, "SELECT ID, SpellID, ShapeshiftExclude1, ShapeshiftExclude2, ShapeshiftMask1, ShapeshiftMask2, "
-        "StanceBarOrder FROM spell_shapeshift ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_SHAPESHIFT, "SELECT ID, SpellID, StanceBarOrder, ShapeshiftExclude1, ShapeshiftExclude2, ShapeshiftMask1, "
+        "ShapeshiftMask2 FROM spell_shapeshift ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellShapeshiftForm.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_SHAPESHIFT_FORM, "SELECT ID, Name, DamageVariance, Flags, CombatRoundTime, MountTypeID, CreatureType, "
-        "BonusActionBar, AttackIconFileID, CreatureDisplayID1, CreatureDisplayID2, CreatureDisplayID3, CreatureDisplayID4, PresetSpellID1, "
-        "PresetSpellID2, PresetSpellID3, PresetSpellID4, PresetSpellID5, PresetSpellID6, PresetSpellID7, PresetSpellID8 FROM spell_shapeshift_form"
-        " ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_SHAPESHIFT_FORM, "SELECT ID, Name, CreatureType, Flags, AttackIconFileID, BonusActionBar, CombatRoundTime, "
+        "DamageVariance, MountTypeID, CreatureDisplayID1, CreatureDisplayID2, CreatureDisplayID3, CreatureDisplayID4, PresetSpellID1, PresetSpellID2, "
+        "PresetSpellID3, PresetSpellID4, PresetSpellID5, PresetSpellID6, PresetSpellID7, PresetSpellID8 FROM spell_shapeshift_form ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_SPELL_SHAPESHIFT_FORM, "SELECT ID, Name_lang FROM spell_shapeshift_form_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // SpellTargetRestrictions.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_TARGET_RESTRICTIONS, "SELECT ID, ConeDegrees, Width, Targets, TargetCreatureType, DifficultyID, MaxTargets, "
-        "MaxTargetLevel, SpellID FROM spell_target_restrictions ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SPELL_TARGET_RESTRICTIONS, "SELECT ID, DifficultyID, ConeDegrees, MaxTargets, MaxTargetLevel, TargetCreatureType, "
+        "Targets, Width, SpellID FROM spell_target_restrictions ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellTotems.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_TOTEMS, "SELECT ID, SpellID, Totem1, Totem2, RequiredTotemCategoryID1, RequiredTotemCategoryID2"
+    PrepareStatement(HOTFIX_SEL_SPELL_TOTEMS, "SELECT ID, SpellID, RequiredTotemCategoryID1, RequiredTotemCategoryID2, Totem1, Totem2"
         " FROM spell_totems ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SpellXSpellVisual.db2
-    PrepareStatement(HOTFIX_SEL_SPELL_X_SPELL_VISUAL, "SELECT SpellVisualID, ID, Probability, CasterPlayerConditionID, CasterUnitConditionID, "
-        "ViewerPlayerConditionID, ViewerUnitConditionID, SpellIconFileID, ActiveIconFileID, Flags, DifficultyID, Priority, SpellID"
+    PrepareStatement(HOTFIX_SEL_SPELL_X_SPELL_VISUAL, "SELECT ID, DifficultyID, SpellVisualID, Probability, Flags, Priority, SpellIconFileID, "
+        "ActiveIconFileID, ViewerUnitConditionID, ViewerPlayerConditionID, CasterUnitConditionID, CasterPlayerConditionID, SpellID"
         " FROM spell_x_spell_visual ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // SummonProperties.db2
-    PrepareStatement(HOTFIX_SEL_SUMMON_PROPERTIES, "SELECT ID, Flags, Control, Faction, Title, Slot FROM summon_properties ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_SUMMON_PROPERTIES, "SELECT ID, Control, Faction, Title, Slot, Flags FROM summon_properties ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // TactKey.db2
     PrepareStatement(HOTFIX_SEL_TACT_KEY, "SELECT ID, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8, Key9, Key10, Key11, Key12, Key13, Key14, Key15, "
         "Key16 FROM tact_key ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // Talent.db2
-    PrepareStatement(HOTFIX_SEL_TALENT, "SELECT ID, Description, SpellID, OverridesSpellID, SpecID, TierID, ColumnIndex, Flags, CategoryMask1, "
-        "CategoryMask2, ClassID FROM talent ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_TALENT, "SELECT ID, Description, TierID, Flags, ColumnIndex, ClassID, SpecID, SpellID, OverridesSpellID, "
+        "CategoryMask1, CategoryMask2 FROM talent ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_TALENT, "SELECT ID, Description_lang FROM talent_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // TaxiNodes.db2
-    PrepareStatement(HOTFIX_SEL_TAXI_NODES, "SELECT ID, Name, PosX, PosY, PosZ, MountCreatureID1, MountCreatureID2, MapOffsetX, MapOffsetY, Facing, "
-        "FlightMapOffsetX, FlightMapOffsetY, ContinentID, ConditionID, CharacterBitNumber, Flags, UiTextureKitID, SpecialIconConditionID"
-        " FROM taxi_nodes ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_TAXI_NODES, "SELECT Name, PosX, PosY, PosZ, MapOffsetX, MapOffsetY, FlightMapOffsetX, FlightMapOffsetY, ID, "
+        "ContinentID, ConditionID, CharacterBitNumber, Flags, UiTextureKitID, Facing, SpecialIconConditionID, VisibilityConditionID, "
+        "MountCreatureID1, MountCreatureID2 FROM taxi_nodes ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_TAXI_NODES, "SELECT ID, Name_lang FROM taxi_nodes_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // TaxiPath.db2
-    PrepareStatement(HOTFIX_SEL_TAXI_PATH, "SELECT FromTaxiNode, ToTaxiNode, ID, Cost FROM taxi_path ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_TAXI_PATH, "SELECT ID, FromTaxiNode, ToTaxiNode, Cost FROM taxi_path ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // TaxiPathNode.db2
-    PrepareStatement(HOTFIX_SEL_TAXI_PATH_NODE, "SELECT LocX, LocY, LocZ, PathID, ContinentID, NodeIndex, ID, Flags, Delay, ArrivalEventID, "
+    PrepareStatement(HOTFIX_SEL_TAXI_PATH_NODE, "SELECT LocX, LocY, LocZ, ID, PathID, NodeIndex, ContinentID, Flags, Delay, ArrivalEventID, "
         "DepartureEventID FROM taxi_path_node ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // TotemCategory.db2
-    PrepareStatement(HOTFIX_SEL_TOTEM_CATEGORY, "SELECT ID, Name, TotemCategoryMask, TotemCategoryType FROM totem_category ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_TOTEM_CATEGORY, "SELECT ID, Name, TotemCategoryType, TotemCategoryMask FROM totem_category ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_TOTEM_CATEGORY, "SELECT ID, Name_lang FROM totem_category_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // Toy.db2
-    PrepareStatement(HOTFIX_SEL_TOY, "SELECT SourceText, ItemID, Flags, SourceTypeEnum, ID FROM toy ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_TOY, "SELECT SourceText, ID, ItemID, Flags, SourceTypeEnum FROM toy ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_TOY, "SELECT ID, SourceText_lang FROM toy_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // TransmogHoliday.db2
     PrepareStatement(HOTFIX_SEL_TRANSMOG_HOLIDAY, "SELECT ID, RequiredTransmogHoliday FROM transmog_holiday ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // TransmogSet.db2
-    PrepareStatement(HOTFIX_SEL_TRANSMOG_SET, "SELECT Name, ParentTransmogSetID, UiOrder, ExpansionID, ID, Flags, TrackingQuestID, ClassMask, "
-        "ItemNameDescriptionID, TransmogSetGroupID FROM transmog_set ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_TRANSMOG_SET, "SELECT Name, ID, ClassMask, TrackingQuestID, Flags, TransmogSetGroupID, ItemNameDescriptionID, "
+        "ParentTransmogSetID, ExpansionID, UiOrder FROM transmog_set ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_TRANSMOG_SET, "SELECT ID, Name_lang FROM transmog_set_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // TransmogSetGroup.db2
@@ -1014,64 +1030,68 @@ void HotfixDatabaseConnection::DoPrepareStatements()
     PrepareStatement(HOTFIX_SEL_TRANSMOG_SET_ITEM, "SELECT ID, TransmogSetID, ItemModifiedAppearanceID, Flags FROM transmog_set_item ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // TransportAnimation.db2
-    PrepareStatement(HOTFIX_SEL_TRANSPORT_ANIMATION, "SELECT ID, TimeIndex, PosX, PosY, PosZ, SequenceID, TransportID FROM transport_animation"
+    PrepareStatement(HOTFIX_SEL_TRANSPORT_ANIMATION, "SELECT ID, PosX, PosY, PosZ, SequenceID, TimeIndex, TransportID FROM transport_animation"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // TransportRotation.db2
-    PrepareStatement(HOTFIX_SEL_TRANSPORT_ROTATION, "SELECT ID, TimeIndex, Rot1, Rot2, Rot3, Rot4, GameObjectsID FROM transport_rotation"
+    PrepareStatement(HOTFIX_SEL_TRANSPORT_ROTATION, "SELECT ID, Rot1, Rot2, Rot3, Rot4, TimeIndex, GameObjectsID FROM transport_rotation"
+        " ORDER BY ID DESC", CONNECTION_SYNCH);
+
+    // UiMap.db2
+    PrepareStatement(HOTFIX_SEL_UI_MAP, "SELECT Name, ID, ParentUiMapID, Flags, System, Type, LevelRangeMin, LevelRangeMax, BountySetID, "
+        "BountyDisplayLocation, VisibilityPlayerConditionID, HelpTextPosition, BkgAtlasID FROM ui_map ORDER BY ID DESC", CONNECTION_SYNCH);
+    PREPARE_LOCALE_STMT(HOTFIX_SEL_UI_MAP, "SELECT ID, Name_lang FROM ui_map_locale WHERE locale = ?", CONNECTION_SYNCH);
+
+    // UiMapAssignment.db2
+    PrepareStatement(HOTFIX_SEL_UI_MAP_ASSIGNMENT, "SELECT UiMinX, UiMinY, UiMaxX, UiMaxY, Region1X, Region1Y, Region1Z, Region2X, Region2Y, "
+        "Region2Z, ID, UiMapID, OrderIndex, MapID, AreaID, WmoDoodadPlacementID, WmoGroupID FROM ui_map_assignment ORDER BY ID DESC", CONNECTION_SYNCH);
+
+    // UiMapLink.db2
+    PrepareStatement(HOTFIX_SEL_UI_MAP_LINK, "SELECT UiMinX, UiMinY, UiMaxX, UiMaxY, ID, ParentUiMapID, OrderIndex, ChildUiMapID FROM ui_map_link"
         " ORDER BY ID DESC", CONNECTION_SYNCH);
 
+    // UiMapXMapArt.db2
+    PrepareStatement(HOTFIX_SEL_UI_MAP_X_MAP_ART, "SELECT ID, PhaseID, UiMapArtID, UiMapID FROM ui_map_x_map_art ORDER BY ID DESC", CONNECTION_SYNCH);
+
     // UnitPowerBar.db2
-    PrepareStatement(HOTFIX_SEL_UNIT_POWER_BAR, "SELECT ID, Name, Cost, OutOfError, ToolTip, RegenerationPeace, RegenerationCombat, FileDataID1, "
-        "FileDataID2, FileDataID3, FileDataID4, FileDataID5, FileDataID6, Color1, Color2, Color3, Color4, Color5, Color6, StartInset, EndInset, "
-        "StartPower, Flags, CenterPower, BarType, MinPower, MaxPower FROM unit_power_bar ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_UNIT_POWER_BAR, "SELECT ID, Name, Cost, OutOfError, ToolTip, MinPower, MaxPower, StartPower, CenterPower, "
+        "RegenerationPeace, RegenerationCombat, BarType, Flags, StartInset, EndInset, FileDataID1, FileDataID2, FileDataID3, FileDataID4, "
+        "FileDataID5, FileDataID6, Color1, Color2, Color3, Color4, Color5, Color6 FROM unit_power_bar ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_UNIT_POWER_BAR, "SELECT ID, Name_lang, Cost_lang, OutOfError_lang, ToolTip_lang FROM unit_power_bar_locale"
         " WHERE locale = ?", CONNECTION_SYNCH);
 
     // Vehicle.db2
-    PrepareStatement(HOTFIX_SEL_VEHICLE, "SELECT ID, Flags, TurnSpeed, PitchSpeed, PitchMin, PitchMax, MouseLookOffsetPitch, CameraFadeDistScalarMin, "
-        "CameraFadeDistScalarMax, CameraPitchOffset, FacingLimitRight, FacingLimitLeft, CameraYawOffset, SeatID1, SeatID2, SeatID3, SeatID4, SeatID5, "
-        "SeatID6, SeatID7, SeatID8, VehicleUIIndicatorID, PowerDisplayID1, PowerDisplayID2, PowerDisplayID3, FlagsB, UiLocomotionType, "
-        "MissileTargetingID FROM vehicle ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_VEHICLE, "SELECT ID, Flags, FlagsB, TurnSpeed, PitchSpeed, PitchMin, PitchMax, MouseLookOffsetPitch, "
+        "CameraFadeDistScalarMin, CameraFadeDistScalarMax, CameraPitchOffset, FacingLimitRight, FacingLimitLeft, CameraYawOffset, UiLocomotionType, "
+        "VehicleUIIndicatorID, MissileTargetingID, SeatID1, SeatID2, SeatID3, SeatID4, SeatID5, SeatID6, SeatID7, SeatID8, PowerDisplayID1, "
+        "PowerDisplayID2, PowerDisplayID3 FROM vehicle ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // VehicleSeat.db2
-    PrepareStatement(HOTFIX_SEL_VEHICLE_SEAT, "SELECT ID, Flags, FlagsB, FlagsC, AttachmentOffsetX, AttachmentOffsetY, AttachmentOffsetZ, "
-        "EnterPreDelay, EnterSpeed, EnterGravity, EnterMinDuration, EnterMaxDuration, EnterMinArcHeight, EnterMaxArcHeight, ExitPreDelay, ExitSpeed, "
-        "ExitGravity, ExitMinDuration, ExitMaxDuration, ExitMinArcHeight, ExitMaxArcHeight, PassengerYaw, PassengerPitch, PassengerRoll, "
-        "VehicleEnterAnimDelay, VehicleExitAnimDelay, CameraEnteringDelay, CameraEnteringDuration, CameraExitingDelay, CameraExitingDuration, "
-        "CameraOffsetX, CameraOffsetY, CameraOffsetZ, CameraPosChaseRate, CameraFacingChaseRate, CameraEnteringZoom, CameraSeatZoomMin, "
-        "CameraSeatZoomMax, UiSkinFileDataID, EnterAnimStart, EnterAnimLoop, RideAnimStart, RideAnimLoop, RideUpperAnimStart, RideUpperAnimLoop, "
-        "ExitAnimStart, ExitAnimLoop, ExitAnimEnd, VehicleEnterAnim, VehicleExitAnim, VehicleRideAnimLoop, EnterAnimKitID, RideAnimKitID, "
-        "ExitAnimKitID, VehicleEnterAnimKitID, VehicleRideAnimKitID, VehicleExitAnimKitID, CameraModeID, AttachmentID, PassengerAttachmentID, "
-        "VehicleEnterAnimBone, VehicleExitAnimBone, VehicleRideAnimLoopBone, VehicleAbilityDisplay, EnterUISoundID, ExitUISoundID FROM vehicle_seat"
-        " ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_VEHICLE_SEAT, "SELECT ID, AttachmentOffsetX, AttachmentOffsetY, AttachmentOffsetZ, CameraOffsetX, CameraOffsetY, "
+        "CameraOffsetZ, Flags, FlagsB, FlagsC, AttachmentID, EnterPreDelay, EnterSpeed, EnterGravity, EnterMinDuration, EnterMaxDuration, "
+        "EnterMinArcHeight, EnterMaxArcHeight, EnterAnimStart, EnterAnimLoop, RideAnimStart, RideAnimLoop, RideUpperAnimStart, RideUpperAnimLoop, "
+        "ExitPreDelay, ExitSpeed, ExitGravity, ExitMinDuration, ExitMaxDuration, ExitMinArcHeight, ExitMaxArcHeight, ExitAnimStart, ExitAnimLoop, "
+        "ExitAnimEnd, VehicleEnterAnim, VehicleEnterAnimBone, VehicleExitAnim, VehicleExitAnimBone, VehicleRideAnimLoop, VehicleRideAnimLoopBone, "
+        "PassengerAttachmentID, PassengerYaw, PassengerPitch, PassengerRoll, VehicleEnterAnimDelay, VehicleExitAnimDelay, VehicleAbilityDisplay, "
+        "EnterUISoundID, ExitUISoundID, UiSkinFileDataID, CameraEnteringDelay, CameraEnteringDuration, CameraExitingDelay, CameraExitingDuration, "
+        "CameraPosChaseRate, CameraFacingChaseRate, CameraEnteringZoom, CameraSeatZoomMin, CameraSeatZoomMax, EnterAnimKitID, RideAnimKitID, "
+        "ExitAnimKitID, VehicleEnterAnimKitID, VehicleRideAnimKitID, VehicleExitAnimKitID, CameraModeID FROM vehicle_seat ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // WmoAreaTable.db2
-    PrepareStatement(HOTFIX_SEL_WMO_AREA_TABLE, "SELECT AreaName, WmoGroupID, AmbienceID, ZoneMusic, IntroSound, AreaTableID, UwIntroSound, "
-        "UwAmbience, NameSetID, SoundProviderPref, SoundProviderPrefUnderwater, Flags, ID, UwZoneMusic, WmoID FROM wmo_area_table ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_WMO_AREA_TABLE, "SELECT AreaName, ID, WmoID, NameSetID, WmoGroupID, SoundProviderPref, SoundProviderPrefUnderwater, "
+        "AmbienceID, UwAmbience, ZoneMusic, UwZoneMusic, IntroSound, UwIntroSound, AreaTableID, Flags FROM wmo_area_table ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_WMO_AREA_TABLE, "SELECT ID, AreaName_lang FROM wmo_area_table_locale WHERE locale = ?", CONNECTION_SYNCH);
 
     // WorldEffect.db2
-    PrepareStatement(HOTFIX_SEL_WORLD_EFFECT, "SELECT ID, TargetAsset, CombatConditionID, TargetType, WhenToDisplay, QuestFeedbackEffectID, "
-        "PlayerConditionID FROM world_effect ORDER BY ID DESC", CONNECTION_SYNCH);
-
-    // WorldMapArea.db2
-    PrepareStatement(HOTFIX_SEL_WORLD_MAP_AREA, "SELECT AreaName, LocLeft, LocRight, LocTop, LocBottom, Flags, MapID, AreaID, DisplayMapID, "
-        "DefaultDungeonFloor, ParentWorldMapID, LevelRangeMin, LevelRangeMax, BountySetID, BountyDisplayLocation, ID, VisibilityPlayerConditionID"
-        " FROM world_map_area ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_WORLD_EFFECT, "SELECT ID, QuestFeedbackEffectID, WhenToDisplay, TargetType, TargetAsset, PlayerConditionID, "
+        "CombatConditionID FROM world_effect ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // WorldMapOverlay.db2
-    PrepareStatement(HOTFIX_SEL_WORLD_MAP_OVERLAY, "SELECT TextureName, ID, TextureWidth, TextureHeight, MapAreaID, OffsetX, OffsetY, HitRectTop, "
-        "HitRectLeft, HitRectBottom, HitRectRight, PlayerConditionID, Flags, AreaID1, AreaID2, AreaID3, AreaID4 FROM world_map_overlay"
-        " ORDER BY ID DESC", CONNECTION_SYNCH);
-
-    // WorldMapTransforms.db2
-    PrepareStatement(HOTFIX_SEL_WORLD_MAP_TRANSFORMS, "SELECT ID, RegionMinX, RegionMinY, RegionMinZ, RegionMaxX, RegionMaxY, RegionMaxZ, "
-        "RegionOffsetX, RegionOffsetY, RegionScale, MapID, AreaID, NewMapID, NewDungeonMapID, NewAreaID, Flags, Priority FROM world_map_transforms"
-        " ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_WORLD_MAP_OVERLAY, "SELECT ID, UiMapArtID, TextureWidth, TextureHeight, OffsetX, OffsetY, HitRectTop, HitRectBottom, "
+        "HitRectLeft, HitRectRight, PlayerConditionID, Flags, AreaID1, AreaID2, AreaID3, AreaID4 FROM world_map_overlay ORDER BY ID DESC", CONNECTION_SYNCH);
 
     // WorldSafeLocs.db2
-    PrepareStatement(HOTFIX_SEL_WORLD_SAFE_LOCS, "SELECT ID, AreaName, LocX, LocY, LocZ, Facing, MapID FROM world_safe_locs ORDER BY ID DESC", CONNECTION_SYNCH);
+    PrepareStatement(HOTFIX_SEL_WORLD_SAFE_LOCS, "SELECT ID, AreaName, LocX, LocY, LocZ, MapID, Facing FROM world_safe_locs ORDER BY ID DESC", CONNECTION_SYNCH);
     PREPARE_LOCALE_STMT(HOTFIX_SEL_WORLD_SAFE_LOCS, "SELECT ID, AreaName_lang FROM world_safe_locs_locale WHERE locale = ?", CONNECTION_SYNCH);
 }
 
diff --git a/src/server/database/Database/Implementation/HotfixDatabase.h b/src/server/database/Database/Implementation/HotfixDatabase.h
index 77f3600ff39..ce2120cf648 100644
--- a/src/server/database/Database/Implementation/HotfixDatabase.h
+++ b/src/server/database/Database/Implementation/HotfixDatabase.h
@@ -34,6 +34,8 @@ enum HotfixDatabaseStatements : uint32
     HOTFIX_SEL_ACHIEVEMENT,
     HOTFIX_SEL_ACHIEVEMENT_LOCALE,
 
+    HOTFIX_SEL_ANIMATION_DATA,
+
     HOTFIX_SEL_ANIM_KIT,
 
     HOTFIX_SEL_AREA_GROUP_MEMBER,
@@ -126,6 +128,8 @@ enum HotfixDatabaseStatements : uint32
 
     HOTFIX_SEL_CINEMATIC_SEQUENCES,
 
+    HOTFIX_SEL_CONTENT_TUNING,
+
     HOTFIX_SEL_CONVERSATION_LINE,
 
     HOTFIX_SEL_CREATURE_DISPLAY_INFO,
@@ -170,6 +174,10 @@ enum HotfixDatabaseStatements : uint32
 
     HOTFIX_SEL_EMOTES_TEXT_SOUND,
 
+    HOTFIX_SEL_EXPECTED_STAT,
+
+    HOTFIX_SEL_EXPECTED_STAT_MOD,
+
     HOTFIX_SEL_FACTION,
     HOTFIX_SEL_FACTION_LOCALE,
 
@@ -197,7 +205,6 @@ enum HotfixDatabaseStatements : uint32
     HOTFIX_SEL_GARR_FOLLOWER_X_ABILITY,
 
     HOTFIX_SEL_GARR_PLOT,
-    HOTFIX_SEL_GARR_PLOT_LOCALE,
 
     HOTFIX_SEL_GARR_PLOT_BUILDING,
 
@@ -359,6 +366,8 @@ enum HotfixDatabaseStatements : uint32
 
     HOTFIX_SEL_NAMES_RESERVED_LOCALE,
 
+    HOTFIX_SEL_NUM_TALENTS_AT_LEVEL,
+
     HOTFIX_SEL_OVERRIDE_SPELL_DATA,
 
     HOTFIX_SEL_PHASE,
@@ -379,12 +388,12 @@ enum HotfixDatabaseStatements : uint32
 
     HOTFIX_SEL_PVP_ITEM,
 
-    HOTFIX_SEL_PVP_REWARD,
-
     HOTFIX_SEL_PVP_TALENT,
     HOTFIX_SEL_PVP_TALENT_LOCALE,
 
-    HOTFIX_SEL_PVP_TALENT_UNLOCK,
+    HOTFIX_SEL_PVP_TALENT_CATEGORY,
+
+    HOTFIX_SEL_PVP_TALENT_SLOT_UNLOCK,
 
     HOTFIX_SEL_QUEST_FACTION_REWARD,
 
@@ -409,8 +418,6 @@ enum HotfixDatabaseStatements : uint32
 
     HOTFIX_SEL_RULESET_ITEM_UPGRADE,
 
-    HOTFIX_SEL_SANDBOX_SCALING,
-
     HOTFIX_SEL_SCALING_STAT_DISTRIBUTION,
 
     HOTFIX_SEL_SCENARIO,
@@ -439,9 +446,6 @@ enum HotfixDatabaseStatements : uint32
     HOTFIX_SEL_SPECIALIZATION_SPELLS,
     HOTFIX_SEL_SPECIALIZATION_SPELLS_LOCALE,
 
-    HOTFIX_SEL_SPELL,
-    HOTFIX_SEL_SPELL_LOCALE,
-
     HOTFIX_SEL_SPELL_AURA_OPTIONS,
 
     HOTFIX_SEL_SPELL_AURA_RESTRICTIONS,
@@ -481,6 +485,9 @@ enum HotfixDatabaseStatements : uint32
 
     HOTFIX_SEL_SPELL_MISC,
 
+    HOTFIX_SEL_SPELL_NAME,
+    HOTFIX_SEL_SPELL_NAME_LOCALE,
+
     HOTFIX_SEL_SPELL_POWER,
 
     HOTFIX_SEL_SPELL_POWER_DIFFICULTY,
@@ -543,6 +550,15 @@ enum HotfixDatabaseStatements : uint32
 
     HOTFIX_SEL_TRANSPORT_ROTATION,
 
+    HOTFIX_SEL_UI_MAP,
+    HOTFIX_SEL_UI_MAP_LOCALE,
+
+    HOTFIX_SEL_UI_MAP_ASSIGNMENT,
+
+    HOTFIX_SEL_UI_MAP_LINK,
+
+    HOTFIX_SEL_UI_MAP_X_MAP_ART,
+
     HOTFIX_SEL_UNIT_POWER_BAR,
     HOTFIX_SEL_UNIT_POWER_BAR_LOCALE,
 
@@ -555,12 +571,8 @@ enum HotfixDatabaseStatements : uint32
 
     HOTFIX_SEL_WORLD_EFFECT,
 
-    HOTFIX_SEL_WORLD_MAP_AREA,
-
     HOTFIX_SEL_WORLD_MAP_OVERLAY,
 
-    HOTFIX_SEL_WORLD_MAP_TRANSFORMS,
-
     HOTFIX_SEL_WORLD_SAFE_LOCS,
     HOTFIX_SEL_WORLD_SAFE_LOCS_LOCALE,
 
diff --git a/src/server/database/Database/Implementation/WorldDatabase.cpp b/src/server/database/Database/Implementation/WorldDatabase.cpp
index 01cb3023c29..a66132121a9 100644
--- a/src/server/database/Database/Implementation/WorldDatabase.cpp
+++ b/src/server/database/Database/Implementation/WorldDatabase.cpp
@@ -77,7 +77,7 @@ void WorldDatabaseConnection::DoPrepareStatements()
     PrepareStatement(WORLD_SEL_WAYPOINT_SCRIPT_ID_BY_GUID, "SELECT id FROM waypoint_scripts WHERE guid = ?", CONNECTION_SYNCH);
     PrepareStatement(WORLD_DEL_CREATURE, "DELETE FROM creature WHERE guid = ?", CONNECTION_ASYNC);
     PrepareStatement(WORLD_SEL_COMMANDS, "SELECT name, permission, help FROM command", CONNECTION_SYNCH);
-    PrepareStatement(WORLD_SEL_CREATURE_TEMPLATE, "SELECT entry, difficulty_entry_1, difficulty_entry_2, difficulty_entry_3, KillCredit1, KillCredit2, modelid1, modelid2, modelid3, modelid4, name, femaleName, subname, TitleAlt, IconName, gossip_menu_id, minlevel, maxlevel, HealthScalingExpansion, RequiredExpansion, VignetteID, faction, npcflag, speed_walk, speed_run, scale, rank, dmgschool, BaseAttackTime, RangeAttackTime, BaseVariance, RangeVariance, unit_class, unit_flags, unit_flags2, unit_flags3, dynamicflags, family, trainer_class, type, type_flags, type_flags2, lootid, pickpocketloot, skinloot, resistance1, resistance2, resistance3, resistance4, resistance5, resistance6, spell1, spell2, spell3, spell4, spell5, spell6, spell7, spell8, VehicleId, mingold, maxgold, AIName, MovementType, InhabitType, HoverHeight, HealthModifier, HealthModifierExtra, ManaModifier, ManaModifierExtra, ArmorModifier, DamageModifier, ExperienceModifier, RacialLeader, movementId, RegenHealth, mechanic_immune_mask, flags_extra, ScriptName FROM creature_template WHERE entry = ?", CONNECTION_SYNCH);
+    PrepareStatement(WORLD_SEL_CREATURE_TEMPLATE, "SELECT entry, difficulty_entry_1, difficulty_entry_2, difficulty_entry_3, KillCredit1, KillCredit2, name, femaleName, subname, TitleAlt, IconName, gossip_menu_id, minlevel, maxlevel, HealthScalingExpansion, RequiredExpansion, VignetteID, faction, npcflag, speed_walk, speed_run, scale, rank, dmgschool, BaseAttackTime, RangeAttackTime, BaseVariance, RangeVariance, unit_class, unit_flags, unit_flags2, unit_flags3, dynamicflags, family, trainer_class, type, type_flags, type_flags2, lootid, pickpocketloot, skinloot, resistance1, resistance2, resistance3, resistance4, resistance5, resistance6, spell1, spell2, spell3, spell4, spell5, spell6, spell7, spell8, VehicleId, mingold, maxgold, AIName, MovementType, InhabitType, HoverHeight, HealthModifier, HealthModifierExtra, ManaModifier, ManaModifierExtra, ArmorModifier, DamageModifier, ExperienceModifier, RacialLeader, movementId, RegenHealth, mechanic_immune_mask, flags_extra, ScriptName FROM creature_template WHERE entry = ?", CONNECTION_SYNCH);
     PrepareStatement(WORLD_SEL_WAYPOINT_SCRIPT_BY_ID, "SELECT guid, delay, command, datalong, datalong2, dataint, x, y, z, o FROM waypoint_scripts WHERE id = ?", CONNECTION_SYNCH);
     PrepareStatement(WORLD_SEL_CREATURE_BY_ID, "SELECT guid FROM creature WHERE id = ?", CONNECTION_SYNCH);
     PrepareStatement(WORLD_SEL_GAMEOBJECT_NEAREST, "SELECT guid, id, position_x, position_y, position_z, map, (POW(position_x - ?, 2) + POW(position_y - ?, 2) + POW(position_z - ?, 2)) AS order_ FROM gameobject WHERE map = ? AND (POW(position_x - ?, 2) + POW(position_y - ?, 2) + POW(position_z - ?, 2)) <= ? ORDER BY order_", CONNECTION_SYNCH);
diff --git a/src/server/game/AI/SmartScripts/SmartScript.cpp b/src/server/game/AI/SmartScripts/SmartScript.cpp
index 6c888550494..a19d01fceb0 100644
--- a/src/server/game/AI/SmartScripts/SmartScript.cpp
+++ b/src/server/game/AI/SmartScripts/SmartScript.cpp
@@ -412,10 +412,10 @@ void SmartScript::ProcessAction(SmartScriptHolder& e, Unit* unit, uint32 var0, u
                     {
                         if (CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate(e.action.morphOrMount.creature))
                         {
-                            uint32 displayId = ObjectMgr::ChooseDisplayId(ci);
-                            (*itr)->ToCreature()->SetDisplayId(displayId);
+                            CreatureModel const* model = ObjectMgr::ChooseDisplayId(ci);
+                            (*itr)->ToCreature()->SetDisplayId(model->CreatureDisplayID, model->DisplayScale);
                             TC_LOG_DEBUG("scripts.ai", "SmartScript::ProcessAction:: SMART_ACTION_MORPH_TO_ENTRY_OR_MODEL: Creature entry %u, %s set displayid to %u",
-                                (*itr)->GetEntry(), (*itr)->GetGUID().ToString().c_str(), displayId);
+                                (*itr)->GetEntry(), (*itr)->GetGUID().ToString().c_str(), model->CreatureDisplayID);
                         }
                     }
                     //if no param1, then use value from param2 (modelId)
@@ -1291,7 +1291,7 @@ void SmartScript::ProcessAction(SmartScriptHolder& e, Unit* unit, uint32 var0, u
                     if (e.action.morphOrMount.creature > 0)
                     {
                         if (CreatureTemplate const* cInfo = sObjectMgr->GetCreatureTemplate(e.action.morphOrMount.creature))
-                            (*itr)->ToUnit()->Mount(ObjectMgr::ChooseDisplayId(cInfo));
+                            (*itr)->ToUnit()->Mount(ObjectMgr::ChooseDisplayId(cInfo)->CreatureDisplayID);
                     }
                     else
                         (*itr)->ToUnit()->Mount(e.action.morphOrMount.model);
diff --git a/src/server/game/Achievements/AchievementMgr.cpp b/src/server/game/Achievements/AchievementMgr.cpp
index 5ebb0f971b6..9531bdff1ed 100644
--- a/src/server/game/Achievements/AchievementMgr.cpp
+++ b/src/server/game/Achievements/AchievementMgr.cpp
@@ -597,7 +597,7 @@ void PlayerAchievementMgr::SendAchievementEarned(AchievementEntry const* achieve
         if (achievement->Flags & (ACHIEVEMENT_FLAG_REALM_FIRST_KILL | ACHIEVEMENT_FLAG_REALM_FIRST_REACH))
         {
             // broadcast realm first reached
-            WorldPackets::Achievement::ServerFirstAchievement serverFirstAchievement;
+            WorldPackets::Achievement::BroadcastAchievement serverFirstAchievement;
             serverFirstAchievement.Name = _owner->GetName();
             serverFirstAchievement.PlayerGUID = _owner->GetGUID();
             serverFirstAchievement.AchievementID = achievement->ID;
@@ -945,7 +945,7 @@ void GuildAchievementMgr::SendAchievementEarned(AchievementEntry const* achievem
     if (achievement->Flags & (ACHIEVEMENT_FLAG_REALM_FIRST_KILL | ACHIEVEMENT_FLAG_REALM_FIRST_REACH))
     {
         // broadcast realm first reached
-        WorldPackets::Achievement::ServerFirstAchievement serverFirstAchievement;
+        WorldPackets::Achievement::BroadcastAchievement serverFirstAchievement;
         serverFirstAchievement.Name = _owner->GetName();
         serverFirstAchievement.PlayerGUID = _owner->GetGUID();
         serverFirstAchievement.AchievementID = achievement->ID;
diff --git a/src/server/game/Achievements/CriteriaHandler.cpp b/src/server/game/Achievements/CriteriaHandler.cpp
index 879967ef31f..bef431b367f 100644
--- a/src/server/game/Achievements/CriteriaHandler.cpp
+++ b/src/server/game/Achievements/CriteriaHandler.cpp
@@ -107,7 +107,7 @@ bool CriteriaData::IsValid(Criteria const* criteria)
                     criteria->ID, criteria->Entry->Type, DataType, ClassRace.Class);
                 return false;
             }
-            if (ClassRace.Race && ((1 << (ClassRace.Race-1)) & RACEMASK_ALL_PLAYABLE) == 0)
+            if (ClassRace.Race && ((UI64LIT(1) << (ClassRace.Race-1)) & RACEMASK_ALL_PLAYABLE) == 0)
             {
                 TC_LOG_ERROR("sql.sql", "Table `criteria_data` (Entry: %u Type: %u) for data type CRITERIA_DATA_TYPE_T_PLAYER_CLASS_RACE (%u) contains a non-existing race in value2 (%u), ignored.",
                     criteria->ID, criteria->Entry->Type, DataType, ClassRace.Race);
@@ -252,7 +252,7 @@ bool CriteriaData::IsValid(Criteria const* criteria)
                     criteria->ID, criteria->Entry->Type, DataType, ClassRace.Class);
                 return false;
             }
-            if (ClassRace.Race && ((1 << (ClassRace.Race-1)) & RACEMASK_ALL_PLAYABLE) == 0)
+            if (ClassRace.Race && ((UI64LIT(1) << (ClassRace.Race-1)) & RACEMASK_ALL_PLAYABLE) == 0)
             {
                 TC_LOG_ERROR("sql.sql", "Table `criteria_data` (Entry: %u Type: %u) for data type CRITERIA_DATA_TYPE_S_PLAYER_CLASS_RACE (%u) contains a non-existing race entry in value2 (%u), ignored.",
                     criteria->ID, criteria->Entry->Type, DataType, ClassRace.Race);
@@ -504,6 +504,8 @@ void CriteriaHandler::UpdateCriteria(CriteriaTypes type, uint64 miscValue1 /*= 0
             case CRITERIA_TYPE_OWN_BATTLE_PET_COUNT:
             case CRITERIA_TYPE_HONOR_LEVEL_REACHED:
             case CRITERIA_TYPE_PRESTIGE_REACHED:
+            case CRITERIA_TYPE_APPEARANCE_UNLOCKED_BY_SLOT:
+            case CRITERIA_TYPE_TRANSMOG_SET_UNLOCKED:
                 SetCriteriaProgress(criteria, 1, referencePlayer, PROGRESS_ACCUMULATE);
                 break;
             // std case: increment at miscValue1
@@ -593,7 +595,7 @@ void CriteriaHandler::UpdateCriteria(CriteriaTypes type, uint64 miscValue1 /*= 0
                 for (RewardedQuestSet::const_iterator itr = rewQuests.begin(); itr != rewQuests.end(); ++itr)
                 {
                     Quest const* quest = sObjectMgr->GetQuestTemplate(*itr);
-                    if (quest && quest->GetZoneOrSort() >= 0 && uint32(quest->GetZoneOrSort()) == criteria->Entry->Asset.ZoneID)
+                    if (quest && quest->GetZoneOrSort() >= 0 && quest->GetZoneOrSort() == criteria->Entry->Asset.ZoneID)
                         ++counter;
                 }
                 SetCriteriaProgress(criteria, counter, referencePlayer);
@@ -655,7 +657,7 @@ void CriteriaHandler::UpdateCriteria(CriteriaTypes type, uint64 miscValue1 /*= 0
                 SetCriteriaProgress(criteria, referencePlayer->GetReputationMgr().GetVisibleFactionCount(), referencePlayer);
                 break;
             case CRITERIA_TYPE_EARN_HONORABLE_KILL:
-                SetCriteriaProgress(criteria, referencePlayer->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS), referencePlayer);
+                SetCriteriaProgress(criteria, referencePlayer->GetUInt32Value(ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS), referencePlayer);
                 break;
             case CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED:
                 SetCriteriaProgress(criteria, referencePlayer->GetMoney(), referencePlayer, PROGRESS_HIGHEST);
@@ -700,16 +702,6 @@ void CriteriaHandler::UpdateCriteria(CriteriaTypes type, uint64 miscValue1 /*= 0
             case CRITERIA_TYPE_REACH_GUILD_LEVEL:
                 SetCriteriaProgress(criteria, miscValue1, referencePlayer);
                 break;
-            case CRITERIA_TYPE_TRANSMOG_SET_UNLOCKED:
-                if (miscValue1 != criteria->Entry->Asset.TransmogSetGroupID)
-                    continue;
-                SetCriteriaProgress(criteria, 1, referencePlayer, PROGRESS_ACCUMULATE);
-                break;
-            case CRITERIA_TYPE_APPEARANCE_UNLOCKED_BY_SLOT:
-                if (!miscValue2 /*login case*/ || miscValue1 != criteria->Entry->Asset.EquipmentSlot)
-                    continue;
-                SetCriteriaProgress(criteria, 1, referencePlayer, PROGRESS_ACCUMULATE);
-                break;
             // FIXME: not triggered in code as result, need to implement
             case CRITERIA_TYPE_COMPLETE_RAID:
             case CRITERIA_TYPE_PLAY_ARENA:
@@ -789,6 +781,9 @@ void CriteriaHandler::UpdateCriteria(CriteriaTypes type, uint64 miscValue1 /*= 0
             case CRITERIA_TYPE_GAIN_PARAGON_REPUTATION:
             case CRITERIA_TYPE_EARN_HONOR_XP:
             case CRITERIA_TYPE_RELIC_TALENT_UNLOCKED:
+            case CRITERIA_TYPE_REACH_ACCOUNT_HONOR_LEVEL:
+            case CRITERIA_TREE_HEART_OF_AZEROTH_ARTIFACT_POWER_EARNED:
+            case CRITERIA_TREE_HEART_OF_AZEROTH_LEVEL_REACHED:
                 break;                                   // Not implemented yet :(
         }
 
@@ -1151,6 +1146,9 @@ bool CriteriaHandler::IsCompletedCriteria(Criteria const* criteria, uint64 requi
         case CRITERIA_TYPE_GAIN_PARAGON_REPUTATION:
         case CRITERIA_TYPE_EARN_HONOR_XP:
         case CRITERIA_TYPE_RELIC_TALENT_UNLOCKED:
+        case CRITERIA_TYPE_REACH_ACCOUNT_HONOR_LEVEL:
+        case CRITERIA_TREE_HEART_OF_AZEROTH_ARTIFACT_POWER_EARNED:
+        case CRITERIA_TREE_HEART_OF_AZEROTH_LEVEL_REACHED:
             return progress->Counter >= requiredAmount;
         case CRITERIA_TYPE_COMPLETE_ACHIEVEMENT:
         case CRITERIA_TYPE_COMPLETE_QUEST:
@@ -1335,22 +1333,22 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
         case CRITERIA_TYPE_WIN_BG:
         case CRITERIA_TYPE_COMPLETE_BATTLEGROUND:
         case CRITERIA_TYPE_DEATH_AT_MAP:
-            if (!miscValue1 || criteria->Entry->Asset.MapID != referencePlayer->GetMapId())
+            if (!miscValue1 || uint32(criteria->Entry->Asset.MapID) != referencePlayer->GetMapId())
                 return false;
             break;
         case CRITERIA_TYPE_KILL_CREATURE:
         case CRITERIA_TYPE_KILLED_BY_CREATURE:
-            if (!miscValue1 || criteria->Entry->Asset.CreatureID != miscValue1)
+            if (!miscValue1 || uint32(criteria->Entry->Asset.CreatureID) != miscValue1)
                 return false;
             break;
         case CRITERIA_TYPE_REACH_SKILL_LEVEL:
         case CRITERIA_TYPE_LEARN_SKILL_LEVEL:
             // update at loading or specific skill update
-            if (miscValue1 && miscValue1 != criteria->Entry->Asset.SkillID)
+            if (miscValue1 && miscValue1 != uint32(criteria->Entry->Asset.SkillID))
                 return false;
             break;
         case CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE:
-            if (miscValue1 && miscValue1 != criteria->Entry->Asset.ZoneID)
+            if (miscValue1 && miscValue1 != uint32(criteria->Entry->Asset.ZoneID))
                 return false;
             break;
         case CRITERIA_TYPE_DEATH:
@@ -1369,7 +1367,7 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
                 return false;
 
             //FIXME: work only for instances where max == min for players
-            if (map->ToInstanceMap()->GetMaxPlayers() != criteria->Entry->Asset.GroupSize)
+            if (map->ToInstanceMap()->GetMaxPlayers() != uint32(criteria->Entry->Asset.GroupSize))
                 return false;
             break;
         }
@@ -1378,7 +1376,7 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
                 return false;
             break;
         case CRITERIA_TYPE_DEATHS_FROM:
-            if (!miscValue1 || miscValue2 != criteria->Entry->Asset.DamageType)
+            if (!miscValue1 || miscValue2 != uint32(criteria->Entry->Asset.DamageType))
                 return false;
             break;
         case CRITERIA_TYPE_COMPLETE_QUEST:
@@ -1386,7 +1384,7 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
             // if miscValues != 0, it contains the questID.
             if (miscValue1)
             {
-                if (miscValue1 != criteria->Entry->Asset.QuestID)
+                if (miscValue1 != uint32(criteria->Entry->Asset.QuestID))
                     return false;
             }
             else
@@ -1405,11 +1403,11 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
         case CRITERIA_TYPE_BE_SPELL_TARGET2:
         case CRITERIA_TYPE_CAST_SPELL:
         case CRITERIA_TYPE_CAST_SPELL2:
-            if (!miscValue1 || miscValue1 != criteria->Entry->Asset.SpellID)
+            if (!miscValue1 || miscValue1 != uint32(criteria->Entry->Asset.SpellID))
                 return false;
             break;
         case CRITERIA_TYPE_LEARN_SPELL:
-            if (miscValue1 && miscValue1 != criteria->Entry->Asset.SpellID)
+            if (miscValue1 && miscValue1 != uint32(criteria->Entry->Asset.SpellID))
                 return false;
 
             if (!referencePlayer->HasSpell(criteria->Entry->Asset.SpellID))
@@ -1418,17 +1416,17 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
         case CRITERIA_TYPE_LOOT_TYPE:
             // miscValue1 = itemId - miscValue2 = count of item loot
             // miscValue3 = loot_type (note: 0 = LOOT_CORPSE and then it ignored)
-            if (!miscValue1 || !miscValue2 || !miscValue3 || miscValue3 != criteria->Entry->Asset.LootType)
+            if (!miscValue1 || !miscValue2 || !miscValue3 || miscValue3 != uint32(criteria->Entry->Asset.LootType))
                 return false;
             break;
         case CRITERIA_TYPE_OWN_ITEM:
-            if (miscValue1 && criteria->Entry->Asset.ItemID != miscValue1)
+            if (miscValue1 && uint32(criteria->Entry->Asset.ItemID) != miscValue1)
                 return false;
             break;
         case CRITERIA_TYPE_USE_ITEM:
         case CRITERIA_TYPE_LOOT_ITEM:
         case CRITERIA_TYPE_EQUIP_ITEM:
-            if (!miscValue1 || criteria->Entry->Asset.ItemID != miscValue1)
+            if (!miscValue1 || uint32(criteria->Entry->Asset.ItemID )!= miscValue1)
                 return false;
             break;
         case CRITERIA_TYPE_EXPLORE_AREA:
@@ -1452,7 +1450,7 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
                     continue;
 
                 uint32 mask = 1 << (uint32(area->AreaBit) % 32);
-                if (referencePlayer->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + playerIndexOffset) & mask)
+                if (referencePlayer->GetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + playerIndexOffset) & mask)
                 {
                     matchFound = true;
                     break;
@@ -1464,19 +1462,19 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
             break;
         }
         case CRITERIA_TYPE_GAIN_REPUTATION:
-            if (miscValue1 && miscValue1 != criteria->Entry->Asset.FactionID)
+            if (miscValue1 && miscValue1 != uint32(criteria->Entry->Asset.FactionID))
                 return false;
             break;
         case CRITERIA_TYPE_EQUIP_EPIC_ITEM:
             // miscValue1 = itemid miscValue2 = itemSlot
-            if (!miscValue1 || miscValue2 != criteria->Entry->Asset.ItemSlot)
+            if (!miscValue1 || miscValue2 != uint32(criteria->Entry->Asset.ItemSlot))
                 return false;
             break;
         case CRITERIA_TYPE_ROLL_NEED_ON_LOOT:
         case CRITERIA_TYPE_ROLL_GREED_ON_LOOT:
         {
             // miscValue1 = itemid miscValue2 = diced value
-            if (!miscValue1 || miscValue2 != criteria->Entry->Asset.RollValue)
+            if (!miscValue1 || miscValue2 != uint32(criteria->Entry->Asset.RollValue))
                 return false;
 
             ItemTemplate const* proto = sObjectMgr->GetItemTemplate(uint32(miscValue1));
@@ -1485,7 +1483,7 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
             break;
         }
         case CRITERIA_TYPE_DO_EMOTE:
-            if (!miscValue1 || miscValue1 != criteria->Entry->Asset.EmoteID)
+            if (!miscValue1 || miscValue1 != uint32(criteria->Entry->Asset.EmoteID))
                 return false;
             break;
         case CRITERIA_TYPE_DAMAGE_DONE:
@@ -1505,12 +1503,12 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
             break;
         case CRITERIA_TYPE_USE_GAMEOBJECT:
         case CRITERIA_TYPE_FISH_IN_GAMEOBJECT:
-            if (!miscValue1 || miscValue1 != criteria->Entry->Asset.GameObjectID)
+            if (!miscValue1 || miscValue1 != uint32(criteria->Entry->Asset.GameObjectID))
                 return false;
             break;
         case CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS:
         case CRITERIA_TYPE_LEARN_SKILL_LINE:
-            if (miscValue1 && miscValue1 != criteria->Entry->Asset.SkillID)
+            if (miscValue1 && miscValue1 != uint32(criteria->Entry->Asset.SkillID))
                 return false;
             break;
         case CRITERIA_TYPE_LOOT_EPIC_ITEM:
@@ -1524,34 +1522,42 @@ bool CriteriaHandler::RequirementsSatisfied(Criteria const* criteria, uint64 mis
             break;
         }
         case CRITERIA_TYPE_HK_CLASS:
-            if (!miscValue1 || miscValue1 != criteria->Entry->Asset.ClassID)
+            if (!miscValue1 || miscValue1 != uint32(criteria->Entry->Asset.ClassID))
                 return false;
             break;
         case CRITERIA_TYPE_HK_RACE:
-            if (!miscValue1 || miscValue1 != criteria->Entry->Asset.RaceID)
+            if (!miscValue1 || miscValue1 != uint32(criteria->Entry->Asset.RaceID))
                 return false;
             break;
         case CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE:
-            if (!miscValue1 || miscValue1 != criteria->Entry->Asset.ObjectiveId)
+            if (!miscValue1 || miscValue1 != uint32(criteria->Entry->Asset.ObjectiveId))
                 return false;
             break;
         case CRITERIA_TYPE_HONORABLE_KILL_AT_AREA:
-            if (!miscValue1 || miscValue1 != criteria->Entry->Asset.AreaID)
+            if (!miscValue1 || miscValue1 != uint32(criteria->Entry->Asset.AreaID))
                 return false;
             break;
         case CRITERIA_TYPE_CURRENCY:
             if (!miscValue1 || !miscValue2 || int64(miscValue2) < 0
-                || miscValue1 != criteria->Entry->Asset.CurrencyID)
+                || miscValue1 != uint32(criteria->Entry->Asset.CurrencyID))
                 return false;
             break;
         case CRITERIA_TYPE_WIN_ARENA:
-            if (miscValue1 != criteria->Entry->Asset.MapID)
+            if (miscValue1 != uint32(criteria->Entry->Asset.MapID))
                 return false;
             break;
         case CRITERIA_TYPE_HIGHEST_TEAM_RATING:
             return false;
         case CRITERIA_TYPE_PLACE_GARRISON_BUILDING:
-            if (miscValue1 != criteria->Entry->Asset.GarrBuildingID)
+            if (miscValue1 != uint32(criteria->Entry->Asset.GarrBuildingID))
+                return false;
+            break;
+        case CRITERIA_TYPE_TRANSMOG_SET_UNLOCKED:
+            if (miscValue1 != uint32(criteria->Entry->Asset.TransmogSetGroupID))
+                return false;
+            break;
+        case CRITERIA_TYPE_APPEARANCE_UNLOCKED_BY_SLOT:
+            if (!miscValue2 /*login case*/ || miscValue1 != uint32(criteria->Entry->Asset.EquipmentSlot))
                 return false;
             break;
         default:
@@ -1781,9 +1787,7 @@ bool CriteriaHandler::AdditionalRequirementsSatisfied(ModifierTreeNode const* tr
                 return false;
             break;
         case CRITERIA_ADDITIONAL_CONDITION_PRESTIGE_LEVEL: // 194
-            if (!referencePlayer || referencePlayer->GetPrestigeLevel() != reqValue)
-                return false;
-            break;
+            return false;
         default:
             break;
     }
@@ -2157,6 +2161,12 @@ char const* CriteriaMgr::GetCriteriaTypeString(CriteriaTypes type)
             return "EARN_HONOR_XP";
         case CRITERIA_TYPE_RELIC_TALENT_UNLOCKED:
             return "RELIC_TALENT_UNLOCKED";
+        case CRITERIA_TYPE_REACH_ACCOUNT_HONOR_LEVEL:
+            return "REACH_ACCOUNT_HONOR_LEVEL";
+        case CRITERIA_TREE_HEART_OF_AZEROTH_ARTIFACT_POWER_EARNED:
+            return "HEART_OF_AZEROTH_ARTIFACT_POWER_EARNED";
+        case CRITERIA_TREE_HEART_OF_AZEROTH_LEVEL_REACHED:
+            return "HEART_OF_AZEROTH_LEVEL_REACHED";
     }
     return "MISSING_TYPE";
 }
diff --git a/src/server/game/BattlePets/BattlePetMgr.cpp b/src/server/game/BattlePets/BattlePetMgr.cpp
index 2c96b93e7fe..42be357f802 100644
--- a/src/server/game/BattlePets/BattlePetMgr.cpp
+++ b/src/server/game/BattlePets/BattlePetMgr.cpp
@@ -444,7 +444,7 @@ void BattlePetMgr::SummonPet(ObjectGuid guid)
         return;
 
     // TODO: set proper CreatureID for spell DEFAULT_SUMMON_BATTLE_PET_SPELL (default EffectMiscValueA is 40721 - Murkimus the Gladiator)
-    _owner->GetPlayer()->SetGuidValue(PLAYER_FIELD_SUMMONED_BATTLE_PET_ID, guid);
+    _owner->GetPlayer()->SetGuidValue(ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID, guid);
     _owner->GetPlayer()->CastSpell(_owner->GetPlayer(), speciesEntry->SummonSpellID ? speciesEntry->SummonSpellID : uint32(DEFAULT_SUMMON_BATTLE_PET_SPELL));
 
     // TODO: set pet level, quality... update fields
@@ -454,10 +454,10 @@ void BattlePetMgr::DismissPet()
 {
     Player* ownerPlayer = _owner->GetPlayer();
     Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*ownerPlayer, ownerPlayer->GetCritterGUID());
-    if (pet && ownerPlayer->GetGuidValue(PLAYER_FIELD_SUMMONED_BATTLE_PET_ID) == pet->GetGuidValue(UNIT_FIELD_BATTLE_PET_COMPANION_GUID))
+    if (pet && ownerPlayer->GetGuidValue(ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID) == pet->GetGuidValue(UNIT_FIELD_BATTLE_PET_COMPANION_GUID))
     {
         pet->DespawnOrUnsummon();
-        ownerPlayer->SetGuidValue(PLAYER_FIELD_SUMMONED_BATTLE_PET_ID, ObjectGuid::Empty);
+        ownerPlayer->SetGuidValue(ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID, ObjectGuid::Empty);
     }
 }
 
diff --git a/src/server/game/Battlegrounds/Battleground.cpp b/src/server/game/Battlegrounds/Battleground.cpp
index 3ddca3a7b33..e63accbb018 100644
--- a/src/server/game/Battlegrounds/Battleground.cpp
+++ b/src/server/game/Battlegrounds/Battleground.cpp
@@ -1289,9 +1289,10 @@ void Battleground::BuildPvPLogDataPacket(WorldPackets::Battleground::PVPLogData&
         {
             playerData.IsInWorld = true;
             playerData.PrimaryTalentTree = player->GetUInt32Value(PLAYER_FIELD_CURRENT_SPEC_ID);
-            playerData.PrimaryTalentTreeNameIndex = 0;
+            playerData.Sex = player->getGender();
             playerData.Race = player->getRace();
-            playerData.Prestige = player->GetPrestigeLevel();
+            playerData.Class = player->getClass();
+            playerData.HonorLevel = player->GetHonorLevel();
         }
 
         pvpLogData.Players.push_back(playerData);
diff --git a/src/server/game/Calendar/CalendarMgr.cpp b/src/server/game/Calendar/CalendarMgr.cpp
index cf4898d8099..73d6c49f7ff 100644
--- a/src/server/game/Calendar/CalendarMgr.cpp
+++ b/src/server/game/Calendar/CalendarMgr.cpp
@@ -463,6 +463,7 @@ void CalendarMgr::SendCalendarEventUpdateAlert(CalendarEvent const& calendarEven
     packet.ClearPending = true; // FIXME
     packet.Date = calendarEvent.GetDate();
     packet.Description = calendarEvent.GetDescription();
+    packet.EventClubID = calendarEvent.GetGuildId();
     packet.EventID = calendarEvent.GetEventId();
     packet.EventName = calendarEvent.GetTitle();
     packet.EventType = calendarEvent.GetType();
@@ -534,18 +535,15 @@ void CalendarMgr::SendCalendarEventInviteAlert(CalendarEvent const& calendarEven
     packet.OwnerGuid = calendarEvent.GetOwnerGUID();
     packet.Status = invite.GetStatus();
     packet.TextureID = calendarEvent.GetTextureId();
-
-    Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId());
-    packet.EventGuildID = guild ? guild->GetGUID() : ObjectGuid::Empty;
+    packet.EventClubID = calendarEvent.GetGuildId();
 
     if (calendarEvent.IsGuildEvent() || calendarEvent.IsGuildAnnouncement())
     {
-        if (guild)
+        if (Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId()))
             guild->BroadcastPacket(packet.Write());
     }
-    else
-        if (Player* player = ObjectAccessor::FindConnectedPlayer(invite.GetInviteeGUID()))
-            player->SendDirectMessage(packet.Write());
+    else if (Player* player = ObjectAccessor::FindConnectedPlayer(invite.GetInviteeGUID()))
+        player->SendDirectMessage(packet.Write());
 }
 
 void CalendarMgr::SendCalendarEvent(ObjectGuid guid, CalendarEvent const& calendarEvent, CalendarSendEventType sendType)
@@ -567,9 +565,7 @@ void CalendarMgr::SendCalendarEvent(ObjectGuid guid, CalendarEvent const& calend
     packet.LockDate = calendarEvent.GetLockDate(); // Always 0 ?
     packet.OwnerGuid = calendarEvent.GetOwnerGUID();
     packet.TextureID = calendarEvent.GetTextureId();
-
-    Guild* guild = sGuildMgr->GetGuildById(calendarEvent.GetGuildId());
-    packet.EventGuildID = (guild ? guild->GetGUID() : ObjectGuid::Empty);
+    packet.EventClubID = calendarEvent.GetGuildId();
 
     for (auto const& calendarInvite : eventInviteeList)
     {
diff --git a/src/server/game/Chat/Chat.cpp b/src/server/game/Chat/Chat.cpp
index 8ef212e6d85..63223e0ccc9 100644
--- a/src/server/game/Chat/Chat.cpp
+++ b/src/server/game/Chat/Chat.cpp
@@ -455,7 +455,7 @@ bool ChatHandler::isValidChatMessage(char const* message)
 /*
 Valid examples:
 |cffa335ee|Hitem:812:0:0:0:0:0:0:0:70|h[Glowing Brightwood Staff]|h|r
-|cff808080|Hquest:2278:47|h[The Platinum Discs]|h|r
+|cffffff00|Hquest:51101:-1:110:120:5|h[The Wounded King]|h|r
 |cffffd000|Htrade:4037:1:150:1:6AAAAAAAAAAAAAAAAAAAAAAOAADAAAAAAAAAAAAAAAAIAAAAAAAAA|h[Engineering]|h|r
 |cff4e96f7|Htalent:2232:-1|h[Taste for Blood]|h|r
 |cff71d5ff|Hspell:21563|h[Command]|h|r
diff --git a/src/server/game/Chat/ChatLink.cpp b/src/server/game/Chat/ChatLink.cpp
index 2f1cc1162f7..6cfec8193e5 100644
--- a/src/server/game/Chat/ChatLink.cpp
+++ b/src/server/game/Chat/ChatLink.cpp
@@ -40,7 +40,8 @@
 //                                                                        - client, item icon shift click
 // |color|Hitemset:itemset_id|h[name]|h|r
 // |color|Hplayer:name|h[name]|h|r                                        - client, in some messages, at click copy only name instead link
-// |color|Hquest:quest_id:quest_level|h[name]|h|r                         - client, quest list name shift-click
+// |color|Hquest:quest_id:quest_level:min_level:max_level:scaling_faction|h[name]|h|r
+//                                                                        - client, quest list name shift-click
 // |color|Hskill:skill_id|h[name]|h|r
 // |color|Hspell:spell_id|h[name]|h|r                                     - client, spellbook spell icon shift-click
 // |color|Htalent:talent_id, rank|h[name]|h|r                              - client, talent icon shift-click
@@ -395,8 +396,8 @@ bool ItemChatLink::ValidateName(char* buffer, char const* context)
     return false;
 }
 
-// |color|Hquest:quest_id:quest_level|h[name]|h|r
-// |cff808080|Hquest:2278:47|h[The Platinum Discs]|h|r
+// |color|Hquest:quest_id:quest_level:min_level:max_level:scaling_faction|h[name]|h|r
+// |cffffff00|Hquest:51101:-1:110:120:5|h[The Wounded King]|h|r
 bool QuestChatLink::Initialize(std::istringstream& iss)
 {
     // Read quest id
@@ -428,6 +429,21 @@ bool QuestChatLink::Initialize(std::istringstream& iss)
         TC_LOG_TRACE("chat.system", "ChatHandler::isValidChatMessage('%s'): quest level %d is too big", iss.str().c_str(), _questLevel);
         return false;
     }
+    if (!ReadInt32(iss, _minLevel))
+    {
+        TC_LOG_TRACE("chat.system", "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading quest min level", iss.str().c_str());
+        return false;
+    }
+    if (!ReadInt32(iss, _maxLevel))
+    {
+        TC_LOG_TRACE("chat.system", "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading quest max level", iss.str().c_str());
+        return false;
+    }
+    if (!ReadInt32(iss, _scalingFaction))
+    {
+        TC_LOG_TRACE("chat.system", "ChatHandler::isValidChatMessage('%s'): sequence finished unexpectedly while reading quest scaling faction", iss.str().c_str());
+        return false;
+    }
     return true;
 }
 
diff --git a/src/server/game/Chat/ChatLink.h b/src/server/game/Chat/ChatLink.h
index 505bc6b66f7..746cb5c93d9 100644
--- a/src/server/game/Chat/ChatLink.h
+++ b/src/server/game/Chat/ChatLink.h
@@ -90,13 +90,16 @@ protected:
 class TC_GAME_API QuestChatLink : public ChatLink
 {
 public:
-    QuestChatLink() : ChatLink(), _quest(nullptr), _questLevel(0) { }
+    QuestChatLink() : ChatLink(), _quest(nullptr), _questLevel(0), _minLevel(0), _maxLevel(0), _scalingFaction(0) { }
     virtual bool Initialize(std::istringstream& iss) override;
     virtual bool ValidateName(char* buffer, const char* context) override;
 
 protected:
     Quest const* _quest;
     int32 _questLevel;
+    int32 _minLevel;
+    int32 _maxLevel;
+    int32 _scalingFaction;
 };
 
 // SpellChatLink - link to quest
diff --git a/src/server/game/Conditions/ConditionMgr.cpp b/src/server/game/Conditions/ConditionMgr.cpp
index bad5c195667..a6e1e2f73b9 100644
--- a/src/server/game/Conditions/ConditionMgr.cpp
+++ b/src/server/game/Conditions/ConditionMgr.cpp
@@ -2002,7 +2002,7 @@ bool ConditionMgr::isConditionTypeValid(Condition* cond) const
         }
         case CONDITION_CLASS:
         {
-            if (!(cond->ConditionValue1 & CLASSMASK_ALL_PLAYABLE))
+            if (cond->ConditionValue1 & ~CLASSMASK_ALL_PLAYABLE)
             {
                 TC_LOG_ERROR("sql.sql", "%s has non existing classmask (%u), skipped.", cond->ToString(true).c_str(), cond->ConditionValue1 & ~CLASSMASK_ALL_PLAYABLE);
                 return false;
@@ -2011,9 +2011,9 @@ bool ConditionMgr::isConditionTypeValid(Condition* cond) const
         }
         case CONDITION_RACE:
         {
-            if (!(cond->ConditionValue1 & RACEMASK_ALL_PLAYABLE))
+            if (cond->ConditionValue1 & ~RACEMASK_ALL_PLAYABLE)
             {
-                TC_LOG_ERROR("sql.sql", "%s has non existing racemask (%u), skipped.", cond->ToString(true).c_str(), cond->ConditionValue1 & ~RACEMASK_ALL_PLAYABLE);
+                TC_LOG_ERROR("sql.sql", "%s has non existing racemask (" UI64FMTD "), skipped.", cond->ToString(true).c_str(), cond->ConditionValue1 & ~RACEMASK_ALL_PLAYABLE);
                 return false;
             }
             break;
@@ -2590,10 +2590,10 @@ bool ConditionMgr::IsPlayerMeetingCondition(Player const* player, PlayerConditio
         }
     }
 
-    if (condition->PvpMedal && !((1 << (condition->PvpMedal - 1)) & player->GetUInt32Value(PLAYER_FIELD_PVP_MEDALS)))
+    if (condition->PvpMedal && !((1 << (condition->PvpMedal - 1)) & player->GetUInt32Value(ACTIVE_PLAYER_FIELD_PVP_MEDALS)))
         return false;
 
-    if (condition->LifetimeMaxPVPRank && player->GetByteValue(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_LIFETIME_MAX_PVP_RANK) != condition->LifetimeMaxPVPRank)
+    if (condition->LifetimeMaxPVPRank && player->GetByteValue(ACTIVE_PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_LIFETIME_MAX_PVP_RANK) != condition->LifetimeMaxPVPRank)
         return false;
 
     if (condition->MovementFlags[0] && !(player->GetUnitMovementFlags() & condition->MovementFlags[0]))
@@ -2647,7 +2647,7 @@ bool ConditionMgr::IsPlayerMeetingCondition(Player const* player, PlayerConditio
         results.fill(true);
         for (std::size_t i = 0; i < PrevQuestCount::value; ++i)
             if (uint32 questBit = sDB2Manager.GetQuestUniqueBitFlag(condition->PrevQuestID[i]))
-                results[i] = (player->GetUInt32Value(PLAYER_FIELD_QUEST_COMPLETED + ((questBit - 1) >> 5)) & (1 << ((questBit - 1) & 31))) != 0;
+                results[i] = (player->GetUInt32Value(ACTIVE_PLAYER_FIELD_QUEST_COMPLETED + ((questBit - 1) >> 5)) & (1 << ((questBit - 1) & 31))) != 0;
 
         if (!PlayerConditionLogic(condition->PrevQuestLogic, results))
             return false;
@@ -2731,7 +2731,7 @@ bool ConditionMgr::IsPlayerMeetingCondition(Player const* player, PlayerConditio
         for (std::size_t i = 0; i < ExploredCount::value; ++i)
         {
             if (AreaTableEntry const* area = sAreaTableStore.LookupEntry(condition->Explored[i]))
-                if (area->AreaBit != -1 && !(player->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + area->AreaBit / 32) & (1 << (uint32(area->AreaBit) % 32))))
+                if (area->AreaBit != -1 && !(player->GetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + area->AreaBit / 32) & (1 << (uint32(area->AreaBit) % 32))))
                     return false;
         }
     }
diff --git a/src/server/game/DataStores/DB2LoadInfo.h b/src/server/game/DataStores/DB2LoadInfo.h
index a6b4c1c0426..81ba8e1d6df 100644
--- a/src/server/game/DataStores/DB2LoadInfo.h
+++ b/src/server/game/DataStores/DB2LoadInfo.h
@@ -30,27 +30,45 @@ struct AchievementLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_STRING, "Title" },
             { false, FT_STRING, "Description" },
+            { false, FT_STRING, "Title" },
             { false, FT_STRING, "Reward" },
-            { true, FT_INT, "Flags" },
+            { false, FT_INT, "ID" },
             { true, FT_SHORT, "InstanceID" },
+            { true, FT_BYTE, "Faction" },
             { true, FT_SHORT, "Supercedes" },
             { true, FT_SHORT, "Category" },
-            { true, FT_SHORT, "UiOrder" },
-            { true, FT_SHORT, "SharesCriteria" },
-            { true, FT_BYTE, "Faction" },
-            { true, FT_BYTE, "Points" },
             { true, FT_BYTE, "MinimumCriteria" },
-            { false, FT_INT, "ID" },
+            { true, FT_BYTE, "Points" },
+            { true, FT_INT, "Flags" },
+            { true, FT_SHORT, "UiOrder" },
             { true, FT_INT, "IconFileID" },
             { false, FT_INT, "CriteriaTree" },
+            { true, FT_SHORT, "SharesCriteria" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AchievementMeta::Instance(), HOTFIX_SEL_ACHIEVEMENT);
         return &loadInfo;
     }
 };
 
+struct AnimationDataLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { false, FT_SHORT, "Fallback" },
+            { false, FT_BYTE, "BehaviorTier" },
+            { true, FT_INT, "BehaviorID" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimationDataMeta::Instance(), HOTFIX_SEL_ANIMATION_DATA);
+        return &loadInfo;
+    }
+};
+
 struct AnimKitLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -91,31 +109,31 @@ struct AreaTableLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING_NOT_LOCALIZED, "ZoneName" },
             { false, FT_STRING, "AreaName" },
-            { true, FT_INT, "Flags1" },
-            { true, FT_INT, "Flags2" },
-            { false, FT_FLOAT, "AmbientMultiplier" },
             { false, FT_SHORT, "ContinentID" },
             { false, FT_SHORT, "ParentAreaID" },
             { true, FT_SHORT, "AreaBit" },
+            { false, FT_BYTE, "SoundProviderPref" },
+            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
             { false, FT_SHORT, "AmbienceID" },
+            { false, FT_SHORT, "UwAmbience" },
             { false, FT_SHORT, "ZoneMusic" },
-            { false, FT_SHORT, "IntroSound" },
-            { false, FT_SHORT, "LiquidTypeID1" },
-            { false, FT_SHORT, "LiquidTypeID2" },
-            { false, FT_SHORT, "LiquidTypeID3" },
-            { false, FT_SHORT, "LiquidTypeID4" },
             { false, FT_SHORT, "UwZoneMusic" },
-            { false, FT_SHORT, "UwAmbience" },
-            { true, FT_SHORT, "PvpCombatWorldStateID" },
-            { false, FT_BYTE, "SoundProviderPref" },
-            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
             { true, FT_BYTE, "ExplorationLevel" },
+            { false, FT_SHORT, "IntroSound" },
+            { false, FT_INT, "UwIntroSound" },
             { false, FT_BYTE, "FactionGroupMask" },
+            { false, FT_FLOAT, "AmbientMultiplier" },
             { false, FT_BYTE, "MountFlags" },
+            { true, FT_SHORT, "PvpCombatWorldStateID" },
             { false, FT_BYTE, "WildBattlePetLevelMin" },
             { false, FT_BYTE, "WildBattlePetLevelMax" },
             { false, FT_BYTE, "WindSettingsID" },
-            { false, FT_INT, "UwIntroSound" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
+            { false, FT_SHORT, "LiquidTypeID1" },
+            { false, FT_SHORT, "LiquidTypeID2" },
+            { false, FT_SHORT, "LiquidTypeID3" },
+            { false, FT_SHORT, "LiquidTypeID4" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTableMeta::Instance(), HOTFIX_SEL_AREA_TABLE);
         return &loadInfo;
@@ -131,20 +149,20 @@ struct AreaTriggerLoadInfo
             { false, FT_FLOAT, "PosX" },
             { false, FT_FLOAT, "PosY" },
             { false, FT_FLOAT, "PosZ" },
+            { false, FT_INT, "ID" },
+            { true, FT_SHORT, "ContinentID" },
+            { true, FT_BYTE, "PhaseUseFlags" },
+            { true, FT_SHORT, "PhaseID" },
+            { true, FT_SHORT, "PhaseGroupID" },
             { false, FT_FLOAT, "Radius" },
             { false, FT_FLOAT, "BoxLength" },
             { false, FT_FLOAT, "BoxWidth" },
             { false, FT_FLOAT, "BoxHeight" },
             { false, FT_FLOAT, "BoxYaw" },
-            { true, FT_SHORT, "ContinentID" },
-            { true, FT_SHORT, "PhaseID" },
-            { true, FT_SHORT, "PhaseGroupID" },
+            { true, FT_BYTE, "ShapeType" },
             { true, FT_SHORT, "ShapeID" },
             { true, FT_SHORT, "AreaTriggerActionSetID" },
-            { true, FT_BYTE, "PhaseUseFlags" },
-            { true, FT_BYTE, "ShapeType" },
             { true, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTriggerMeta::Instance(), HOTFIX_SEL_AREA_TRIGGER);
         return &loadInfo;
@@ -175,15 +193,15 @@ struct ArtifactLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
+            { false, FT_INT, "ID" },
+            { false, FT_SHORT, "UiTextureKitID" },
+            { true, FT_INT, "UiNameColor" },
             { true, FT_INT, "UiBarOverlayColor" },
             { true, FT_INT, "UiBarBackgroundColor" },
-            { true, FT_INT, "UiNameColor" },
-            { false, FT_SHORT, "UiTextureKitID" },
             { false, FT_SHORT, "ChrSpecializationID" },
-            { false, FT_BYTE, "ArtifactCategoryID" },
             { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "ArtifactCategoryID" },
             { false, FT_INT, "UiModelSceneID" },
             { false, FT_INT, "SpellVisualKitID" },
         };
@@ -199,20 +217,20 @@ struct ArtifactAppearanceLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Name" },
-            { true, FT_INT, "UiSwatchColor" },
-            { false, FT_FLOAT, "UiModelSaturation" },
-            { false, FT_FLOAT, "UiModelOpacity" },
-            { false, FT_INT, "OverrideShapeshiftDisplayID" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "ArtifactAppearanceSetID" },
-            { false, FT_SHORT, "UiCameraID" },
             { false, FT_BYTE, "DisplayIndex" },
+            { false, FT_INT, "UnlockPlayerConditionID" },
             { false, FT_BYTE, "ItemAppearanceModifierID" },
-            { false, FT_BYTE, "Flags" },
+            { true, FT_INT, "UiSwatchColor" },
+            { false, FT_FLOAT, "UiModelSaturation" },
+            { false, FT_FLOAT, "UiModelOpacity" },
             { false, FT_BYTE, "OverrideShapeshiftFormID" },
-            { false, FT_INT, "ID" },
-            { false, FT_INT, "UnlockPlayerConditionID" },
+            { false, FT_INT, "OverrideShapeshiftDisplayID" },
             { false, FT_INT, "UiItemAppearanceID" },
             { false, FT_INT, "UiAltItemAppearanceID" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_SHORT, "UiCameraID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactAppearanceMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE);
         return &loadInfo;
@@ -227,12 +245,12 @@ struct ArtifactAppearanceSetLoadInfo
         {
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
+            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DisplayIndex" },
             { false, FT_SHORT, "UiCameraID" },
             { false, FT_SHORT, "AltHandUICameraID" },
-            { false, FT_BYTE, "DisplayIndex" },
             { true, FT_BYTE, "ForgeAttachmentOverride" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
             { false, FT_BYTE, "ArtifactID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactAppearanceSetMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE_SET);
@@ -261,14 +279,14 @@ struct ArtifactPowerLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_FLOAT, "PosX" },
-            { false, FT_FLOAT, "PosY" },
+            { false, FT_FLOAT, "DisplayPosX" },
+            { false, FT_FLOAT, "DisplayPosY" },
+            { false, FT_INT, "ID" },
             { false, FT_BYTE, "ArtifactID" },
-            { false, FT_BYTE, "Flags" },
             { false, FT_BYTE, "MaxPurchasableRank" },
-            { false, FT_BYTE, "Tier" },
-            { false, FT_INT, "ID" },
             { true, FT_INT, "Label" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "Tier" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactPowerMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER);
         return &loadInfo;
@@ -311,10 +329,10 @@ struct ArtifactPowerRankLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "RankIndex" },
             { true, FT_INT, "SpellID" },
-            { false, FT_FLOAT, "AuraPointsOverride" },
             { false, FT_SHORT, "ItemBonusListID" },
-            { false, FT_BYTE, "RankIndex" },
+            { false, FT_FLOAT, "AuraPointsOverride" },
             { false, FT_SHORT, "ArtifactPowerID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactPowerRankMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER_RANK);
@@ -370,9 +388,9 @@ struct ArtifactUnlockLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "ItemBonusListID" },
-            { false, FT_BYTE, "PowerRank" },
             { false, FT_INT, "PowerID" },
+            { false, FT_BYTE, "PowerRank" },
+            { false, FT_SHORT, "ItemBonusListID" },
             { false, FT_INT, "PlayerConditionID" },
             { false, FT_BYTE, "ArtifactID" },
         };
@@ -436,12 +454,12 @@ struct BarberShopStyleLoadInfo
         {
             { false, FT_STRING, "DisplayName" },
             { false, FT_STRING, "Description" },
-            { false, FT_FLOAT, "CostModifier" },
+            { false, FT_INT, "ID" },
             { false, FT_BYTE, "Type" },
+            { false, FT_FLOAT, "CostModifier" },
             { false, FT_BYTE, "Race" },
             { false, FT_BYTE, "Sex" },
             { false, FT_BYTE, "Data" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BarberShopStyleMeta::Instance(), HOTFIX_SEL_BARBER_SHOP_STYLE);
         return &loadInfo;
@@ -470,8 +488,8 @@ struct BattlePetBreedStateLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "Value" },
             { false, FT_BYTE, "BattlePetStateID" },
+            { false, FT_SHORT, "Value" },
             { false, FT_BYTE, "BattlePetBreedID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetBreedStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_BREED_STATE);
@@ -485,15 +503,15 @@ struct BattlePetSpeciesLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_STRING, "SourceText" },
             { false, FT_STRING, "Description" },
+            { false, FT_STRING, "SourceText" },
+            { false, FT_INT, "ID" },
             { true, FT_INT, "CreatureID" },
-            { true, FT_INT, "IconFileDataID" },
             { true, FT_INT, "SummonSpellID" },
-            { false, FT_SHORT, "Flags" },
+            { true, FT_INT, "IconFileDataID" },
             { false, FT_BYTE, "PetTypeEnum" },
+            { false, FT_SHORT, "Flags" },
             { true, FT_BYTE, "SourceTypeEnum" },
-            { false, FT_INT, "ID" },
             { true, FT_INT, "CardUIModelSceneID" },
             { true, FT_INT, "LoadoutUIModelSceneID" },
         };
@@ -509,8 +527,8 @@ struct BattlePetSpeciesStateLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Value" },
             { false, FT_BYTE, "BattlePetStateID" },
+            { true, FT_INT, "Value" },
             { false, FT_SHORT, "BattlePetSpeciesID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetSpeciesStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_SPECIES_STATE);
@@ -529,7 +547,18 @@ struct BattlemasterListLoadInfo
             { false, FT_STRING, "GameType" },
             { false, FT_STRING, "ShortDescription" },
             { false, FT_STRING, "LongDescription" },
+            { true, FT_BYTE, "InstanceType" },
+            { true, FT_BYTE, "MinLevel" },
+            { true, FT_BYTE, "MaxLevel" },
+            { true, FT_BYTE, "RatedPlayers" },
+            { true, FT_BYTE, "MinPlayers" },
+            { true, FT_BYTE, "MaxPlayers" },
+            { true, FT_BYTE, "GroupsAllowed" },
+            { true, FT_BYTE, "MaxGroupSize" },
+            { true, FT_SHORT, "HolidayWorldState" },
+            { true, FT_BYTE, "Flags" },
             { true, FT_INT, "IconFileDataID" },
+            { true, FT_SHORT, "RequiredPlayerConditionID" },
             { true, FT_SHORT, "MapID1" },
             { true, FT_SHORT, "MapID2" },
             { true, FT_SHORT, "MapID3" },
@@ -546,17 +575,6 @@ struct BattlemasterListLoadInfo
             { true, FT_SHORT, "MapID14" },
             { true, FT_SHORT, "MapID15" },
             { true, FT_SHORT, "MapID16" },
-            { true, FT_SHORT, "HolidayWorldState" },
-            { true, FT_SHORT, "RequiredPlayerConditionID" },
-            { true, FT_BYTE, "InstanceType" },
-            { true, FT_BYTE, "GroupsAllowed" },
-            { true, FT_BYTE, "MaxGroupSize" },
-            { true, FT_BYTE, "MinLevel" },
-            { true, FT_BYTE, "MaxLevel" },
-            { true, FT_BYTE, "RatedPlayers" },
-            { true, FT_BYTE, "MinPlayers" },
-            { true, FT_BYTE, "MaxPlayers" },
-            { true, FT_BYTE, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlemasterListMeta::Instance(), HOTFIX_SEL_BATTLEMASTER_LIST);
         return &loadInfo;
@@ -569,21 +587,22 @@ struct BroadcastTextLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "ID" },
             { false, FT_STRING, "Text" },
             { false, FT_STRING, "Text1" },
+            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "LanguageID" },
+            { true, FT_INT, "ConditionID" },
+            { false, FT_SHORT, "EmotesID" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_INT, "ChatBubbleDurationMs" },
+            { false, FT_INT, "SoundEntriesID1" },
+            { false, FT_INT, "SoundEntriesID2" },
             { false, FT_SHORT, "EmoteID1" },
             { false, FT_SHORT, "EmoteID2" },
             { false, FT_SHORT, "EmoteID3" },
             { false, FT_SHORT, "EmoteDelay1" },
             { false, FT_SHORT, "EmoteDelay2" },
             { false, FT_SHORT, "EmoteDelay3" },
-            { false, FT_SHORT, "EmotesID" },
-            { false, FT_BYTE, "LanguageID" },
-            { false, FT_BYTE, "Flags" },
-            { true, FT_INT, "ConditionID" },
-            { false, FT_INT, "SoundEntriesID1" },
-            { false, FT_INT, "SoundEntriesID2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BroadcastTextMeta::Instance(), HOTFIX_SEL_BROADCAST_TEXT);
         return &loadInfo;
@@ -598,10 +617,10 @@ struct CfgRegionsLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING_NOT_LOCALIZED, "Tag" },
-            { false, FT_INT, "Raidorigin" },
-            { false, FT_INT, "ChallengeOrigin" },
             { false, FT_SHORT, "RegionID" },
+            { false, FT_INT, "Raidorigin" },
             { false, FT_BYTE, "RegionGroupMask" },
+            { false, FT_INT, "ChallengeOrigin" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, Cfg_RegionsMeta::Instance(), HOTFIX_SEL_CFG_REGIONS);
         return &loadInfo;
@@ -636,9 +655,9 @@ struct CharBaseSectionLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "LayoutResType" },
             { false, FT_BYTE, "VariationEnum" },
             { false, FT_BYTE, "ResolutionVariationEnum" },
-            { false, FT_BYTE, "LayoutResType" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharBaseSectionMeta::Instance(), HOTFIX_SEL_CHAR_BASE_SECTION);
         return &loadInfo;
@@ -652,15 +671,15 @@ struct CharSectionsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "MaterialResourcesID1" },
-            { true, FT_INT, "MaterialResourcesID2" },
-            { true, FT_INT, "MaterialResourcesID3" },
-            { true, FT_SHORT, "Flags" },
             { true, FT_BYTE, "RaceID" },
             { true, FT_BYTE, "SexID" },
             { true, FT_BYTE, "BaseSection" },
             { true, FT_BYTE, "VariationIndex" },
             { true, FT_BYTE, "ColorIndex" },
+            { true, FT_SHORT, "Flags" },
+            { true, FT_INT, "MaterialResourcesID1" },
+            { true, FT_INT, "MaterialResourcesID2" },
+            { true, FT_INT, "MaterialResourcesID3" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharSectionsMeta::Instance(), HOTFIX_SEL_CHAR_SECTIONS);
         return &loadInfo;
@@ -674,6 +693,11 @@ struct CharStartOutfitLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "ClassID" },
+            { false, FT_BYTE, "SexID" },
+            { false, FT_BYTE, "OutfitID" },
+            { false, FT_INT, "PetDisplayID" },
+            { false, FT_BYTE, "PetFamilyID" },
             { true, FT_INT, "ItemID1" },
             { true, FT_INT, "ItemID2" },
             { true, FT_INT, "ItemID3" },
@@ -698,11 +722,6 @@ struct CharStartOutfitLoadInfo
             { true, FT_INT, "ItemID22" },
             { true, FT_INT, "ItemID23" },
             { true, FT_INT, "ItemID24" },
-            { false, FT_INT, "PetDisplayID" },
-            { false, FT_BYTE, "ClassID" },
-            { false, FT_BYTE, "SexID" },
-            { false, FT_BYTE, "OutfitID" },
-            { false, FT_BYTE, "PetFamilyID" },
             { false, FT_BYTE, "RaceID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharStartOutfitMeta::Instance(), HOTFIX_SEL_CHAR_START_OUTFIT);
@@ -750,26 +769,26 @@ struct ChrClassesLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_STRING_NOT_LOCALIZED, "PetNameToken" },
             { false, FT_STRING, "Name" },
-            { false, FT_STRING, "NameFemale" },
-            { false, FT_STRING, "NameMale" },
             { false, FT_STRING_NOT_LOCALIZED, "Filename" },
+            { false, FT_STRING, "NameMale" },
+            { false, FT_STRING, "NameFemale" },
+            { false, FT_STRING_NOT_LOCALIZED, "PetNameToken" },
+            { false, FT_INT, "ID" },
             { false, FT_INT, "CreateScreenFileDataID" },
             { false, FT_INT, "SelectScreenFileDataID" },
-            { false, FT_INT, "LowResScreenFileDataID" },
             { false, FT_INT, "IconFileDataID" },
+            { false, FT_INT, "LowResScreenFileDataID" },
             { true, FT_INT, "StartingLevel" },
             { false, FT_SHORT, "Flags" },
             { false, FT_SHORT, "CinematicSequenceID" },
             { false, FT_SHORT, "DefaultSpec" },
+            { false, FT_BYTE, "PrimaryStatPriority" },
             { false, FT_BYTE, "DisplayPower" },
-            { false, FT_BYTE, "SpellClassSet" },
-            { false, FT_BYTE, "AttackPowerPerStrength" },
-            { false, FT_BYTE, "AttackPowerPerAgility" },
             { false, FT_BYTE, "RangedAttackPowerPerAgility" },
-            { false, FT_BYTE, "PrimaryStatPriority" },
-            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "AttackPowerPerAgility" },
+            { false, FT_BYTE, "AttackPowerPerStrength" },
+            { false, FT_BYTE, "SpellClassSet" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES);
         return &loadInfo;
@@ -783,7 +802,7 @@ struct ChrClassesXPowerTypesLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_BYTE, "PowerType" },
+            { true, FT_BYTE, "PowerType" },
             { false, FT_BYTE, "ClassID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassesXPowerTypesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES_X_POWER_TYPES);
@@ -803,9 +822,12 @@ struct ChrRacesLoadInfo
             { false, FT_STRING, "NameFemale" },
             { false, FT_STRING, "NameLowercase" },
             { false, FT_STRING, "NameFemaleLowercase" },
+            { false, FT_INT, "ID" },
             { true, FT_INT, "Flags" },
             { false, FT_INT, "MaleDisplayId" },
             { false, FT_INT, "FemaleDisplayId" },
+            { false, FT_INT, "HighResMaleDisplayId" },
+            { false, FT_INT, "HighResFemaleDisplayId" },
             { true, FT_INT, "CreateScreenFileDataID" },
             { true, FT_INT, "SelectScreenFileDataID" },
             { false, FT_FLOAT, "MaleCustomizeOffset1" },
@@ -815,34 +837,39 @@ struct ChrRacesLoadInfo
             { false, FT_FLOAT, "FemaleCustomizeOffset2" },
             { false, FT_FLOAT, "FemaleCustomizeOffset3" },
             { true, FT_INT, "LowResScreenFileDataID" },
+            { false, FT_INT, "AlteredFormStartVisualKitID1" },
+            { false, FT_INT, "AlteredFormStartVisualKitID2" },
+            { false, FT_INT, "AlteredFormStartVisualKitID3" },
+            { false, FT_INT, "AlteredFormFinishVisualKitID1" },
+            { false, FT_INT, "AlteredFormFinishVisualKitID2" },
+            { false, FT_INT, "AlteredFormFinishVisualKitID3" },
+            { true, FT_INT, "HeritageArmorAchievementID" },
             { true, FT_INT, "StartingLevel" },
             { true, FT_INT, "UiDisplayOrder" },
+            { true, FT_INT, "FemaleSkeletonFileDataID" },
+            { true, FT_INT, "MaleSkeletonFileDataID" },
+            { true, FT_INT, "HelmVisFallbackRaceID" },
             { true, FT_SHORT, "FactionID" },
+            { true, FT_SHORT, "CinematicSequenceID" },
             { true, FT_SHORT, "ResSicknessSpellID" },
             { true, FT_SHORT, "SplashSoundID" },
-            { true, FT_SHORT, "CinematicSequenceID" },
             { true, FT_BYTE, "BaseLanguage" },
             { true, FT_BYTE, "CreatureType" },
             { true, FT_BYTE, "Alliance" },
             { true, FT_BYTE, "RaceRelated" },
             { true, FT_BYTE, "UnalteredVisualRaceID" },
             { true, FT_BYTE, "CharComponentTextureLayoutID" },
+            { true, FT_BYTE, "CharComponentTexLayoutHiResID" },
             { true, FT_BYTE, "DefaultClassID" },
             { true, FT_BYTE, "NeutralRaceID" },
-            { true, FT_BYTE, "DisplayRaceID" },
-            { true, FT_BYTE, "CharComponentTexLayoutHiResID" },
-            { false, FT_INT, "ID" },
-            { false, FT_INT, "HighResMaleDisplayId" },
-            { false, FT_INT, "HighResFemaleDisplayId" },
-            { true, FT_INT, "HeritageArmorAchievementID" },
-            { true, FT_INT, "MaleSkeletonFileDataID" },
-            { true, FT_INT, "FemaleSkeletonFileDataID" },
-            { false, FT_INT, "AlteredFormStartVisualKitID1" },
-            { false, FT_INT, "AlteredFormStartVisualKitID2" },
-            { false, FT_INT, "AlteredFormStartVisualKitID3" },
-            { false, FT_INT, "AlteredFormFinishVisualKitID1" },
-            { false, FT_INT, "AlteredFormFinishVisualKitID2" },
-            { false, FT_INT, "AlteredFormFinishVisualKitID3" },
+            { true, FT_BYTE, "MaleModelFallbackRaceID" },
+            { true, FT_BYTE, "MaleModelFallbackSex" },
+            { true, FT_BYTE, "FemaleModelFallbackRaceID" },
+            { true, FT_BYTE, "FemaleModelFallbackSex" },
+            { true, FT_BYTE, "MaleTextureFallbackRaceID" },
+            { true, FT_BYTE, "MaleTextureFallbackSex" },
+            { true, FT_BYTE, "FemaleTextureFallbackRaceID" },
+            { true, FT_BYTE, "FemaleTextureFallbackSex" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrRacesMeta::Instance(), HOTFIX_SEL_CHR_RACES);
         return &loadInfo;
@@ -858,17 +885,17 @@ struct ChrSpecializationLoadInfo
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "FemaleName" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "MasterySpellID1" },
-            { true, FT_INT, "MasterySpellID2" },
+            { false, FT_INT, "ID" },
             { true, FT_BYTE, "ClassID" },
             { true, FT_BYTE, "OrderIndex" },
             { true, FT_BYTE, "PetTalentType" },
             { true, FT_BYTE, "Role" },
-            { true, FT_BYTE, "PrimaryStatPriority" },
-            { false, FT_INT, "ID" },
-            { true, FT_INT, "SpellIconFileID" },
             { false, FT_INT, "Flags" },
+            { true, FT_INT, "SpellIconFileID" },
+            { true, FT_BYTE, "PrimaryStatPriority" },
             { true, FT_INT, "AnimReplacements" },
+            { true, FT_INT, "MasterySpellID1" },
+            { true, FT_INT, "MasterySpellID2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrSpecializationMeta::Instance(), HOTFIX_SEL_CHR_SPECIALIZATION);
         return &loadInfo;
@@ -882,10 +909,10 @@ struct CinematicCameraLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "SoundID" },
             { false, FT_FLOAT, "OriginX" },
             { false, FT_FLOAT, "OriginY" },
             { false, FT_FLOAT, "OriginZ" },
+            { false, FT_INT, "SoundID" },
             { false, FT_FLOAT, "OriginFacing" },
             { false, FT_INT, "FileDataID" },
         };
@@ -916,6 +943,24 @@ struct CinematicSequencesLoadInfo
     }
 };
 
+struct ContentTuningLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "MinLevel" },
+            { true, FT_INT, "MaxLevel" },
+            { true, FT_INT, "Flags" },
+            { true, FT_INT, "ExpectedStatModID" },
+            { true, FT_INT, "DifficultyESMID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ContentTuningMeta::Instance(), HOTFIX_SEL_CONTENT_TUNING);
+        return &loadInfo;
+    }
+};
+
 struct ConversationLineLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -944,27 +989,29 @@ struct CreatureDisplayInfoLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "CreatureModelScale" },
             { false, FT_SHORT, "ModelID" },
-            { false, FT_SHORT, "NPCSoundID" },
+            { false, FT_SHORT, "SoundID" },
             { true, FT_BYTE, "SizeClass" },
-            { false, FT_BYTE, "Flags" },
-            { true, FT_BYTE, "Gender" },
-            { true, FT_INT, "ExtendedDisplayInfoID" },
-            { true, FT_INT, "PortraitTextureFileDataID" },
+            { false, FT_FLOAT, "CreatureModelScale" },
             { false, FT_BYTE, "CreatureModelAlpha" },
-            { false, FT_SHORT, "SoundID" },
-            { false, FT_FLOAT, "PlayerOverrideScale" },
-            { true, FT_INT, "PortraitCreatureDisplayInfoID" },
             { false, FT_BYTE, "BloodID" },
+            { true, FT_INT, "ExtendedDisplayInfoID" },
+            { false, FT_SHORT, "NPCSoundID" },
             { false, FT_SHORT, "ParticleColorID" },
-            { false, FT_INT, "CreatureGeosetData" },
+            { true, FT_INT, "PortraitCreatureDisplayInfoID" },
+            { true, FT_INT, "PortraitTextureFileDataID" },
             { false, FT_SHORT, "ObjectEffectPackageID" },
             { false, FT_SHORT, "AnimReplacementSetID" },
-            { true, FT_BYTE, "UnarmedWeaponType" },
+            { false, FT_BYTE, "Flags" },
             { true, FT_INT, "StateSpellVisualKitID" },
+            { false, FT_FLOAT, "PlayerOverrideScale" },
             { false, FT_FLOAT, "PetInstanceScale" },
+            { true, FT_BYTE, "UnarmedWeaponType" },
             { true, FT_INT, "MountPoofSpellVisualKitID" },
+            { true, FT_INT, "DissolveEffectID" },
+            { true, FT_BYTE, "Gender" },
+            { true, FT_INT, "DissolveOutEffectID" },
+            { true, FT_BYTE, "CreatureModelMinLod" },
             { true, FT_INT, "TextureVariationFileDataID1" },
             { true, FT_INT, "TextureVariationFileDataID2" },
             { true, FT_INT, "TextureVariationFileDataID3" },
@@ -981,8 +1028,6 @@ struct CreatureDisplayInfoExtraLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "BakeMaterialResourcesID" },
-            { true, FT_INT, "HDBakeMaterialResourcesID" },
             { true, FT_BYTE, "DisplayRaceID" },
             { true, FT_BYTE, "DisplaySexID" },
             { true, FT_BYTE, "DisplayClassID" },
@@ -991,10 +1036,12 @@ struct CreatureDisplayInfoExtraLoadInfo
             { true, FT_BYTE, "HairStyleID" },
             { true, FT_BYTE, "HairColorID" },
             { true, FT_BYTE, "FacialHairID" },
+            { true, FT_BYTE, "Flags" },
+            { true, FT_INT, "BakeMaterialResourcesID" },
+            { true, FT_INT, "HDBakeMaterialResourcesID" },
             { false, FT_BYTE, "CustomDisplayOption1" },
             { false, FT_BYTE, "CustomDisplayOption2" },
             { false, FT_BYTE, "CustomDisplayOption3" },
-            { true, FT_BYTE, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureDisplayInfoExtraMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO_EXTRA);
         return &loadInfo;
@@ -1010,14 +1057,14 @@ struct CreatureFamilyLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_FLOAT, "MinScale" },
+            { true, FT_BYTE, "MinScaleLevel" },
             { false, FT_FLOAT, "MaxScale" },
+            { true, FT_BYTE, "MaxScaleLevel" },
+            { true, FT_SHORT, "PetFoodMask" },
+            { true, FT_BYTE, "PetTalentType" },
             { true, FT_INT, "IconFileID" },
             { true, FT_SHORT, "SkillLine1" },
             { true, FT_SHORT, "SkillLine2" },
-            { true, FT_SHORT, "PetFoodMask" },
-            { true, FT_BYTE, "MinScaleLevel" },
-            { true, FT_BYTE, "MaxScaleLevel" },
-            { true, FT_BYTE, "PetTalentType" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureFamilyMeta::Instance(), HOTFIX_SEL_CREATURE_FAMILY);
         return &loadInfo;
@@ -1031,39 +1078,39 @@ struct CreatureModelDataLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "ModelScale" },
-            { false, FT_FLOAT, "FootprintTextureLength" },
-            { false, FT_FLOAT, "FootprintTextureWidth" },
-            { false, FT_FLOAT, "FootprintParticleScale" },
-            { false, FT_FLOAT, "CollisionWidth" },
-            { false, FT_FLOAT, "CollisionHeight" },
-            { false, FT_FLOAT, "MountHeight" },
             { false, FT_FLOAT, "GeoBox1" },
             { false, FT_FLOAT, "GeoBox2" },
             { false, FT_FLOAT, "GeoBox3" },
             { false, FT_FLOAT, "GeoBox4" },
             { false, FT_FLOAT, "GeoBox5" },
             { false, FT_FLOAT, "GeoBox6" },
-            { false, FT_FLOAT, "WorldEffectScale" },
-            { false, FT_FLOAT, "AttachedEffectScale" },
-            { false, FT_FLOAT, "MissileCollisionRadius" },
-            { false, FT_FLOAT, "MissileCollisionPush" },
-            { false, FT_FLOAT, "MissileCollisionRaise" },
-            { false, FT_FLOAT, "OverrideLootEffectScale" },
-            { false, FT_FLOAT, "OverrideNameScale" },
-            { false, FT_FLOAT, "OverrideSelectionRadius" },
-            { false, FT_FLOAT, "TamedPetBaseScale" },
-            { false, FT_FLOAT, "HoverHeight" },
             { false, FT_INT, "Flags" },
             { false, FT_INT, "FileDataID" },
-            { false, FT_INT, "SizeClass" },
             { false, FT_INT, "BloodID" },
             { false, FT_INT, "FootprintTextureID" },
+            { false, FT_FLOAT, "FootprintTextureLength" },
+            { false, FT_FLOAT, "FootprintTextureWidth" },
+            { false, FT_FLOAT, "FootprintParticleScale" },
             { false, FT_INT, "FoleyMaterialID" },
             { false, FT_INT, "FootstepCameraEffectID" },
             { false, FT_INT, "DeathThudCameraEffectID" },
             { false, FT_INT, "SoundID" },
+            { false, FT_INT, "SizeClass" },
+            { false, FT_FLOAT, "CollisionWidth" },
+            { false, FT_FLOAT, "CollisionHeight" },
+            { false, FT_FLOAT, "WorldEffectScale" },
             { false, FT_INT, "CreatureGeosetDataID" },
+            { false, FT_FLOAT, "HoverHeight" },
+            { false, FT_FLOAT, "AttachedEffectScale" },
+            { false, FT_FLOAT, "ModelScale" },
+            { false, FT_FLOAT, "MissileCollisionRadius" },
+            { false, FT_FLOAT, "MissileCollisionPush" },
+            { false, FT_FLOAT, "MissileCollisionRaise" },
+            { false, FT_FLOAT, "MountHeight" },
+            { false, FT_FLOAT, "OverrideLootEffectScale" },
+            { false, FT_FLOAT, "OverrideNameScale" },
+            { false, FT_FLOAT, "OverrideSelectionRadius" },
+            { false, FT_FLOAT, "TamedPetBaseScale" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureModelDataMeta::Instance(), HOTFIX_SEL_CREATURE_MODEL_DATA);
         return &loadInfo;
@@ -1092,16 +1139,16 @@ struct CriteriaLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "Asset" },
-            { true, FT_INT, "StartAsset" },
-            { true, FT_INT, "FailAsset" },
+            { true, FT_SHORT, "Type" },
+            { true, FT_INT, "Asset" },
             { false, FT_INT, "ModifierTreeId" },
-            { false, FT_SHORT, "StartTimer" },
-            { true, FT_SHORT, "EligibilityWorldStateID" },
-            { false, FT_BYTE, "Type" },
             { false, FT_BYTE, "StartEvent" },
+            { true, FT_INT, "StartAsset" },
+            { false, FT_SHORT, "StartTimer" },
             { false, FT_BYTE, "FailEvent" },
+            { true, FT_INT, "FailAsset" },
             { false, FT_BYTE, "Flags" },
+            { true, FT_SHORT, "EligibilityWorldStateID" },
             { true, FT_BYTE, "EligibilityWorldStateValue" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CriteriaMeta::Instance(), HOTFIX_SEL_CRITERIA);
@@ -1117,12 +1164,12 @@ struct CriteriaTreeLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "Amount" },
-            { true, FT_SHORT, "Flags" },
+            { false, FT_INT, "Parent" },
+            { false, FT_INT, "Amount" },
             { true, FT_BYTE, "Operator" },
             { false, FT_INT, "CriteriaID" },
-            { false, FT_INT, "Parent" },
             { true, FT_INT, "OrderIndex" },
+            { true, FT_SHORT, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CriteriaTreeMeta::Instance(), HOTFIX_SEL_CRITERIA_TREE);
         return &loadInfo;
@@ -1138,14 +1185,15 @@ struct CurrencyTypesLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
-            { false, FT_INT, "MaxQty" },
-            { false, FT_INT, "MaxEarnablePerWeek" },
-            { false, FT_INT, "Flags" },
             { false, FT_BYTE, "CategoryID" },
-            { false, FT_BYTE, "SpellCategory" },
-            { false, FT_BYTE, "Quality" },
             { true, FT_INT, "InventoryIconFileID" },
             { false, FT_INT, "SpellWeight" },
+            { false, FT_BYTE, "SpellCategory" },
+            { false, FT_INT, "MaxQty" },
+            { false, FT_INT, "MaxEarnablePerWeek" },
+            { false, FT_INT, "Flags" },
+            { true, FT_BYTE, "Quality" },
+            { true, FT_INT, "FactionID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CurrencyTypesMeta::Instance(), HOTFIX_SEL_CURRENCY_TYPES);
         return &loadInfo;
@@ -1191,28 +1239,28 @@ struct DestructibleModelDataLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "State0Wmo" },
-            { false, FT_SHORT, "State1Wmo" },
-            { false, FT_SHORT, "State2Wmo" },
-            { false, FT_SHORT, "State3Wmo" },
-            { false, FT_SHORT, "HealEffectSpeed" },
             { true, FT_BYTE, "State0ImpactEffectDoodadSet" },
             { false, FT_BYTE, "State0AmbientDoodadSet" },
-            { true, FT_BYTE, "State0NameSet" },
+            { false, FT_SHORT, "State1Wmo" },
             { true, FT_BYTE, "State1DestructionDoodadSet" },
             { true, FT_BYTE, "State1ImpactEffectDoodadSet" },
             { false, FT_BYTE, "State1AmbientDoodadSet" },
-            { true, FT_BYTE, "State1NameSet" },
+            { false, FT_SHORT, "State2Wmo" },
             { true, FT_BYTE, "State2DestructionDoodadSet" },
             { true, FT_BYTE, "State2ImpactEffectDoodadSet" },
             { false, FT_BYTE, "State2AmbientDoodadSet" },
-            { true, FT_BYTE, "State2NameSet" },
+            { false, FT_SHORT, "State3Wmo" },
             { false, FT_BYTE, "State3InitDoodadSet" },
             { false, FT_BYTE, "State3AmbientDoodadSet" },
-            { true, FT_BYTE, "State3NameSet" },
             { false, FT_BYTE, "EjectDirection" },
             { false, FT_BYTE, "DoNotHighlight" },
+            { false, FT_SHORT, "State0Wmo" },
             { false, FT_BYTE, "HealEffect" },
+            { false, FT_SHORT, "HealEffectSpeed" },
+            { true, FT_BYTE, "State0NameSet" },
+            { true, FT_BYTE, "State1NameSet" },
+            { true, FT_BYTE, "State2NameSet" },
+            { true, FT_BYTE, "State3NameSet" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DestructibleModelDataMeta::Instance(), HOTFIX_SEL_DESTRUCTIBLE_MODEL_DATA);
         return &loadInfo;
@@ -1227,18 +1275,18 @@ struct DifficultyLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
-            { false, FT_SHORT, "GroupSizeHealthCurveID" },
-            { false, FT_SHORT, "GroupSizeDmgCurveID" },
-            { false, FT_SHORT, "GroupSizeSpellPointsCurveID" },
-            { false, FT_BYTE, "FallbackDifficultyID" },
             { false, FT_BYTE, "InstanceType" },
+            { false, FT_BYTE, "OrderIndex" },
+            { true, FT_BYTE, "OldEnumValue" },
+            { false, FT_BYTE, "FallbackDifficultyID" },
             { false, FT_BYTE, "MinPlayers" },
             { false, FT_BYTE, "MaxPlayers" },
-            { true, FT_BYTE, "OldEnumValue" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "ToggleDifficultyID" },
             { false, FT_BYTE, "ItemContext" },
-            { false, FT_BYTE, "OrderIndex" },
+            { false, FT_BYTE, "ToggleDifficultyID" },
+            { false, FT_SHORT, "GroupSizeHealthCurveID" },
+            { false, FT_SHORT, "GroupSizeDmgCurveID" },
+            { false, FT_SHORT, "GroupSizeSpellPointsCurveID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DifficultyMeta::Instance(), HOTFIX_SEL_DIFFICULTY);
         return &loadInfo;
@@ -1252,13 +1300,13 @@ struct DungeonEncounterLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Name" },
-            { true, FT_INT, "CreatureDisplayID" },
+            { false, FT_INT, "ID" },
             { true, FT_SHORT, "MapID" },
             { true, FT_BYTE, "DifficultyID" },
+            { true, FT_INT, "OrderIndex" },
             { true, FT_BYTE, "Bit" },
+            { true, FT_INT, "CreatureDisplayID" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
-            { true, FT_INT, "OrderIndex" },
             { true, FT_INT, "SpellIconFileID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DungeonEncounterMeta::Instance(), HOTFIX_SEL_DUNGEON_ENCOUNTER);
@@ -1331,13 +1379,13 @@ struct EmotesLoadInfo
             { false, FT_INT, "ID" },
             { true, FT_LONG, "RaceMask" },
             { false, FT_STRING_NOT_LOCALIZED, "EmoteSlashCommand" },
+            { true, FT_INT, "AnimID" },
             { false, FT_INT, "EmoteFlags" },
-            { false, FT_INT, "SpellVisualKitID" },
-            { true, FT_SHORT, "AnimID" },
             { false, FT_BYTE, "EmoteSpecProc" },
-            { true, FT_INT, "ClassMask" },
             { false, FT_INT, "EmoteSpecProcParam" },
             { false, FT_INT, "EventSoundID" },
+            { false, FT_INT, "SpellVisualKitID" },
+            { true, FT_INT, "ClassMask" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, EmotesMeta::Instance(), HOTFIX_SEL_EMOTES);
         return &loadInfo;
@@ -1367,8 +1415,8 @@ struct EmotesTextSoundLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_BYTE, "RaceID" },
-            { false, FT_BYTE, "SexID" },
             { false, FT_BYTE, "ClassID" },
+            { false, FT_BYTE, "SexID" },
             { false, FT_INT, "SoundID" },
             { false, FT_SHORT, "EmotesTextID" },
         };
@@ -1377,6 +1425,52 @@ struct EmotesTextSoundLoadInfo
     }
 };
 
+struct ExpectedStatLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "ExpansionID" },
+            { false, FT_FLOAT, "CreatureHealth" },
+            { false, FT_FLOAT, "PlayerHealth" },
+            { false, FT_FLOAT, "CreatureAutoAttackDps" },
+            { false, FT_FLOAT, "CreatureArmor" },
+            { false, FT_FLOAT, "PlayerMana" },
+            { false, FT_FLOAT, "PlayerPrimaryStat" },
+            { false, FT_FLOAT, "PlayerSecondaryStat" },
+            { false, FT_FLOAT, "ArmorConstant" },
+            { false, FT_FLOAT, "CreatureSpellDamage" },
+            { true, FT_INT, "Lvl" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ExpectedStatMeta::Instance(), HOTFIX_SEL_EXPECTED_STAT);
+        return &loadInfo;
+    }
+};
+
+struct ExpectedStatModLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { false, FT_FLOAT, "CreatureHealthMod" },
+            { false, FT_FLOAT, "PlayerHealthMod" },
+            { false, FT_FLOAT, "CreatureAutoAttackDPSMod" },
+            { false, FT_FLOAT, "CreatureArmorMod" },
+            { false, FT_FLOAT, "PlayerManaMod" },
+            { false, FT_FLOAT, "PlayerPrimaryStatMod" },
+            { false, FT_FLOAT, "PlayerSecondaryStatMod" },
+            { false, FT_FLOAT, "ArmorConstantMod" },
+            { false, FT_FLOAT, "CreatureSpellDamageMod" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ExpectedStatModMeta::Instance(), HOTFIX_SEL_EXPECTED_STAT_MOD);
+        return &loadInfo;
+    }
+};
+
 struct FactionLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -1390,17 +1484,12 @@ struct FactionLoadInfo
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
             { false, FT_INT, "ID" },
-            { true, FT_INT, "ReputationBase1" },
-            { true, FT_INT, "ReputationBase2" },
-            { true, FT_INT, "ReputationBase3" },
-            { true, FT_INT, "ReputationBase4" },
-            { false, FT_FLOAT, "ParentFactionMod1" },
-            { false, FT_FLOAT, "ParentFactionMod2" },
-            { true, FT_INT, "ReputationMax1" },
-            { true, FT_INT, "ReputationMax2" },
-            { true, FT_INT, "ReputationMax3" },
-            { true, FT_INT, "ReputationMax4" },
             { true, FT_SHORT, "ReputationIndex" },
+            { false, FT_SHORT, "ParentFactionID" },
+            { false, FT_BYTE, "Expansion" },
+            { false, FT_BYTE, "FriendshipRepID" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_SHORT, "ParagonFactionID" },
             { true, FT_SHORT, "ReputationClassMask1" },
             { true, FT_SHORT, "ReputationClassMask2" },
             { true, FT_SHORT, "ReputationClassMask3" },
@@ -1409,13 +1498,18 @@ struct FactionLoadInfo
             { false, FT_SHORT, "ReputationFlags2" },
             { false, FT_SHORT, "ReputationFlags3" },
             { false, FT_SHORT, "ReputationFlags4" },
-            { false, FT_SHORT, "ParentFactionID" },
-            { false, FT_SHORT, "ParagonFactionID" },
+            { true, FT_INT, "ReputationBase1" },
+            { true, FT_INT, "ReputationBase2" },
+            { true, FT_INT, "ReputationBase3" },
+            { true, FT_INT, "ReputationBase4" },
+            { true, FT_INT, "ReputationMax1" },
+            { true, FT_INT, "ReputationMax2" },
+            { true, FT_INT, "ReputationMax3" },
+            { true, FT_INT, "ReputationMax4" },
+            { false, FT_FLOAT, "ParentFactionMod1" },
+            { false, FT_FLOAT, "ParentFactionMod2" },
             { false, FT_BYTE, "ParentFactionCap1" },
             { false, FT_BYTE, "ParentFactionCap2" },
-            { false, FT_BYTE, "Expansion" },
-            { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "FriendshipRepID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FactionMeta::Instance(), HOTFIX_SEL_FACTION);
         return &loadInfo;
@@ -1431,6 +1525,9 @@ struct FactionTemplateLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_SHORT, "Faction" },
             { false, FT_SHORT, "Flags" },
+            { false, FT_BYTE, "FactionGroup" },
+            { false, FT_BYTE, "FriendGroup" },
+            { false, FT_BYTE, "EnemyGroup" },
             { false, FT_SHORT, "Enemies1" },
             { false, FT_SHORT, "Enemies2" },
             { false, FT_SHORT, "Enemies3" },
@@ -1439,9 +1536,6 @@ struct FactionTemplateLoadInfo
             { false, FT_SHORT, "Friend2" },
             { false, FT_SHORT, "Friend3" },
             { false, FT_SHORT, "Friend4" },
-            { false, FT_BYTE, "FactionGroup" },
-            { false, FT_BYTE, "FriendGroup" },
-            { false, FT_BYTE, "EnemyGroup" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FactionTemplateMeta::Instance(), HOTFIX_SEL_FACTION_TEMPLATE);
         return &loadInfo;
@@ -1455,16 +1549,16 @@ struct GameobjectDisplayInfoLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "FileDataID" },
             { false, FT_FLOAT, "GeoBoxMinX" },
             { false, FT_FLOAT, "GeoBoxMinY" },
             { false, FT_FLOAT, "GeoBoxMinZ" },
             { false, FT_FLOAT, "GeoBoxMaxX" },
             { false, FT_FLOAT, "GeoBoxMaxY" },
             { false, FT_FLOAT, "GeoBoxMaxZ" },
+            { true, FT_INT, "FileDataID" },
+            { true, FT_SHORT, "ObjectEffectPackageID" },
             { false, FT_FLOAT, "OverrideLootEffectScale" },
             { false, FT_FLOAT, "OverrideNameScale" },
-            { true, FT_SHORT, "ObjectEffectPackageID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameObjectDisplayInfoMeta::Instance(), HOTFIX_SEL_GAMEOBJECT_DISPLAY_INFO);
         return &loadInfo;
@@ -1485,7 +1579,14 @@ struct GameobjectsLoadInfo
             { false, FT_FLOAT, "Rot2" },
             { false, FT_FLOAT, "Rot3" },
             { false, FT_FLOAT, "Rot4" },
+            { false, FT_INT, "ID" },
+            { false, FT_SHORT, "OwnerID" },
+            { false, FT_SHORT, "DisplayID" },
             { false, FT_FLOAT, "Scale" },
+            { false, FT_BYTE, "TypeID" },
+            { false, FT_BYTE, "PhaseUseFlags" },
+            { false, FT_SHORT, "PhaseID" },
+            { false, FT_SHORT, "PhaseGroupID" },
             { true, FT_INT, "PropValue1" },
             { true, FT_INT, "PropValue2" },
             { true, FT_INT, "PropValue3" },
@@ -1494,13 +1595,6 @@ struct GameobjectsLoadInfo
             { true, FT_INT, "PropValue6" },
             { true, FT_INT, "PropValue7" },
             { true, FT_INT, "PropValue8" },
-            { false, FT_SHORT, "OwnerID" },
-            { false, FT_SHORT, "DisplayID" },
-            { false, FT_SHORT, "PhaseID" },
-            { false, FT_SHORT, "PhaseGroupID" },
-            { false, FT_BYTE, "PhaseUseFlags" },
-            { false, FT_BYTE, "TypeID" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameObjectsMeta::Instance(), HOTFIX_SEL_GAMEOBJECTS);
         return &loadInfo;
@@ -1515,12 +1609,12 @@ struct GarrAbilityLoadInfo
         {
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "IconFileDataID" },
-            { false, FT_SHORT, "Flags" },
-            { false, FT_SHORT, "FactionChangeGarrAbilityID" },
+            { false, FT_INT, "ID" },
             { false, FT_BYTE, "GarrAbilityCategoryID" },
             { false, FT_BYTE, "GarrFollowerTypeID" },
-            { false, FT_INT, "ID" },
+            { true, FT_INT, "IconFileDataID" },
+            { false, FT_SHORT, "FactionChangeGarrAbilityID" },
+            { false, FT_SHORT, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrAbilityMeta::Instance(), HOTFIX_SEL_GARR_ABILITY);
         return &loadInfo;
@@ -1534,30 +1628,30 @@ struct GarrBuildingLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_STRING, "AllianceName" },
             { false, FT_STRING, "HordeName" },
+            { false, FT_STRING, "AllianceName" },
             { false, FT_STRING, "Description" },
             { false, FT_STRING, "Tooltip" },
+            { false, FT_BYTE, "GarrTypeID" },
+            { false, FT_BYTE, "BuildingType" },
             { true, FT_INT, "HordeGameObjectID" },
             { true, FT_INT, "AllianceGameObjectID" },
-            { true, FT_INT, "IconFileDataID" },
+            { false, FT_BYTE, "GarrSiteID" },
+            { false, FT_BYTE, "UpgradeLevel" },
+            { true, FT_INT, "BuildSeconds" },
             { false, FT_SHORT, "CurrencyTypeID" },
+            { true, FT_INT, "CurrencyQty" },
             { false, FT_SHORT, "HordeUiTextureKitID" },
             { false, FT_SHORT, "AllianceUiTextureKitID" },
+            { true, FT_INT, "IconFileDataID" },
             { false, FT_SHORT, "AllianceSceneScriptPackageID" },
             { false, FT_SHORT, "HordeSceneScriptPackageID" },
+            { true, FT_INT, "MaxAssignments" },
+            { false, FT_BYTE, "ShipmentCapacity" },
             { false, FT_SHORT, "GarrAbilityID" },
             { false, FT_SHORT, "BonusGarrAbilityID" },
             { false, FT_SHORT, "GoldCost" },
-            { false, FT_BYTE, "GarrSiteID" },
-            { false, FT_BYTE, "BuildingType" },
-            { false, FT_BYTE, "UpgradeLevel" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "ShipmentCapacity" },
-            { false, FT_BYTE, "GarrTypeID" },
-            { true, FT_INT, "BuildSeconds" },
-            { true, FT_INT, "CurrencyQty" },
-            { true, FT_INT, "MaxAssignments" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrBuildingMeta::Instance(), HOTFIX_SEL_GARR_BUILDING);
         return &loadInfo;
@@ -1572,10 +1666,10 @@ struct GarrBuildingPlotInstLoadInfo
         {
             { false, FT_FLOAT, "MapOffsetX" },
             { false, FT_FLOAT, "MapOffsetY" },
-            { false, FT_SHORT, "UiTextureAtlasMemberID" },
-            { false, FT_SHORT, "GarrSiteLevelPlotInstID" },
-            { false, FT_BYTE, "GarrBuildingID" },
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "GarrBuildingID" },
+            { false, FT_SHORT, "GarrSiteLevelPlotInstID" },
+            { false, FT_SHORT, "UiTextureAtlasMemberID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrBuildingPlotInstMeta::Instance(), HOTFIX_SEL_GARR_BUILDING_PLOT_INST);
         return &loadInfo;
@@ -1591,11 +1685,11 @@ struct GarrClassSpecLoadInfo
             { false, FT_STRING, "ClassSpec" },
             { false, FT_STRING, "ClassSpecMale" },
             { false, FT_STRING, "ClassSpecFemale" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "UiTextureAtlasMemberID" },
             { false, FT_SHORT, "GarrFollItemSetID" },
             { false, FT_BYTE, "FollowerClassLimit" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrClassSpecMeta::Instance(), HOTFIX_SEL_GARR_CLASS_SPEC);
         return &loadInfo;
@@ -1611,35 +1705,35 @@ struct GarrFollowerLoadInfo
             { false, FT_STRING, "HordeSourceText" },
             { false, FT_STRING, "AllianceSourceText" },
             { false, FT_STRING, "TitleName" },
+            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "GarrTypeID" },
+            { false, FT_BYTE, "GarrFollowerTypeID" },
             { true, FT_INT, "HordeCreatureID" },
             { true, FT_INT, "AllianceCreatureID" },
-            { true, FT_INT, "HordeIconFileDataID" },
-            { true, FT_INT, "AllianceIconFileDataID" },
-            { false, FT_INT, "HordeSlottingBroadcastTextID" },
-            { false, FT_INT, "AllySlottingBroadcastTextID" },
-            { false, FT_SHORT, "HordeGarrFollItemSetID" },
-            { false, FT_SHORT, "AllianceGarrFollItemSetID" },
-            { false, FT_SHORT, "ItemLevelWeapon" },
-            { false, FT_SHORT, "ItemLevelArmor" },
-            { false, FT_SHORT, "HordeUITextureKitID" },
-            { false, FT_SHORT, "AllianceUITextureKitID" },
-            { false, FT_BYTE, "GarrFollowerTypeID" },
             { false, FT_BYTE, "HordeGarrFollRaceID" },
             { false, FT_BYTE, "AllianceGarrFollRaceID" },
-            { false, FT_BYTE, "Quality" },
             { false, FT_BYTE, "HordeGarrClassSpecID" },
             { false, FT_BYTE, "AllianceGarrClassSpecID" },
+            { false, FT_BYTE, "Quality" },
             { false, FT_BYTE, "FollowerLevel" },
-            { false, FT_BYTE, "Gender" },
-            { false, FT_BYTE, "Flags" },
+            { false, FT_SHORT, "ItemLevelWeapon" },
+            { false, FT_SHORT, "ItemLevelArmor" },
             { true, FT_BYTE, "HordeSourceTypeEnum" },
             { true, FT_BYTE, "AllianceSourceTypeEnum" },
-            { false, FT_BYTE, "GarrTypeID" },
+            { true, FT_INT, "HordeIconFileDataID" },
+            { true, FT_INT, "AllianceIconFileDataID" },
+            { false, FT_SHORT, "HordeGarrFollItemSetID" },
+            { false, FT_SHORT, "AllianceGarrFollItemSetID" },
+            { false, FT_SHORT, "HordeUITextureKitID" },
+            { false, FT_SHORT, "AllianceUITextureKitID" },
             { false, FT_BYTE, "Vitality" },
-            { false, FT_BYTE, "ChrClassID" },
             { false, FT_BYTE, "HordeFlavorGarrStringID" },
             { false, FT_BYTE, "AllianceFlavorGarrStringID" },
-            { false, FT_INT, "ID" },
+            { false, FT_INT, "HordeSlottingBroadcastTextID" },
+            { false, FT_INT, "AllySlottingBroadcastTextID" },
+            { false, FT_BYTE, "ChrClassID" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "Gender" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER);
         return &loadInfo;
@@ -1653,8 +1747,9 @@ struct GarrFollowerXAbilityLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "GarrAbilityID" },
+            { false, FT_BYTE, "OrderIndex" },
             { false, FT_BYTE, "FactionIndex" },
+            { false, FT_SHORT, "GarrAbilityID" },
             { false, FT_SHORT, "GarrFollowerID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerXAbilityMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_X_ABILITY);
@@ -1669,12 +1764,12 @@ struct GarrPlotLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_STRING, "Name" },
-            { true, FT_INT, "AllianceConstructObjID" },
-            { true, FT_INT, "HordeConstructObjID" },
-            { false, FT_BYTE, "UiCategoryID" },
+            { false, FT_STRING_NOT_LOCALIZED, "Name" },
             { false, FT_BYTE, "PlotType" },
+            { true, FT_INT, "HordeConstructObjID" },
+            { true, FT_INT, "AllianceConstructObjID" },
             { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "UiCategoryID" },
             { false, FT_INT, "UpgradeRequirement1" },
             { false, FT_INT, "UpgradeRequirement2" },
         };
@@ -1722,14 +1817,14 @@ struct GarrSiteLevelLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_FLOAT, "TownHallUiPosX" },
             { false, FT_FLOAT, "TownHallUiPosY" },
+            { false, FT_INT, "GarrSiteID" },
+            { false, FT_BYTE, "GarrLevel" },
             { false, FT_SHORT, "MapID" },
-            { false, FT_SHORT, "UiTextureKitID" },
             { false, FT_SHORT, "UpgradeMovieID" },
+            { false, FT_SHORT, "UiTextureKitID" },
+            { false, FT_BYTE, "MaxBuildingLevel" },
             { false, FT_SHORT, "UpgradeCost" },
             { false, FT_SHORT, "UpgradeGoldCost" },
-            { false, FT_BYTE, "GarrLevel" },
-            { false, FT_BYTE, "GarrSiteID" },
-            { false, FT_BYTE, "MaxBuildingLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrSiteLevelMeta::Instance(), HOTFIX_SEL_GARR_SITE_LEVEL);
         return &loadInfo;
@@ -1761,8 +1856,8 @@ struct GemPropertiesLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "Type" },
             { false, FT_SHORT, "EnchantId" },
+            { true, FT_INT, "Type" },
             { false, FT_SHORT, "MinItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GemPropertiesMeta::Instance(), HOTFIX_SEL_GEM_PROPERTIES);
@@ -1825,8 +1920,8 @@ struct GuildColorBackgroundLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_BYTE, "Red" },
-            { false, FT_BYTE, "Green" },
             { false, FT_BYTE, "Blue" },
+            { false, FT_BYTE, "Green" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildColorBackgroundMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BACKGROUND);
         return &loadInfo;
@@ -1841,8 +1936,8 @@ struct GuildColorBorderLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_BYTE, "Red" },
-            { false, FT_BYTE, "Green" },
             { false, FT_BYTE, "Blue" },
+            { false, FT_BYTE, "Green" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildColorBorderMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BORDER);
         return &loadInfo;
@@ -1857,8 +1952,8 @@ struct GuildColorEmblemLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_BYTE, "Red" },
-            { false, FT_BYTE, "Green" },
             { false, FT_BYTE, "Blue" },
+            { false, FT_BYTE, "Green" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildColorEmblemMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_EMBLEM);
         return &loadInfo;
@@ -1886,19 +1981,19 @@ struct HeirloomLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "SourceText" },
+            { false, FT_INT, "ID" },
             { true, FT_INT, "ItemID" },
-            { true, FT_INT, "LegacyItemID" },
             { true, FT_INT, "LegacyUpgradedItemID" },
             { true, FT_INT, "StaticUpgradedItemID" },
+            { true, FT_BYTE, "SourceTypeEnum" },
+            { false, FT_BYTE, "Flags" },
+            { true, FT_INT, "LegacyItemID" },
             { true, FT_INT, "UpgradeItemID1" },
             { true, FT_INT, "UpgradeItemID2" },
             { true, FT_INT, "UpgradeItemID3" },
             { false, FT_SHORT, "UpgradeItemBonusListID1" },
             { false, FT_SHORT, "UpgradeItemBonusListID2" },
             { false, FT_SHORT, "UpgradeItemBonusListID3" },
-            { false, FT_BYTE, "Flags" },
-            { true, FT_BYTE, "SourceTypeEnum" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HeirloomMeta::Instance(), HOTFIX_SEL_HEIRLOOM);
         return &loadInfo;
@@ -1912,6 +2007,23 @@ struct HolidaysLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "Region" },
+            { false, FT_BYTE, "Looping" },
+            { false, FT_INT, "HolidayNameID" },
+            { false, FT_INT, "HolidayDescriptionID" },
+            { false, FT_BYTE, "Priority" },
+            { true, FT_BYTE, "CalendarFilterType" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_SHORT, "Duration1" },
+            { false, FT_SHORT, "Duration2" },
+            { false, FT_SHORT, "Duration3" },
+            { false, FT_SHORT, "Duration4" },
+            { false, FT_SHORT, "Duration5" },
+            { false, FT_SHORT, "Duration6" },
+            { false, FT_SHORT, "Duration7" },
+            { false, FT_SHORT, "Duration8" },
+            { false, FT_SHORT, "Duration9" },
+            { false, FT_SHORT, "Duration10" },
             { false, FT_INT, "Date1" },
             { false, FT_INT, "Date2" },
             { false, FT_INT, "Date3" },
@@ -1928,18 +2040,6 @@ struct HolidaysLoadInfo
             { false, FT_INT, "Date14" },
             { false, FT_INT, "Date15" },
             { false, FT_INT, "Date16" },
-            { false, FT_SHORT, "Duration1" },
-            { false, FT_SHORT, "Duration2" },
-            { false, FT_SHORT, "Duration3" },
-            { false, FT_SHORT, "Duration4" },
-            { false, FT_SHORT, "Duration5" },
-            { false, FT_SHORT, "Duration6" },
-            { false, FT_SHORT, "Duration7" },
-            { false, FT_SHORT, "Duration8" },
-            { false, FT_SHORT, "Duration9" },
-            { false, FT_SHORT, "Duration10" },
-            { false, FT_SHORT, "Region" },
-            { false, FT_BYTE, "Looping" },
             { false, FT_BYTE, "CalendarFlags1" },
             { false, FT_BYTE, "CalendarFlags2" },
             { false, FT_BYTE, "CalendarFlags3" },
@@ -1950,11 +2050,6 @@ struct HolidaysLoadInfo
             { false, FT_BYTE, "CalendarFlags8" },
             { false, FT_BYTE, "CalendarFlags9" },
             { false, FT_BYTE, "CalendarFlags10" },
-            { false, FT_BYTE, "Priority" },
-            { true, FT_BYTE, "CalendarFilterType" },
-            { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "HolidayNameID" },
-            { false, FT_INT, "HolidayDescriptionID" },
             { true, FT_INT, "TextureFileDataID1" },
             { true, FT_INT, "TextureFileDataID2" },
             { true, FT_INT, "TextureFileDataID3" },
@@ -2030,13 +2125,13 @@ struct ItemLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "IconFileDataID" },
             { false, FT_BYTE, "ClassID" },
             { false, FT_BYTE, "SubclassID" },
-            { true, FT_BYTE, "SoundOverrideSubclassID" },
             { false, FT_BYTE, "Material" },
-            { false, FT_BYTE, "InventoryType" },
+            { true, FT_BYTE, "InventoryType" },
             { false, FT_BYTE, "SheatheType" },
+            { true, FT_BYTE, "SoundOverrideSubclassID" },
+            { true, FT_INT, "IconFileDataID" },
             { false, FT_BYTE, "ItemGroupSoundsID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemMeta::Instance(), HOTFIX_SEL_ITEM);
@@ -2051,10 +2146,10 @@ struct ItemAppearanceLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DisplayType" },
             { true, FT_INT, "ItemDisplayInfoID" },
             { true, FT_INT, "DefaultIconFileDataID" },
             { true, FT_INT, "UiOrder" },
-            { false, FT_BYTE, "DisplayType" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemAppearanceMeta::Instance(), HOTFIX_SEL_ITEM_APPEARANCE);
         return &loadInfo;
@@ -2075,7 +2170,6 @@ struct ItemArmorQualityLoadInfo
             { false, FT_FLOAT, "Qualitymod5" },
             { false, FT_FLOAT, "Qualitymod6" },
             { false, FT_FLOAT, "Qualitymod7" },
-            { true, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemArmorQualityMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_QUALITY);
         return &loadInfo;
@@ -2110,11 +2204,11 @@ struct ItemArmorTotalLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { true, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Cloth" },
             { false, FT_FLOAT, "Leather" },
             { false, FT_FLOAT, "Mail" },
             { false, FT_FLOAT, "Plate" },
-            { true, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemArmorTotalMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_TOTAL);
         return &loadInfo;
@@ -2175,10 +2269,10 @@ struct ItemBonusTreeNodeLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "ItemContext" },
             { false, FT_SHORT, "ChildItemBonusTreeID" },
             { false, FT_SHORT, "ChildItemBonusListID" },
             { false, FT_SHORT, "ChildItemLevelSelectorID" },
-            { false, FT_BYTE, "ItemContext" },
             { false, FT_SHORT, "ParentItemBonusTreeID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemBonusTreeNodeMeta::Instance(), HOTFIX_SEL_ITEM_BONUS_TREE_NODE);
@@ -2210,8 +2304,8 @@ struct ItemClassLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "ClassName" },
-            { false, FT_FLOAT, "PriceModifier" },
             { true, FT_BYTE, "ClassID" },
+            { false, FT_FLOAT, "PriceModifier" },
             { false, FT_BYTE, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemClassMeta::Instance(), HOTFIX_SEL_ITEM_CLASS);
@@ -2240,6 +2334,7 @@ struct ItemDamageAmmoLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2247,7 +2342,6 @@ struct ItemDamageAmmoLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageAmmoMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_AMMO);
         return &loadInfo;
@@ -2261,6 +2355,7 @@ struct ItemDamageOneHandLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2268,7 +2363,6 @@ struct ItemDamageOneHandLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageOneHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND);
         return &loadInfo;
@@ -2282,6 +2376,7 @@ struct ItemDamageOneHandCasterLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2289,7 +2384,6 @@ struct ItemDamageOneHandCasterLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageOneHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND_CASTER);
         return &loadInfo;
@@ -2303,6 +2397,7 @@ struct ItemDamageTwoHandLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2310,7 +2405,6 @@ struct ItemDamageTwoHandLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageTwoHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND);
         return &loadInfo;
@@ -2324,6 +2418,7 @@ struct ItemDamageTwoHandCasterLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Quality1" },
             { false, FT_FLOAT, "Quality2" },
             { false, FT_FLOAT, "Quality3" },
@@ -2331,7 +2426,6 @@ struct ItemDamageTwoHandCasterLoadInfo
             { false, FT_FLOAT, "Quality5" },
             { false, FT_FLOAT, "Quality6" },
             { false, FT_FLOAT, "Quality7" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageTwoHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND_CASTER);
         return &loadInfo;
@@ -2345,11 +2439,11 @@ struct ItemDisenchantLootLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { true, FT_BYTE, "Subclass" },
+            { false, FT_BYTE, "Quality" },
             { false, FT_SHORT, "MinLevel" },
             { false, FT_SHORT, "MaxLevel" },
             { false, FT_SHORT, "SkillRequired" },
-            { true, FT_BYTE, "Subclass" },
-            { false, FT_BYTE, "Quality" },
             { true, FT_BYTE, "ExpansionID" },
             { false, FT_BYTE, "Class" },
         };
@@ -2365,14 +2459,14 @@ struct ItemEffectLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "SpellID" },
+            { false, FT_BYTE, "LegacySlotIndex" },
+            { true, FT_BYTE, "TriggerType" },
+            { true, FT_SHORT, "Charges" },
             { true, FT_INT, "CoolDownMSec" },
             { true, FT_INT, "CategoryCoolDownMSec" },
-            { true, FT_SHORT, "Charges" },
             { false, FT_SHORT, "SpellCategoryID" },
+            { true, FT_INT, "SpellID" },
             { false, FT_SHORT, "ChrSpecializationID" },
-            { false, FT_BYTE, "LegacySlotIndex" },
-            { true, FT_BYTE, "TriggerType" },
             { true, FT_INT, "ParentItemID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemEffectMeta::Instance(), HOTFIX_SEL_ITEM_EFFECT);
@@ -2387,32 +2481,32 @@ struct ItemExtendedCostLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "RequiredArenaRating" },
+            { true, FT_BYTE, "ArenaBracket" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "MinFactionID" },
+            { false, FT_BYTE, "MinReputation" },
+            { false, FT_BYTE, "RequiredAchievement" },
             { true, FT_INT, "ItemID1" },
             { true, FT_INT, "ItemID2" },
             { true, FT_INT, "ItemID3" },
             { true, FT_INT, "ItemID4" },
             { true, FT_INT, "ItemID5" },
-            { false, FT_INT, "CurrencyCount1" },
-            { false, FT_INT, "CurrencyCount2" },
-            { false, FT_INT, "CurrencyCount3" },
-            { false, FT_INT, "CurrencyCount4" },
-            { false, FT_INT, "CurrencyCount5" },
             { false, FT_SHORT, "ItemCount1" },
             { false, FT_SHORT, "ItemCount2" },
             { false, FT_SHORT, "ItemCount3" },
             { false, FT_SHORT, "ItemCount4" },
             { false, FT_SHORT, "ItemCount5" },
-            { false, FT_SHORT, "RequiredArenaRating" },
             { false, FT_SHORT, "CurrencyID1" },
             { false, FT_SHORT, "CurrencyID2" },
             { false, FT_SHORT, "CurrencyID3" },
             { false, FT_SHORT, "CurrencyID4" },
             { false, FT_SHORT, "CurrencyID5" },
-            { false, FT_BYTE, "ArenaBracket" },
-            { false, FT_BYTE, "MinFactionID" },
-            { false, FT_BYTE, "MinReputation" },
-            { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "RequiredAchievement" },
+            { false, FT_INT, "CurrencyCount1" },
+            { false, FT_INT, "CurrencyCount2" },
+            { false, FT_INT, "CurrencyCount3" },
+            { false, FT_INT, "CurrencyCount4" },
+            { false, FT_INT, "CurrencyCount5" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemExtendedCostMeta::Instance(), HOTFIX_SEL_ITEM_EXTENDED_COST);
         return &loadInfo;
@@ -2503,8 +2597,8 @@ struct ItemModifiedAppearanceLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { true, FT_INT, "ItemID" },
             { false, FT_INT, "ID" },
+            { true, FT_INT, "ItemID" },
             { false, FT_BYTE, "ItemAppearanceModifierID" },
             { false, FT_SHORT, "ItemAppearanceID" },
             { false, FT_BYTE, "OrderIndex" },
@@ -2522,9 +2616,9 @@ struct ItemPriceBaseLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_SHORT, "ItemLevel" },
             { false, FT_FLOAT, "Armor" },
             { false, FT_FLOAT, "Weapon" },
-            { false, FT_SHORT, "ItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemPriceBaseMeta::Instance(), HOTFIX_SEL_ITEM_PRICE_BASE);
         return &loadInfo;
@@ -2583,19 +2677,20 @@ struct ItemSearchNameLoadInfo
             { true, FT_LONG, "AllowableRace" },
             { false, FT_STRING, "Display" },
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Flags1" },
-            { true, FT_INT, "Flags2" },
-            { true, FT_INT, "Flags3" },
-            { false, FT_SHORT, "ItemLevel" },
             { false, FT_BYTE, "OverallQualityID" },
             { false, FT_BYTE, "ExpansionID" },
-            { true, FT_BYTE, "RequiredLevel" },
             { false, FT_SHORT, "MinFactionID" },
             { false, FT_BYTE, "MinReputation" },
             { true, FT_INT, "AllowableClass" },
+            { true, FT_BYTE, "RequiredLevel" },
             { false, FT_SHORT, "RequiredSkill" },
             { false, FT_SHORT, "RequiredSkillRank" },
             { false, FT_INT, "RequiredAbility" },
+            { false, FT_SHORT, "ItemLevel" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
+            { true, FT_INT, "Flags3" },
+            { true, FT_INT, "Flags4" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSearchNameMeta::Instance(), HOTFIX_SEL_ITEM_SEARCH_NAME);
         return &loadInfo;
@@ -2610,6 +2705,9 @@ struct ItemSetLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
+            { false, FT_INT, "SetFlags" },
+            { false, FT_INT, "RequiredSkill" },
+            { false, FT_SHORT, "RequiredSkillRank" },
             { false, FT_INT, "ItemID1" },
             { false, FT_INT, "ItemID2" },
             { false, FT_INT, "ItemID3" },
@@ -2627,9 +2725,6 @@ struct ItemSetLoadInfo
             { false, FT_INT, "ItemID15" },
             { false, FT_INT, "ItemID16" },
             { false, FT_INT, "ItemID17" },
-            { false, FT_SHORT, "RequiredSkillRank" },
-            { false, FT_INT, "RequiredSkill" },
-            { false, FT_INT, "SetFlags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSetMeta::Instance(), HOTFIX_SEL_ITEM_SET);
         return &loadInfo;
@@ -2643,8 +2738,8 @@ struct ItemSetSpellLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "SpellID" },
             { false, FT_SHORT, "ChrSpecID" },
+            { false, FT_INT, "SpellID" },
             { false, FT_BYTE, "Threshold" },
             { false, FT_SHORT, "ItemSetID" },
         };
@@ -2661,33 +2756,16 @@ struct ItemSparseLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_LONG, "AllowableRace" },
-            { false, FT_STRING, "Display" },
-            { false, FT_STRING, "Display1" },
-            { false, FT_STRING, "Display2" },
-            { false, FT_STRING, "Display3" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "Flags1" },
-            { true, FT_INT, "Flags2" },
-            { true, FT_INT, "Flags3" },
-            { true, FT_INT, "Flags4" },
-            { false, FT_FLOAT, "PriceRandomValue" },
-            { false, FT_FLOAT, "PriceVariance" },
-            { false, FT_INT, "VendorStackCount" },
-            { false, FT_INT, "BuyPrice" },
-            { false, FT_INT, "SellPrice" },
-            { false, FT_INT, "RequiredAbility" },
-            { true, FT_INT, "MaxCount" },
-            { true, FT_INT, "Stackable" },
-            { true, FT_INT, "StatPercentEditor1" },
-            { true, FT_INT, "StatPercentEditor2" },
-            { true, FT_INT, "StatPercentEditor3" },
-            { true, FT_INT, "StatPercentEditor4" },
-            { true, FT_INT, "StatPercentEditor5" },
-            { true, FT_INT, "StatPercentEditor6" },
-            { true, FT_INT, "StatPercentEditor7" },
-            { true, FT_INT, "StatPercentEditor8" },
-            { true, FT_INT, "StatPercentEditor9" },
-            { true, FT_INT, "StatPercentEditor10" },
+            { false, FT_STRING, "Display3" },
+            { false, FT_STRING, "Display2" },
+            { false, FT_STRING, "Display1" },
+            { false, FT_STRING, "Display" },
+            { false, FT_FLOAT, "DmgVariance" },
+            { false, FT_INT, "DurationInInventory" },
+            { false, FT_FLOAT, "QualityModifier" },
+            { false, FT_INT, "BagFamily" },
+            { false, FT_FLOAT, "ItemRange" },
             { false, FT_FLOAT, "StatPercentageOfSocket1" },
             { false, FT_FLOAT, "StatPercentageOfSocket2" },
             { false, FT_FLOAT, "StatPercentageOfSocket3" },
@@ -2698,50 +2776,64 @@ struct ItemSparseLoadInfo
             { false, FT_FLOAT, "StatPercentageOfSocket8" },
             { false, FT_FLOAT, "StatPercentageOfSocket9" },
             { false, FT_FLOAT, "StatPercentageOfSocket10" },
-            { false, FT_FLOAT, "ItemRange" },
-            { false, FT_INT, "BagFamily" },
-            { false, FT_FLOAT, "QualityModifier" },
-            { false, FT_INT, "DurationInInventory" },
-            { false, FT_FLOAT, "DmgVariance" },
-            { true, FT_SHORT, "AllowableClass" },
-            { false, FT_SHORT, "ItemLevel" },
-            { false, FT_SHORT, "RequiredSkill" },
-            { false, FT_SHORT, "RequiredSkillRank" },
-            { false, FT_SHORT, "MinFactionID" },
-            { true, FT_SHORT, "ItemStatValue1" },
-            { true, FT_SHORT, "ItemStatValue2" },
-            { true, FT_SHORT, "ItemStatValue3" },
-            { true, FT_SHORT, "ItemStatValue4" },
-            { true, FT_SHORT, "ItemStatValue5" },
-            { true, FT_SHORT, "ItemStatValue6" },
-            { true, FT_SHORT, "ItemStatValue7" },
-            { true, FT_SHORT, "ItemStatValue8" },
-            { true, FT_SHORT, "ItemStatValue9" },
-            { true, FT_SHORT, "ItemStatValue10" },
-            { false, FT_SHORT, "ScalingStatDistributionID" },
-            { false, FT_SHORT, "ItemDelay" },
-            { false, FT_SHORT, "PageID" },
-            { false, FT_SHORT, "StartQuestID" },
-            { false, FT_SHORT, "LockID" },
-            { false, FT_SHORT, "RandomSelect" },
-            { false, FT_SHORT, "ItemRandomSuffixGroupID" },
-            { false, FT_SHORT, "ItemSet" },
-            { false, FT_SHORT, "ZoneBound" },
-            { false, FT_SHORT, "InstanceBound" },
-            { false, FT_SHORT, "TotemCategoryID" },
-            { false, FT_SHORT, "SocketMatchEnchantmentId" },
-            { false, FT_SHORT, "GemProperties" },
-            { false, FT_SHORT, "LimitCategory" },
-            { false, FT_SHORT, "RequiredHoliday" },
-            { false, FT_SHORT, "RequiredTransmogHoliday" },
+            { true, FT_INT, "StatPercentEditor1" },
+            { true, FT_INT, "StatPercentEditor2" },
+            { true, FT_INT, "StatPercentEditor3" },
+            { true, FT_INT, "StatPercentEditor4" },
+            { true, FT_INT, "StatPercentEditor5" },
+            { true, FT_INT, "StatPercentEditor6" },
+            { true, FT_INT, "StatPercentEditor7" },
+            { true, FT_INT, "StatPercentEditor8" },
+            { true, FT_INT, "StatPercentEditor9" },
+            { true, FT_INT, "StatPercentEditor10" },
+            { true, FT_INT, "Stackable" },
+            { true, FT_INT, "MaxCount" },
+            { false, FT_INT, "RequiredAbility" },
+            { false, FT_INT, "SellPrice" },
+            { false, FT_INT, "BuyPrice" },
+            { false, FT_INT, "VendorStackCount" },
+            { false, FT_FLOAT, "PriceVariance" },
+            { false, FT_FLOAT, "PriceRandomValue" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
+            { true, FT_INT, "Flags3" },
+            { true, FT_INT, "Flags4" },
+            { true, FT_INT, "FactionRelated" },
             { false, FT_SHORT, "ItemNameDescriptionID" },
-            { false, FT_BYTE, "OverallQualityID" },
-            { false, FT_BYTE, "InventoryType" },
-            { true, FT_BYTE, "RequiredLevel" },
-            { false, FT_BYTE, "RequiredPVPRank" },
-            { false, FT_BYTE, "RequiredPVPMedal" },
-            { false, FT_BYTE, "MinReputation" },
-            { false, FT_BYTE, "ContainerSlots" },
+            { false, FT_SHORT, "RequiredTransmogHoliday" },
+            { false, FT_SHORT, "RequiredHoliday" },
+            { false, FT_SHORT, "LimitCategory" },
+            { false, FT_SHORT, "GemProperties" },
+            { false, FT_SHORT, "SocketMatchEnchantmentId" },
+            { false, FT_SHORT, "TotemCategoryID" },
+            { false, FT_SHORT, "InstanceBound" },
+            { false, FT_SHORT, "ZoneBound" },
+            { false, FT_SHORT, "ItemSet" },
+            { false, FT_SHORT, "ItemRandomSuffixGroupID" },
+            { false, FT_SHORT, "RandomSelect" },
+            { false, FT_SHORT, "LockID" },
+            { false, FT_SHORT, "StartQuestID" },
+            { false, FT_SHORT, "PageID" },
+            { false, FT_SHORT, "ItemDelay" },
+            { false, FT_SHORT, "ScalingStatDistributionID" },
+            { false, FT_SHORT, "MinFactionID" },
+            { false, FT_SHORT, "RequiredSkillRank" },
+            { false, FT_SHORT, "RequiredSkill" },
+            { false, FT_SHORT, "ItemLevel" },
+            { true, FT_SHORT, "AllowableClass" },
+            { false, FT_BYTE, "ExpansionID" },
+            { false, FT_BYTE, "ArtifactID" },
+            { false, FT_BYTE, "SpellWeight" },
+            { false, FT_BYTE, "SpellWeightCategory" },
+            { false, FT_BYTE, "SocketType1" },
+            { false, FT_BYTE, "SocketType2" },
+            { false, FT_BYTE, "SocketType3" },
+            { false, FT_BYTE, "SheatheType" },
+            { false, FT_BYTE, "Material" },
+            { false, FT_BYTE, "PageMaterialID" },
+            { false, FT_BYTE, "LanguageID" },
+            { false, FT_BYTE, "Bonding" },
+            { false, FT_BYTE, "DamageDamageType" },
             { true, FT_BYTE, "StatModifierBonusStat1" },
             { true, FT_BYTE, "StatModifierBonusStat2" },
             { true, FT_BYTE, "StatModifierBonusStat3" },
@@ -2752,19 +2844,13 @@ struct ItemSparseLoadInfo
             { true, FT_BYTE, "StatModifierBonusStat8" },
             { true, FT_BYTE, "StatModifierBonusStat9" },
             { true, FT_BYTE, "StatModifierBonusStat10" },
-            { false, FT_BYTE, "DamageDamageType" },
-            { false, FT_BYTE, "Bonding" },
-            { false, FT_BYTE, "LanguageID" },
-            { false, FT_BYTE, "PageMaterialID" },
-            { false, FT_BYTE, "Material" },
-            { false, FT_BYTE, "SheatheType" },
-            { false, FT_BYTE, "SocketType1" },
-            { false, FT_BYTE, "SocketType2" },
-            { false, FT_BYTE, "SocketType3" },
-            { false, FT_BYTE, "SpellWeightCategory" },
-            { false, FT_BYTE, "SpellWeight" },
-            { false, FT_BYTE, "ArtifactID" },
-            { false, FT_BYTE, "ExpansionID" },
+            { false, FT_BYTE, "ContainerSlots" },
+            { false, FT_BYTE, "MinReputation" },
+            { false, FT_BYTE, "RequiredPVPMedal" },
+            { false, FT_BYTE, "RequiredPVPRank" },
+            { true, FT_BYTE, "RequiredLevel" },
+            { false, FT_BYTE, "InventoryType" },
+            { false, FT_BYTE, "OverallQualityID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSparseMeta::Instance(), HOTFIX_SEL_ITEM_SPARSE);
         return &loadInfo;
@@ -2778,12 +2864,12 @@ struct ItemSpecLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_SHORT, "SpecializationID" },
             { false, FT_BYTE, "MinLevel" },
             { false, FT_BYTE, "MaxLevel" },
             { false, FT_BYTE, "ItemType" },
             { false, FT_BYTE, "PrimaryStat" },
             { false, FT_BYTE, "SecondaryStat" },
+            { false, FT_SHORT, "SpecializationID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSpecMeta::Instance(), HOTFIX_SEL_ITEM_SPEC);
         return &loadInfo;
@@ -2812,11 +2898,11 @@ struct ItemUpgradeLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "CurrencyAmount" },
-            { false, FT_SHORT, "PrerequisiteID" },
-            { false, FT_SHORT, "CurrencyType" },
             { false, FT_BYTE, "ItemUpgradePathID" },
             { false, FT_BYTE, "ItemLevelIncrement" },
+            { false, FT_SHORT, "PrerequisiteID" },
+            { false, FT_SHORT, "CurrencyType" },
+            { false, FT_INT, "CurrencyAmount" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemUpgradeMeta::Instance(), HOTFIX_SEL_ITEM_UPGRADE);
         return &loadInfo;
@@ -2892,37 +2978,38 @@ struct LfgDungeonsLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_STRING, "Description" },
-            { true, FT_INT, "Flags" },
-            { false, FT_FLOAT, "MinGear" },
-            { false, FT_SHORT, "MaxLevel" },
-            { false, FT_SHORT, "TargetLevelMax" },
-            { true, FT_SHORT, "MapID" },
-            { false, FT_SHORT, "RandomID" },
-            { false, FT_SHORT, "ScenarioID" },
-            { false, FT_SHORT, "FinalEncounterID" },
-            { false, FT_SHORT, "BonusReputationAmount" },
-            { false, FT_SHORT, "MentorItemLevel" },
-            { false, FT_SHORT, "RequiredPlayerConditionId" },
             { false, FT_BYTE, "MinLevel" },
-            { false, FT_BYTE, "TargetLevel" },
-            { false, FT_BYTE, "TargetLevelMin" },
-            { false, FT_BYTE, "DifficultyID" },
+            { false, FT_SHORT, "MaxLevel" },
             { false, FT_BYTE, "TypeID" },
+            { false, FT_BYTE, "Subtype" },
             { true, FT_BYTE, "Faction" },
+            { true, FT_INT, "IconTextureFileID" },
+            { true, FT_INT, "RewardsBgTextureFileID" },
+            { true, FT_INT, "PopupBgTextureFileID" },
             { false, FT_BYTE, "ExpansionLevel" },
-            { false, FT_BYTE, "OrderIndex" },
+            { true, FT_SHORT, "MapID" },
+            { false, FT_BYTE, "DifficultyID" },
+            { false, FT_FLOAT, "MinGear" },
             { false, FT_BYTE, "GroupID" },
+            { false, FT_BYTE, "OrderIndex" },
+            { false, FT_INT, "RequiredPlayerConditionId" },
+            { false, FT_BYTE, "TargetLevel" },
+            { false, FT_BYTE, "TargetLevelMin" },
+            { false, FT_SHORT, "TargetLevelMax" },
+            { false, FT_SHORT, "RandomID" },
+            { false, FT_SHORT, "ScenarioID" },
+            { false, FT_SHORT, "FinalEncounterID" },
             { false, FT_BYTE, "CountTank" },
             { false, FT_BYTE, "CountHealer" },
             { false, FT_BYTE, "CountDamage" },
             { false, FT_BYTE, "MinCountTank" },
             { false, FT_BYTE, "MinCountHealer" },
             { false, FT_BYTE, "MinCountDamage" },
-            { false, FT_BYTE, "Subtype" },
+            { false, FT_SHORT, "BonusReputationAmount" },
+            { false, FT_SHORT, "MentorItemLevel" },
             { false, FT_BYTE, "MentorCharLevel" },
-            { true, FT_INT, "IconTextureFileID" },
-            { true, FT_INT, "RewardsBgTextureFileID" },
-            { true, FT_INT, "PopupBgTextureFileID" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LFGDungeonsMeta::Instance(), HOTFIX_SEL_LFG_DUNGEONS);
         return &loadInfo;
@@ -2970,12 +3057,26 @@ struct LiquidTypeLoadInfo
             { false, FT_STRING_NOT_LOCALIZED, "Texture4" },
             { false, FT_STRING_NOT_LOCALIZED, "Texture5" },
             { false, FT_STRING_NOT_LOCALIZED, "Texture6" },
+            { false, FT_SHORT, "Flags" },
+            { false, FT_BYTE, "SoundBank" },
+            { false, FT_INT, "SoundID" },
             { false, FT_INT, "SpellID" },
             { false, FT_FLOAT, "MaxDarkenDepth" },
             { false, FT_FLOAT, "FogDarkenIntensity" },
             { false, FT_FLOAT, "AmbDarkenIntensity" },
             { false, FT_FLOAT, "DirDarkenIntensity" },
+            { false, FT_SHORT, "LightID" },
             { false, FT_FLOAT, "ParticleScale" },
+            { false, FT_BYTE, "ParticleMovement" },
+            { false, FT_BYTE, "ParticleTexSlots" },
+            { false, FT_BYTE, "MaterialID" },
+            { true, FT_INT, "MinimapStaticCol" },
+            { false, FT_BYTE, "FrameCountTexture1" },
+            { false, FT_BYTE, "FrameCountTexture2" },
+            { false, FT_BYTE, "FrameCountTexture3" },
+            { false, FT_BYTE, "FrameCountTexture4" },
+            { false, FT_BYTE, "FrameCountTexture5" },
+            { false, FT_BYTE, "FrameCountTexture6" },
             { true, FT_INT, "Color1" },
             { true, FT_INT, "Color2" },
             { false, FT_FLOAT, "Float1" },
@@ -3000,19 +3101,10 @@ struct LiquidTypeLoadInfo
             { false, FT_INT, "Int2" },
             { false, FT_INT, "Int3" },
             { false, FT_INT, "Int4" },
-            { false, FT_SHORT, "Flags" },
-            { false, FT_SHORT, "LightID" },
-            { false, FT_BYTE, "SoundBank" },
-            { false, FT_BYTE, "ParticleMovement" },
-            { false, FT_BYTE, "ParticleTexSlots" },
-            { false, FT_BYTE, "MaterialID" },
-            { false, FT_BYTE, "FrameCountTexture1" },
-            { false, FT_BYTE, "FrameCountTexture2" },
-            { false, FT_BYTE, "FrameCountTexture3" },
-            { false, FT_BYTE, "FrameCountTexture4" },
-            { false, FT_BYTE, "FrameCountTexture5" },
-            { false, FT_BYTE, "FrameCountTexture6" },
-            { false, FT_INT, "SoundID" },
+            { false, FT_FLOAT, "Coefficient1" },
+            { false, FT_FLOAT, "Coefficient2" },
+            { false, FT_FLOAT, "Coefficient3" },
+            { false, FT_FLOAT, "Coefficient4" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LiquidTypeMeta::Instance(), HOTFIX_SEL_LIQUID_TYPE);
         return &loadInfo;
@@ -3091,23 +3183,24 @@ struct MapLoadInfo
             { false, FT_STRING, "MapDescription1" },
             { false, FT_STRING, "PvpShortDescription" },
             { false, FT_STRING, "PvpLongDescription" },
-            { true, FT_INT, "Flags1" },
-            { true, FT_INT, "Flags2" },
-            { false, FT_FLOAT, "MinimapIconScale" },
             { false, FT_FLOAT, "CorpseX" },
             { false, FT_FLOAT, "CorpseY" },
+            { false, FT_BYTE, "MapType" },
+            { true, FT_BYTE, "InstanceType" },
+            { false, FT_BYTE, "ExpansionID" },
             { false, FT_SHORT, "AreaTableID" },
             { true, FT_SHORT, "LoadingScreenID" },
-            { true, FT_SHORT, "CorpseMapID" },
             { true, FT_SHORT, "TimeOfDayOverride" },
             { true, FT_SHORT, "ParentMapID" },
             { true, FT_SHORT, "CosmeticParentMapID" },
-            { true, FT_SHORT, "WindSettingsID" },
-            { false, FT_BYTE, "InstanceType" },
-            { false, FT_BYTE, "MapType" },
-            { false, FT_BYTE, "ExpansionID" },
-            { false, FT_BYTE, "MaxPlayers" },
             { false, FT_BYTE, "TimeOffset" },
+            { false, FT_FLOAT, "MinimapIconScale" },
+            { true, FT_SHORT, "CorpseMapID" },
+            { false, FT_BYTE, "MaxPlayers" },
+            { true, FT_SHORT, "WindSettingsID" },
+            { true, FT_INT, "ZmpFileDataID" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapMeta::Instance(), HOTFIX_SEL_MAP);
         return &loadInfo;
@@ -3122,13 +3215,14 @@ struct MapDifficultyLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Message" },
+            { false, FT_INT, "ItemContextPickerID" },
+            { true, FT_INT, "ContentTuningID" },
             { false, FT_BYTE, "DifficultyID" },
+            { false, FT_BYTE, "LockID" },
             { false, FT_BYTE, "ResetInterval" },
             { false, FT_BYTE, "MaxPlayers" },
-            { false, FT_BYTE, "LockID" },
-            { false, FT_BYTE, "Flags" },
             { false, FT_BYTE, "ItemContext" },
-            { false, FT_INT, "ItemContextPickerID" },
+            { false, FT_BYTE, "Flags" },
             { false, FT_SHORT, "MapID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapDifficultyMeta::Instance(), HOTFIX_SEL_MAP_DIFFICULTY);
@@ -3143,13 +3237,13 @@ struct ModifierTreeLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Asset" },
-            { true, FT_INT, "SecondaryAsset" },
             { false, FT_INT, "Parent" },
-            { false, FT_BYTE, "Type" },
-            { true, FT_BYTE, "TertiaryAsset" },
             { true, FT_BYTE, "Operator" },
             { true, FT_BYTE, "Amount" },
+            { false, FT_BYTE, "Type" },
+            { true, FT_INT, "Asset" },
+            { true, FT_INT, "SecondaryAsset" },
+            { true, FT_BYTE, "TertiaryAsset" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ModifierTreeMeta::Instance(), HOTFIX_SEL_MODIFIER_TREE);
         return &loadInfo;
@@ -3163,15 +3257,15 @@ struct MountLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Name" },
-            { false, FT_STRING, "Description" },
             { false, FT_STRING, "SourceText" },
-            { true, FT_INT, "SourceSpellID" },
-            { false, FT_FLOAT, "MountFlyRideHeight" },
+            { false, FT_STRING, "Description" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "MountTypeID" },
             { false, FT_SHORT, "Flags" },
             { true, FT_BYTE, "SourceTypeEnum" },
-            { false, FT_INT, "ID" },
+            { true, FT_INT, "SourceSpellID" },
             { false, FT_INT, "PlayerConditionID" },
+            { false, FT_FLOAT, "MountFlyRideHeight" },
             { true, FT_INT, "UiModelSceneID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MountMeta::Instance(), HOTFIX_SEL_MOUNT);
@@ -3185,14 +3279,14 @@ struct MountCapabilityLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { true, FT_INT, "ReqSpellKnownID" },
-            { true, FT_INT, "ModSpellAuraID" },
+            { false, FT_INT, "ID" },
+            { false, FT_BYTE, "Flags" },
             { false, FT_SHORT, "ReqRidingSkill" },
             { false, FT_SHORT, "ReqAreaID" },
-            { true, FT_SHORT, "ReqMapID" },
-            { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
             { false, FT_INT, "ReqSpellAuraID" },
+            { true, FT_INT, "ReqSpellKnownID" },
+            { true, FT_INT, "ModSpellAuraID" },
+            { true, FT_SHORT, "ReqMapID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MountCapabilityMeta::Instance(), HOTFIX_SEL_MOUNT_CAPABILITY);
         return &loadInfo;
@@ -3238,10 +3332,10 @@ struct MovieLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "AudioFileDataID" },
-            { false, FT_INT, "SubtitleFileDataID" },
             { false, FT_BYTE, "Volume" },
             { false, FT_BYTE, "KeyID" },
+            { false, FT_INT, "AudioFileDataID" },
+            { false, FT_INT, "SubtitleFileDataID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MovieMeta::Instance(), HOTFIX_SEL_MOVIE);
         return &loadInfo;
@@ -3308,6 +3402,22 @@ struct NamesReservedLocaleLoadInfo
     }
 };
 
+struct NumTalentsAtLevelLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "NumTalents" },
+            { true, FT_INT, "NumTalentsDeathKnight" },
+            { true, FT_INT, "NumTalentsDemonHunter" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, NumTalentsAtLevelMeta::Instance(), HOTFIX_SEL_NUM_TALENTS_AT_LEVEL);
+        return &loadInfo;
+    }
+};
+
 struct OverrideSpellDataLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -3371,12 +3481,9 @@ struct PlayerConditionLoadInfo
             { true, FT_LONG, "RaceMask" },
             { false, FT_STRING, "FailureDescription" },
             { false, FT_INT, "ID" },
-            { false, FT_BYTE, "Flags" },
             { false, FT_SHORT, "MinLevel" },
             { false, FT_SHORT, "MaxLevel" },
             { true, FT_INT, "ClassMask" },
-            { true, FT_BYTE, "Gender" },
-            { true, FT_BYTE, "NativeGender" },
             { false, FT_INT, "SkillLogic" },
             { false, FT_BYTE, "LanguageID" },
             { false, FT_BYTE, "MinLanguage" },
@@ -3385,8 +3492,6 @@ struct PlayerConditionLoadInfo
             { false, FT_BYTE, "MaxReputation" },
             { false, FT_INT, "ReputationLogic" },
             { true, FT_BYTE, "CurrentPvpFaction" },
-            { false, FT_BYTE, "MinPVPRank" },
-            { false, FT_BYTE, "MaxPVPRank" },
             { false, FT_BYTE, "PvpMedal" },
             { false, FT_INT, "PrevQuestLogic" },
             { false, FT_INT, "CurrQuestLogic" },
@@ -3400,31 +3505,36 @@ struct PlayerConditionLoadInfo
             { false, FT_BYTE, "PartyStatus" },
             { false, FT_BYTE, "LifetimeMaxPVPRank" },
             { false, FT_INT, "AchievementLogic" },
-            { false, FT_INT, "LfgLogic" },
+            { true, FT_BYTE, "Gender" },
+            { true, FT_BYTE, "NativeGender" },
             { false, FT_INT, "AreaLogic" },
+            { false, FT_INT, "LfgLogic" },
             { false, FT_INT, "CurrencyLogic" },
             { false, FT_SHORT, "QuestKillID" },
             { false, FT_INT, "QuestKillLogic" },
             { true, FT_BYTE, "MinExpansionLevel" },
             { true, FT_BYTE, "MaxExpansionLevel" },
-            { true, FT_BYTE, "MinExpansionTier" },
-            { true, FT_BYTE, "MaxExpansionTier" },
-            { false, FT_BYTE, "MinGuildLevel" },
-            { false, FT_BYTE, "MaxGuildLevel" },
-            { false, FT_BYTE, "PhaseUseFlags" },
-            { false, FT_SHORT, "PhaseID" },
-            { false, FT_INT, "PhaseGroupID" },
             { true, FT_INT, "MinAvgItemLevel" },
             { true, FT_INT, "MaxAvgItemLevel" },
             { false, FT_SHORT, "MinAvgEquippedItemLevel" },
             { false, FT_SHORT, "MaxAvgEquippedItemLevel" },
+            { false, FT_BYTE, "PhaseUseFlags" },
+            { false, FT_SHORT, "PhaseID" },
+            { false, FT_INT, "PhaseGroupID" },
+            { false, FT_BYTE, "Flags" },
             { true, FT_BYTE, "ChrSpecializationIndex" },
             { true, FT_BYTE, "ChrSpecializationRole" },
+            { false, FT_INT, "ModifierTreeID" },
             { true, FT_BYTE, "PowerType" },
             { false, FT_BYTE, "PowerTypeComp" },
             { false, FT_BYTE, "PowerTypeValue" },
-            { false, FT_INT, "ModifierTreeID" },
             { true, FT_INT, "WeaponSubclassMask" },
+            { false, FT_BYTE, "MaxGuildLevel" },
+            { false, FT_BYTE, "MinGuildLevel" },
+            { true, FT_BYTE, "MaxExpansionTier" },
+            { true, FT_BYTE, "MinExpansionTier" },
+            { false, FT_BYTE, "MinPVPRank" },
+            { false, FT_BYTE, "MaxPVPRank" },
             { false, FT_SHORT, "SkillID1" },
             { false, FT_SHORT, "SkillID2" },
             { false, FT_SHORT, "SkillID3" },
@@ -3483,6 +3593,10 @@ struct PlayerConditionLoadInfo
             { false, FT_SHORT, "Achievement2" },
             { false, FT_SHORT, "Achievement3" },
             { false, FT_SHORT, "Achievement4" },
+            { false, FT_SHORT, "AreaID1" },
+            { false, FT_SHORT, "AreaID2" },
+            { false, FT_SHORT, "AreaID3" },
+            { false, FT_SHORT, "AreaID4" },
             { false, FT_BYTE, "LfgStatus1" },
             { false, FT_BYTE, "LfgStatus2" },
             { false, FT_BYTE, "LfgStatus3" },
@@ -3495,10 +3609,6 @@ struct PlayerConditionLoadInfo
             { false, FT_INT, "LfgValue2" },
             { false, FT_INT, "LfgValue3" },
             { false, FT_INT, "LfgValue4" },
-            { false, FT_SHORT, "AreaID1" },
-            { false, FT_SHORT, "AreaID2" },
-            { false, FT_SHORT, "AreaID3" },
-            { false, FT_SHORT, "AreaID4" },
             { false, FT_INT, "CurrencyID1" },
             { false, FT_INT, "CurrencyID2" },
             { false, FT_INT, "CurrencyID3" },
@@ -3548,16 +3658,16 @@ struct PowerTypeLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING_NOT_LOCALIZED, "NameGlobalStringTag" },
             { false, FT_STRING_NOT_LOCALIZED, "CostGlobalStringTag" },
-            { false, FT_FLOAT, "RegenPeace" },
-            { false, FT_FLOAT, "RegenCombat" },
-            { true, FT_SHORT, "MaxBasePower" },
-            { true, FT_SHORT, "RegenInterruptTimeMS" },
-            { true, FT_SHORT, "Flags" },
             { true, FT_BYTE, "PowerTypeEnum" },
             { true, FT_BYTE, "MinPower" },
+            { true, FT_SHORT, "MaxBasePower" },
             { true, FT_BYTE, "CenterPower" },
             { true, FT_BYTE, "DefaultPower" },
             { true, FT_BYTE, "DisplayModifier" },
+            { true, FT_SHORT, "RegenInterruptTimeMS" },
+            { false, FT_FLOAT, "RegenPeace" },
+            { false, FT_FLOAT, "RegenCombat" },
+            { true, FT_SHORT, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PowerTypeMeta::Instance(), HOTFIX_SEL_POWER_TYPE);
         return &loadInfo;
@@ -3572,9 +3682,10 @@ struct PrestigeLevelInfoLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
+            { true, FT_INT, "PrestigeLevel" },
             { true, FT_INT, "BadgeTextureFileDataID" },
-            { false, FT_BYTE, "PrestigeLevel" },
             { false, FT_BYTE, "Flags" },
+            { true, FT_INT, "AwardedAchievementID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PrestigeLevelInfoMeta::Instance(), HOTFIX_SEL_PRESTIGE_LEVEL_INFO);
         return &loadInfo;
@@ -3613,57 +3724,54 @@ struct PvpItemLoadInfo
     }
 };
 
-struct PvpRewardLoadInfo
+struct PvpTalentLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
+            { false, FT_STRING, "Description" },
             { false, FT_INT, "ID" },
-            { true, FT_INT, "HonorLevel" },
-            { true, FT_INT, "PrestigeLevel" },
-            { true, FT_INT, "RewardPackID" },
+            { true, FT_INT, "SpecID" },
+            { true, FT_INT, "SpellID" },
+            { true, FT_INT, "OverridesSpellID" },
+            { true, FT_INT, "Flags" },
+            { true, FT_INT, "ActionBarSpellID" },
+            { true, FT_INT, "PvpTalentCategoryID" },
+            { true, FT_INT, "LevelRequired" },
         };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpRewardMeta::Instance(), HOTFIX_SEL_PVP_REWARD);
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentMeta::Instance(), HOTFIX_SEL_PVP_TALENT);
         return &loadInfo;
     }
 };
 
-struct PvpTalentLoadInfo
+struct PvpTalentCategoryLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_STRING, "Description" },
-            { true, FT_INT, "SpellID" },
-            { true, FT_INT, "OverridesSpellID" },
-            { true, FT_INT, "ActionBarSpellID" },
-            { true, FT_INT, "TierID" },
-            { true, FT_INT, "ColumnIndex" },
-            { true, FT_INT, "Flags" },
-            { true, FT_INT, "ClassID" },
-            { true, FT_INT, "SpecID" },
-            { true, FT_INT, "Role" },
+            { false, FT_BYTE, "TalentSlotMask" },
         };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentMeta::Instance(), HOTFIX_SEL_PVP_TALENT);
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentCategoryMeta::Instance(), HOTFIX_SEL_PVP_TALENT_CATEGORY);
         return &loadInfo;
     }
 };
 
-struct PvpTalentUnlockLoadInfo
+struct PvpTalentSlotUnlockLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "TierID" },
-            { true, FT_INT, "ColumnIndex" },
-            { true, FT_INT, "HonorLevel" },
+            { true, FT_BYTE, "Slot" },
+            { true, FT_INT, "LevelRequired" },
+            { true, FT_INT, "DeathKnightLevelRequired" },
+            { true, FT_INT, "DemonHunterLevelRequired" },
         };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentUnlockMeta::Instance(), HOTFIX_SEL_PVP_TALENT_UNLOCK);
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentSlotUnlockMeta::Instance(), HOTFIX_SEL_PVP_TALENT_SLOT_UNLOCK);
         return &loadInfo;
     }
 };
@@ -3721,10 +3829,10 @@ struct QuestPackageItemLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "ItemID" },
             { false, FT_SHORT, "PackageID" },
-            { false, FT_BYTE, "DisplayType" },
+            { true, FT_INT, "ItemID" },
             { false, FT_INT, "ItemQuantity" },
+            { false, FT_BYTE, "DisplayType" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestPackageItemMeta::Instance(), HOTFIX_SEL_QUEST_PACKAGE_ITEM);
         return &loadInfo;
@@ -3790,6 +3898,7 @@ struct RandPropPointsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { true, FT_INT, "DamageReplaceStat" },
             { false, FT_INT, "Epic1" },
             { false, FT_INT, "Epic2" },
             { false, FT_INT, "Epic3" },
@@ -3818,11 +3927,11 @@ struct RewardPackLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { true, FT_INT, "CharTitleID" },
             { false, FT_INT, "Money" },
-            { false, FT_FLOAT, "ArtifactXPMultiplier" },
             { true, FT_BYTE, "ArtifactXPDifficulty" },
+            { false, FT_FLOAT, "ArtifactXPMultiplier" },
             { false, FT_BYTE, "ArtifactXPCategoryID" },
-            { true, FT_INT, "CharTitleID" },
             { false, FT_INT, "TreasurePickerID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RewardPackMeta::Instance(), HOTFIX_SEL_REWARD_PACK);
@@ -3877,22 +3986,6 @@ struct RulesetItemUpgradeLoadInfo
     }
 };
 
-struct SandboxScalingLoadInfo
-{
-    static DB2LoadInfo const* Instance()
-    {
-        static DB2FieldMeta const fields[] =
-        {
-            { false, FT_INT, "ID" },
-            { true, FT_INT, "MinLevel" },
-            { true, FT_INT, "MaxLevel" },
-            { true, FT_INT, "Flags" },
-        };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SandboxScalingMeta::Instance(), HOTFIX_SEL_SANDBOX_SCALING);
-        return &loadInfo;
-    }
-};
-
 struct ScalingStatDistributionLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -3918,8 +4011,9 @@ struct ScenarioLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_SHORT, "AreaTableID" },
-            { false, FT_BYTE, "Flags" },
             { false, FT_BYTE, "Type" },
+            { false, FT_BYTE, "Flags" },
+            { false, FT_INT, "UiTextureKitID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScenarioMeta::Instance(), HOTFIX_SEL_SCENARIO);
         return &loadInfo;
@@ -3936,12 +4030,14 @@ struct ScenarioStepLoadInfo
             { false, FT_STRING, "Description" },
             { false, FT_STRING, "Title" },
             { false, FT_SHORT, "ScenarioID" },
-            { false, FT_SHORT, "Supersedes" },
+            { false, FT_INT, "Criteriatreeid" },
             { false, FT_SHORT, "RewardQuestID" },
+            { true, FT_INT, "RelatedStep" },
+            { false, FT_SHORT, "Supersedes" },
             { false, FT_BYTE, "OrderIndex" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "Criteriatreeid" },
-            { true, FT_INT, "RelatedStep" },
+            { false, FT_INT, "VisibilityPlayerConditionID" },
+            { false, FT_SHORT, "WidgetSetID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScenarioStepMeta::Instance(), HOTFIX_SEL_SCENARIO_STEP);
         return &loadInfo;
@@ -4013,15 +4109,19 @@ struct SkillLineLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "ID" },
             { false, FT_STRING, "DisplayName" },
-            { false, FT_STRING, "Description" },
             { false, FT_STRING, "AlternateVerb" },
-            { false, FT_SHORT, "Flags" },
+            { false, FT_STRING, "Description" },
+            { false, FT_STRING, "HordeDisplayName" },
+            { false, FT_STRING_NOT_LOCALIZED, "OverrideSourceInfoDisplayName" },
+            { false, FT_INT, "ID" },
             { true, FT_BYTE, "CategoryID" },
-            { true, FT_BYTE, "CanLink" },
             { true, FT_INT, "SpellIconFileID" },
+            { true, FT_BYTE, "CanLink" },
             { false, FT_INT, "ParentSkillLineID" },
+            { true, FT_INT, "ParentTierIndex" },
+            { false, FT_SHORT, "Flags" },
+            { true, FT_INT, "SpellBookSpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SkillLineMeta::Instance(), HOTFIX_SEL_SKILL_LINE);
         return &loadInfo;
@@ -4036,18 +4136,19 @@ struct SkillLineAbilityLoadInfo
         {
             { true, FT_LONG, "RaceMask" },
             { false, FT_INT, "ID" },
+            { true, FT_SHORT, "SkillLine" },
             { true, FT_INT, "Spell" },
+            { true, FT_SHORT, "MinSkillLineRank" },
+            { true, FT_INT, "ClassMask" },
             { true, FT_INT, "SupercedesSpell" },
-            { true, FT_SHORT, "SkillLine" },
+            { true, FT_BYTE, "AcquireMethod" },
             { true, FT_SHORT, "TrivialSkillLineRankHigh" },
             { true, FT_SHORT, "TrivialSkillLineRankLow" },
+            { true, FT_BYTE, "Flags" },
+            { true, FT_BYTE, "NumSkillUps" },
             { true, FT_SHORT, "UniqueBit" },
             { true, FT_SHORT, "TradeSkillCategoryID" },
-            { true, FT_BYTE, "NumSkillUps" },
-            { true, FT_INT, "ClassMask" },
-            { true, FT_SHORT, "MinSkillLineRank" },
-            { true, FT_BYTE, "AcquireMethod" },
-            { true, FT_BYTE, "Flags" },
+            { true, FT_SHORT, "SkillupSkillLineID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SkillLineAbilityMeta::Instance(), HOTFIX_SEL_SKILL_LINE_ABILITY);
         return &loadInfo;
@@ -4063,11 +4164,11 @@ struct SkillRaceClassInfoLoadInfo
             { false, FT_INT, "ID" },
             { true, FT_LONG, "RaceMask" },
             { true, FT_SHORT, "SkillID" },
+            { true, FT_INT, "ClassMask" },
             { false, FT_SHORT, "Flags" },
-            { true, FT_SHORT, "SkillTierID" },
             { true, FT_BYTE, "Availability" },
             { true, FT_BYTE, "MinLevel" },
-            { true, FT_INT, "ClassMask" },
+            { true, FT_SHORT, "SkillTierID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SkillRaceClassInfoMeta::Instance(), HOTFIX_SEL_SKILL_RACE_CLASS_INFO);
         return &loadInfo;
@@ -4081,18 +4182,18 @@ struct SoundKitLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "SoundType" },
             { false, FT_FLOAT, "VolumeFloat" },
+            { false, FT_SHORT, "Flags" },
             { false, FT_FLOAT, "MinDistance" },
             { false, FT_FLOAT, "DistanceCutoff" },
-            { false, FT_SHORT, "Flags" },
-            { false, FT_SHORT, "SoundEntriesAdvancedID" },
-            { false, FT_BYTE, "SoundType" },
-            { false, FT_BYTE, "DialogType" },
             { false, FT_BYTE, "EAXDef" },
+            { false, FT_INT, "SoundKitAdvancedID" },
             { false, FT_FLOAT, "VolumeVariationPlus" },
             { false, FT_FLOAT, "VolumeVariationMinus" },
             { false, FT_FLOAT, "PitchVariationPlus" },
             { false, FT_FLOAT, "PitchVariationMinus" },
+            { true, FT_BYTE, "DialogType" },
             { false, FT_FLOAT, "PitchAdjust" },
             { false, FT_SHORT, "BusOverwriteID" },
             { false, FT_BYTE, "MaxInstances" },
@@ -4109,34 +4210,17 @@ struct SpecializationSpellsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Description" },
+            { false, FT_INT, "ID" },
+            { false, FT_SHORT, "SpecID" },
             { true, FT_INT, "SpellID" },
             { true, FT_INT, "OverridesSpellID" },
-            { false, FT_SHORT, "SpecID" },
             { false, FT_BYTE, "DisplayOrder" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpecializationSpellsMeta::Instance(), HOTFIX_SEL_SPECIALIZATION_SPELLS);
         return &loadInfo;
     }
 };
 
-struct SpellLoadInfo
-{
-    static DB2LoadInfo const* Instance()
-    {
-        static DB2FieldMeta const fields[] =
-        {
-            { false, FT_INT, "ID" },
-            { false, FT_STRING, "Name" },
-            { false, FT_STRING, "NameSubtext" },
-            { false, FT_STRING, "Description" },
-            { false, FT_STRING, "AuraDescription" },
-        };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellMeta::Instance(), HOTFIX_SEL_SPELL);
-        return &loadInfo;
-    }
-};
-
 struct SpellAuraOptionsLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -4144,13 +4228,14 @@ struct SpellAuraOptionsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "ProcCharges" },
-            { true, FT_INT, "ProcTypeMask" },
-            { true, FT_INT, "ProcCategoryRecovery" },
-            { false, FT_SHORT, "CumulativeAura" },
-            { false, FT_SHORT, "SpellProcsPerMinuteID" },
             { false, FT_BYTE, "DifficultyID" },
+            { false, FT_SHORT, "CumulativeAura" },
+            { true, FT_INT, "ProcCategoryRecovery" },
             { false, FT_BYTE, "ProcChance" },
+            { true, FT_INT, "ProcCharges" },
+            { false, FT_SHORT, "SpellProcsPerMinuteID" },
+            { true, FT_INT, "ProcTypeMask1" },
+            { true, FT_INT, "ProcTypeMask2" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellAuraOptionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_OPTIONS);
@@ -4165,15 +4250,15 @@ struct SpellAuraRestrictionsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "CasterAuraSpell" },
-            { true, FT_INT, "TargetAuraSpell" },
-            { true, FT_INT, "ExcludeCasterAuraSpell" },
-            { true, FT_INT, "ExcludeTargetAuraSpell" },
             { false, FT_BYTE, "DifficultyID" },
             { false, FT_BYTE, "CasterAuraState" },
             { false, FT_BYTE, "TargetAuraState" },
             { false, FT_BYTE, "ExcludeCasterAuraState" },
             { false, FT_BYTE, "ExcludeTargetAuraState" },
+            { true, FT_INT, "CasterAuraSpell" },
+            { true, FT_INT, "TargetAuraSpell" },
+            { true, FT_INT, "ExcludeCasterAuraSpell" },
+            { true, FT_INT, "ExcludeTargetAuraSpell" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellAuraRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_RESTRICTIONS);
@@ -4189,8 +4274,8 @@ struct SpellCastTimesLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "Base" },
-            { true, FT_INT, "Minimum" },
             { true, FT_SHORT, "PerLevel" },
+            { true, FT_INT, "Minimum" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCastTimesMeta::Instance(), HOTFIX_SEL_SPELL_CAST_TIMES);
         return &loadInfo;
@@ -4205,12 +4290,12 @@ struct SpellCastingRequirementsLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
-            { false, FT_SHORT, "MinFactionID" },
-            { false, FT_SHORT, "RequiredAreasID" },
-            { false, FT_SHORT, "RequiresSpellFocus" },
             { false, FT_BYTE, "FacingCasterFlags" },
+            { false, FT_SHORT, "MinFactionID" },
             { true, FT_BYTE, "MinReputation" },
+            { false, FT_SHORT, "RequiredAreasID" },
             { false, FT_BYTE, "RequiredAuraVision" },
+            { false, FT_SHORT, "RequiresSpellFocus" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCastingRequirementsMeta::Instance(), HOTFIX_SEL_SPELL_CASTING_REQUIREMENTS);
         return &loadInfo;
@@ -4224,14 +4309,14 @@ struct SpellCategoriesLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_SHORT, "Category" },
-            { true, FT_SHORT, "StartRecoveryCategory" },
-            { true, FT_SHORT, "ChargeCategory" },
             { false, FT_BYTE, "DifficultyID" },
+            { true, FT_SHORT, "Category" },
             { true, FT_BYTE, "DefenseType" },
             { true, FT_BYTE, "DispelType" },
             { true, FT_BYTE, "Mechanic" },
             { true, FT_BYTE, "PreventionType" },
+            { true, FT_SHORT, "StartRecoveryCategory" },
+            { true, FT_SHORT, "ChargeCategory" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCategoriesMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORIES);
@@ -4247,10 +4332,10 @@ struct SpellCategoryLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
-            { true, FT_INT, "ChargeRecoveryTime" },
             { true, FT_BYTE, "Flags" },
             { false, FT_BYTE, "UsesPerWeek" },
             { true, FT_BYTE, "MaxCharges" },
+            { true, FT_INT, "ChargeRecoveryTime" },
             { true, FT_INT, "TypeMask" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCategoryMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORY);
@@ -4266,12 +4351,12 @@ struct SpellClassOptionsLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
-            { false, FT_INT, "SpellClassMask1" },
-            { false, FT_INT, "SpellClassMask2" },
-            { false, FT_INT, "SpellClassMask3" },
-            { false, FT_INT, "SpellClassMask4" },
-            { false, FT_BYTE, "SpellClassSet" },
             { false, FT_INT, "ModalNextSpell" },
+            { false, FT_BYTE, "SpellClassSet" },
+            { true, FT_INT, "SpellClassMask1" },
+            { true, FT_INT, "SpellClassMask2" },
+            { true, FT_INT, "SpellClassMask3" },
+            { true, FT_INT, "SpellClassMask4" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellClassOptionsMeta::Instance(), HOTFIX_SEL_SPELL_CLASS_OPTIONS);
         return &loadInfo;
@@ -4285,10 +4370,10 @@ struct SpellCooldownsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DifficultyID" },
             { true, FT_INT, "CategoryRecoveryTime" },
             { true, FT_INT, "RecoveryTime" },
             { true, FT_INT, "StartRecoveryTime" },
-            { false, FT_BYTE, "DifficultyID" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCooldownsMeta::Instance(), HOTFIX_SEL_SPELL_COOLDOWNS);
@@ -4304,8 +4389,8 @@ struct SpellDurationLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "Duration" },
-            { true, FT_INT, "MaxDuration" },
             { false, FT_INT, "DurationPerLevel" },
+            { true, FT_INT, "MaxDuration" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellDurationMeta::Instance(), HOTFIX_SEL_SPELL_DURATION);
         return &loadInfo;
@@ -4319,40 +4404,39 @@ struct SpellEffectLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "Effect" },
-            { true, FT_INT, "EffectBasePoints" },
-            { true, FT_INT, "EffectIndex" },
-            { true, FT_INT, "EffectAura" },
             { true, FT_INT, "DifficultyID" },
+            { true, FT_INT, "EffectIndex" },
+            { false, FT_INT, "Effect" },
             { false, FT_FLOAT, "EffectAmplitude" },
+            { true, FT_INT, "EffectAttributes" },
+            { true, FT_SHORT, "EffectAura" },
             { true, FT_INT, "EffectAuraPeriod" },
             { false, FT_FLOAT, "EffectBonusCoefficient" },
             { false, FT_FLOAT, "EffectChainAmplitude" },
             { true, FT_INT, "EffectChainTargets" },
-            { true, FT_INT, "EffectDieSides" },
             { true, FT_INT, "EffectItemType" },
             { true, FT_INT, "EffectMechanic" },
             { false, FT_FLOAT, "EffectPointsPerResource" },
+            { false, FT_FLOAT, "EffectPosFacing" },
             { false, FT_FLOAT, "EffectRealPointsPerLevel" },
             { true, FT_INT, "EffectTriggerSpell" },
-            { false, FT_FLOAT, "EffectPosFacing" },
-            { true, FT_INT, "EffectAttributes" },
             { false, FT_FLOAT, "BonusCoefficientFromAP" },
             { false, FT_FLOAT, "PvpMultiplier" },
             { false, FT_FLOAT, "Coefficient" },
             { false, FT_FLOAT, "Variance" },
             { false, FT_FLOAT, "ResourceCoefficient" },
             { false, FT_FLOAT, "GroupSizeBasePointsCoefficient" },
-            { false, FT_INT, "EffectSpellClassMask1" },
-            { false, FT_INT, "EffectSpellClassMask2" },
-            { false, FT_INT, "EffectSpellClassMask3" },
-            { false, FT_INT, "EffectSpellClassMask4" },
+            { false, FT_FLOAT, "EffectBasePoints" },
             { true, FT_INT, "EffectMiscValue1" },
             { true, FT_INT, "EffectMiscValue2" },
             { false, FT_INT, "EffectRadiusIndex1" },
             { false, FT_INT, "EffectRadiusIndex2" },
-            { false, FT_INT, "ImplicitTarget1" },
-            { false, FT_INT, "ImplicitTarget2" },
+            { true, FT_INT, "EffectSpellClassMask1" },
+            { true, FT_INT, "EffectSpellClassMask2" },
+            { true, FT_INT, "EffectSpellClassMask3" },
+            { true, FT_INT, "EffectSpellClassMask4" },
+            { true, FT_SHORT, "ImplicitTarget1" },
+            { true, FT_SHORT, "ImplicitTarget2" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellEffectMeta::Instance(), HOTFIX_SEL_SPELL_EFFECT);
@@ -4368,9 +4452,9 @@ struct SpellEquippedItemsLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
+            { true, FT_BYTE, "EquippedItemClass" },
             { true, FT_INT, "EquippedItemInvTypes" },
             { true, FT_INT, "EquippedItemSubclass" },
-            { true, FT_BYTE, "EquippedItemClass" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellEquippedItemsMeta::Instance(), HOTFIX_SEL_SPELL_EQUIPPED_ITEMS);
         return &loadInfo;
@@ -4419,6 +4503,7 @@ struct SpellItemEnchantmentLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
+            { false, FT_STRING, "HordeName" },
             { false, FT_INT, "EffectArg1" },
             { false, FT_INT, "EffectArg2" },
             { false, FT_INT, "EffectArg3" },
@@ -4427,6 +4512,7 @@ struct SpellItemEnchantmentLoadInfo
             { false, FT_FLOAT, "EffectScalingPoints3" },
             { false, FT_INT, "TransmogCost" },
             { false, FT_INT, "IconFileDataID" },
+            { false, FT_INT, "TransmogPlayerConditionID" },
             { true, FT_SHORT, "EffectPointsMin1" },
             { true, FT_SHORT, "EffectPointsMin2" },
             { true, FT_SHORT, "EffectPointsMin3" },
@@ -4439,12 +4525,11 @@ struct SpellItemEnchantmentLoadInfo
             { false, FT_BYTE, "Effect1" },
             { false, FT_BYTE, "Effect2" },
             { false, FT_BYTE, "Effect3" },
+            { true, FT_BYTE, "ScalingClass" },
+            { true, FT_BYTE, "ScalingClassRestricted" },
             { false, FT_BYTE, "ConditionID" },
             { false, FT_BYTE, "MinLevel" },
             { false, FT_BYTE, "MaxLevel" },
-            { true, FT_BYTE, "ScalingClass" },
-            { true, FT_BYTE, "ScalingClassRestricted" },
-            { false, FT_INT, "TransmogPlayerConditionID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellItemEnchantmentMeta::Instance(), HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT);
         return &loadInfo;
@@ -4458,16 +4543,16 @@ struct SpellItemEnchantmentConditionLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "LtOperand1" },
-            { false, FT_INT, "LtOperand2" },
-            { false, FT_INT, "LtOperand3" },
-            { false, FT_INT, "LtOperand4" },
-            { false, FT_INT, "LtOperand5" },
             { false, FT_BYTE, "LtOperandType1" },
             { false, FT_BYTE, "LtOperandType2" },
             { false, FT_BYTE, "LtOperandType3" },
             { false, FT_BYTE, "LtOperandType4" },
             { false, FT_BYTE, "LtOperandType5" },
+            { false, FT_INT, "LtOperand1" },
+            { false, FT_INT, "LtOperand2" },
+            { false, FT_INT, "LtOperand3" },
+            { false, FT_INT, "LtOperand4" },
+            { false, FT_INT, "LtOperand5" },
             { false, FT_BYTE, "Operator1" },
             { false, FT_BYTE, "Operator2" },
             { false, FT_BYTE, "Operator3" },
@@ -4517,10 +4602,10 @@ struct SpellLevelsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DifficultyID" },
             { true, FT_SHORT, "BaseLevel" },
             { true, FT_SHORT, "MaxLevel" },
             { true, FT_SHORT, "SpellLevel" },
-            { false, FT_BYTE, "DifficultyID" },
             { false, FT_BYTE, "MaxPassiveAuraLevel" },
             { true, FT_INT, "SpellID" },
         };
@@ -4536,15 +4621,16 @@ struct SpellMiscLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DifficultyID" },
             { false, FT_SHORT, "CastingTimeIndex" },
             { false, FT_SHORT, "DurationIndex" },
             { false, FT_SHORT, "RangeIndex" },
             { false, FT_BYTE, "SchoolMask" },
-            { true, FT_INT, "SpellIconFileDataID" },
             { false, FT_FLOAT, "Speed" },
-            { true, FT_INT, "ActiveIconFileDataID" },
             { false, FT_FLOAT, "LaunchDelay" },
-            { false, FT_BYTE, "DifficultyID" },
+            { false, FT_FLOAT, "MinDuration" },
+            { true, FT_INT, "SpellIconFileDataID" },
+            { true, FT_INT, "ActiveIconFileDataID" },
             { true, FT_INT, "Attributes1" },
             { true, FT_INT, "Attributes2" },
             { true, FT_INT, "Attributes3" },
@@ -4566,25 +4652,39 @@ struct SpellMiscLoadInfo
     }
 };
 
+struct SpellNameLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { false, FT_STRING, "Name" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellNameMeta::Instance(), HOTFIX_SEL_SPELL_NAME);
+        return &loadInfo;
+    }
+};
+
 struct SpellPowerLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
-            { true, FT_INT, "ManaCost" },
-            { false, FT_FLOAT, "PowerCostPct" },
-            { false, FT_FLOAT, "PowerPctPerSecond" },
-            { true, FT_INT, "RequiredAuraSpellID" },
-            { false, FT_FLOAT, "PowerCostMaxPct" },
-            { false, FT_BYTE, "OrderIndex" },
-            { true, FT_BYTE, "PowerType" },
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "OrderIndex" },
+            { true, FT_INT, "ManaCost" },
             { true, FT_INT, "ManaCostPerLevel" },
             { true, FT_INT, "ManaPerSecond" },
-            { false, FT_INT, "OptionalCost" },
             { false, FT_INT, "PowerDisplayID" },
             { true, FT_INT, "AltPowerBarID" },
+            { false, FT_FLOAT, "PowerCostPct" },
+            { false, FT_FLOAT, "PowerCostMaxPct" },
+            { false, FT_FLOAT, "PowerPctPerSecond" },
+            { true, FT_BYTE, "PowerType" },
+            { true, FT_INT, "RequiredAuraSpellID" },
+            { false, FT_INT, "OptionalCost" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellPowerMeta::Instance(), HOTFIX_SEL_SPELL_POWER);
@@ -4598,9 +4698,9 @@ struct SpellPowerDifficultyLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
+            { false, FT_INT, "ID" },
             { false, FT_BYTE, "DifficultyID" },
             { false, FT_BYTE, "OrderIndex" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellPowerDifficultyMeta::Instance(), HOTFIX_SEL_SPELL_POWER_DIFFICULTY);
         return &loadInfo;
@@ -4629,9 +4729,9 @@ struct SpellProcsPerMinuteModLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "Coeff" },
-            { true, FT_SHORT, "Param" },
             { false, FT_BYTE, "Type" },
+            { true, FT_SHORT, "Param" },
+            { false, FT_FLOAT, "Coeff" },
             { false, FT_SHORT, "SpellProcsPerMinuteID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellProcsPerMinuteModMeta::Instance(), HOTFIX_SEL_SPELL_PROCS_PER_MINUTE_MOD);
@@ -4665,11 +4765,11 @@ struct SpellRangeLoadInfo
             { false, FT_INT, "ID" },
             { false, FT_STRING, "DisplayName" },
             { false, FT_STRING, "DisplayNameShort" },
+            { false, FT_BYTE, "Flags" },
             { false, FT_FLOAT, "RangeMin1" },
             { false, FT_FLOAT, "RangeMin2" },
             { false, FT_FLOAT, "RangeMax1" },
             { false, FT_FLOAT, "RangeMax2" },
-            { false, FT_BYTE, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellRangeMeta::Instance(), HOTFIX_SEL_SPELL_RANGE);
         return &loadInfo;
@@ -4714,10 +4814,10 @@ struct SpellScalingLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
-            { true, FT_SHORT, "ScalesFromItemLevel" },
             { true, FT_INT, "Class" },
             { false, FT_INT, "MinScalingLevel" },
             { false, FT_INT, "MaxScalingLevel" },
+            { true, FT_SHORT, "ScalesFromItemLevel" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellScalingMeta::Instance(), HOTFIX_SEL_SPELL_SCALING);
         return &loadInfo;
@@ -4732,11 +4832,11 @@ struct SpellShapeshiftLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
+            { true, FT_BYTE, "StanceBarOrder" },
             { true, FT_INT, "ShapeshiftExclude1" },
             { true, FT_INT, "ShapeshiftExclude2" },
             { true, FT_INT, "ShapeshiftMask1" },
             { true, FT_INT, "ShapeshiftMask2" },
-            { true, FT_BYTE, "StanceBarOrder" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellShapeshiftMeta::Instance(), HOTFIX_SEL_SPELL_SHAPESHIFT);
         return &loadInfo;
@@ -4751,13 +4851,13 @@ struct SpellShapeshiftFormLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
-            { false, FT_FLOAT, "DamageVariance" },
+            { true, FT_BYTE, "CreatureType" },
             { true, FT_INT, "Flags" },
+            { true, FT_INT, "AttackIconFileID" },
+            { true, FT_BYTE, "BonusActionBar" },
             { true, FT_SHORT, "CombatRoundTime" },
+            { false, FT_FLOAT, "DamageVariance" },
             { false, FT_SHORT, "MountTypeID" },
-            { true, FT_BYTE, "CreatureType" },
-            { true, FT_BYTE, "BonusActionBar" },
-            { true, FT_INT, "AttackIconFileID" },
             { false, FT_INT, "CreatureDisplayID1" },
             { false, FT_INT, "CreatureDisplayID2" },
             { false, FT_INT, "CreatureDisplayID3" },
@@ -4783,13 +4883,13 @@ struct SpellTargetRestrictionsLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "ConeDegrees" },
-            { false, FT_FLOAT, "Width" },
-            { true, FT_INT, "Targets" },
-            { true, FT_SHORT, "TargetCreatureType" },
             { false, FT_BYTE, "DifficultyID" },
+            { false, FT_FLOAT, "ConeDegrees" },
             { false, FT_BYTE, "MaxTargets" },
             { false, FT_INT, "MaxTargetLevel" },
+            { true, FT_SHORT, "TargetCreatureType" },
+            { true, FT_INT, "Targets" },
+            { false, FT_FLOAT, "Width" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellTargetRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_TARGET_RESTRICTIONS);
@@ -4805,10 +4905,10 @@ struct SpellTotemsLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "SpellID" },
-            { true, FT_INT, "Totem1" },
-            { true, FT_INT, "Totem2" },
             { false, FT_SHORT, "RequiredTotemCategoryID1" },
             { false, FT_SHORT, "RequiredTotemCategoryID2" },
+            { true, FT_INT, "Totem1" },
+            { true, FT_INT, "Totem2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellTotemsMeta::Instance(), HOTFIX_SEL_SPELL_TOTEMS);
         return &loadInfo;
@@ -4821,18 +4921,18 @@ struct SpellXSpellVisualLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "SpellVisualID" },
             { false, FT_INT, "ID" },
+            { false, FT_BYTE, "DifficultyID" },
+            { false, FT_INT, "SpellVisualID" },
             { false, FT_FLOAT, "Probability" },
-            { false, FT_SHORT, "CasterPlayerConditionID" },
-            { false, FT_SHORT, "CasterUnitConditionID" },
-            { false, FT_SHORT, "ViewerPlayerConditionID" },
-            { false, FT_SHORT, "ViewerUnitConditionID" },
-            { true, FT_INT, "SpellIconFileID" },
-            { true, FT_INT, "ActiveIconFileID" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_BYTE, "DifficultyID" },
             { false, FT_BYTE, "Priority" },
+            { true, FT_INT, "SpellIconFileID" },
+            { true, FT_INT, "ActiveIconFileID" },
+            { false, FT_SHORT, "ViewerUnitConditionID" },
+            { false, FT_INT, "ViewerPlayerConditionID" },
+            { false, FT_SHORT, "CasterUnitConditionID" },
+            { false, FT_INT, "CasterPlayerConditionID" },
             { true, FT_INT, "SpellID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellXSpellVisualMeta::Instance(), HOTFIX_SEL_SPELL_X_SPELL_VISUAL);
@@ -4847,11 +4947,11 @@ struct SummonPropertiesLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Flags" },
             { true, FT_INT, "Control" },
             { true, FT_INT, "Faction" },
             { true, FT_INT, "Title" },
             { true, FT_INT, "Slot" },
+            { true, FT_INT, "Flags" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SummonPropertiesMeta::Instance(), HOTFIX_SEL_SUMMON_PROPERTIES);
         return &loadInfo;
@@ -4895,15 +4995,15 @@ struct TalentLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Description" },
-            { false, FT_INT, "SpellID" },
-            { false, FT_INT, "OverridesSpellID" },
-            { false, FT_SHORT, "SpecID" },
             { false, FT_BYTE, "TierID" },
-            { false, FT_BYTE, "ColumnIndex" },
             { false, FT_BYTE, "Flags" },
+            { false, FT_BYTE, "ColumnIndex" },
+            { false, FT_BYTE, "ClassID" },
+            { false, FT_SHORT, "SpecID" },
+            { false, FT_INT, "SpellID" },
+            { false, FT_INT, "OverridesSpellID" },
             { false, FT_BYTE, "CategoryMask1" },
             { false, FT_BYTE, "CategoryMask2" },
-            { false, FT_BYTE, "ClassID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TalentMeta::Instance(), HOTFIX_SEL_TALENT);
         return &loadInfo;
@@ -4916,24 +5016,25 @@ struct TaxiNodesLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
             { false, FT_FLOAT, "PosX" },
             { false, FT_FLOAT, "PosY" },
             { false, FT_FLOAT, "PosZ" },
-            { true, FT_INT, "MountCreatureID1" },
-            { true, FT_INT, "MountCreatureID2" },
             { false, FT_FLOAT, "MapOffsetX" },
             { false, FT_FLOAT, "MapOffsetY" },
-            { false, FT_FLOAT, "Facing" },
             { false, FT_FLOAT, "FlightMapOffsetX" },
             { false, FT_FLOAT, "FlightMapOffsetY" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "ContinentID" },
             { false, FT_SHORT, "ConditionID" },
             { false, FT_SHORT, "CharacterBitNumber" },
             { false, FT_BYTE, "Flags" },
             { true, FT_INT, "UiTextureKitID" },
+            { false, FT_FLOAT, "Facing" },
             { false, FT_INT, "SpecialIconConditionID" },
+            { false, FT_INT, "VisibilityConditionID" },
+            { true, FT_INT, "MountCreatureID1" },
+            { true, FT_INT, "MountCreatureID2" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TaxiNodesMeta::Instance(), HOTFIX_SEL_TAXI_NODES);
         return &loadInfo;
@@ -4946,9 +5047,9 @@ struct TaxiPathLoadInfo
     {
         static DB2FieldMeta const fields[] =
         {
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "FromTaxiNode" },
             { false, FT_SHORT, "ToTaxiNode" },
-            { false, FT_INT, "ID" },
             { false, FT_INT, "Cost" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TaxiPathMeta::Instance(), HOTFIX_SEL_TAXI_PATH);
@@ -4965,10 +5066,10 @@ struct TaxiPathNodeLoadInfo
             { false, FT_FLOAT, "LocX" },
             { false, FT_FLOAT, "LocY" },
             { false, FT_FLOAT, "LocZ" },
+            { false, FT_INT, "ID" },
             { false, FT_SHORT, "PathID" },
+            { true, FT_INT, "NodeIndex" },
             { false, FT_SHORT, "ContinentID" },
-            { false, FT_BYTE, "NodeIndex" },
-            { false, FT_INT, "ID" },
             { false, FT_BYTE, "Flags" },
             { false, FT_INT, "Delay" },
             { false, FT_SHORT, "ArrivalEventID" },
@@ -4987,8 +5088,8 @@ struct TotemCategoryLoadInfo
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING, "Name" },
-            { true, FT_INT, "TotemCategoryMask" },
             { false, FT_BYTE, "TotemCategoryType" },
+            { true, FT_INT, "TotemCategoryMask" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TotemCategoryMeta::Instance(), HOTFIX_SEL_TOTEM_CATEGORY);
         return &loadInfo;
@@ -5002,10 +5103,10 @@ struct ToyLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "SourceText" },
+            { false, FT_INT, "ID" },
             { true, FT_INT, "ItemID" },
             { false, FT_BYTE, "Flags" },
             { true, FT_BYTE, "SourceTypeEnum" },
-            { false, FT_INT, "ID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ToyMeta::Instance(), HOTFIX_SEL_TOY);
         return &loadInfo;
@@ -5033,15 +5134,15 @@ struct TransmogSetLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "Name" },
-            { false, FT_SHORT, "ParentTransmogSetID" },
-            { true, FT_SHORT, "UiOrder" },
-            { false, FT_BYTE, "ExpansionID" },
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Flags" },
-            { false, FT_INT, "TrackingQuestID" },
             { true, FT_INT, "ClassMask" },
-            { true, FT_INT, "ItemNameDescriptionID" },
+            { false, FT_INT, "TrackingQuestID" },
+            { true, FT_INT, "Flags" },
             { false, FT_INT, "TransmogSetGroupID" },
+            { true, FT_INT, "ItemNameDescriptionID" },
+            { false, FT_SHORT, "ParentTransmogSetID" },
+            { false, FT_BYTE, "ExpansionID" },
+            { true, FT_SHORT, "UiOrder" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransmogSetMeta::Instance(), HOTFIX_SEL_TRANSMOG_SET);
         return &loadInfo;
@@ -5085,11 +5186,11 @@ struct TransportAnimationLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "TimeIndex" },
             { false, FT_FLOAT, "PosX" },
             { false, FT_FLOAT, "PosY" },
             { false, FT_FLOAT, "PosZ" },
             { false, FT_BYTE, "SequenceID" },
+            { false, FT_INT, "TimeIndex" },
             { true, FT_INT, "TransportID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransportAnimationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ANIMATION);
@@ -5104,11 +5205,11 @@ struct TransportRotationLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "TimeIndex" },
             { false, FT_FLOAT, "Rot1" },
             { false, FT_FLOAT, "Rot2" },
             { false, FT_FLOAT, "Rot3" },
             { false, FT_FLOAT, "Rot4" },
+            { false, FT_INT, "TimeIndex" },
             { true, FT_INT, "GameObjectsID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransportRotationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ROTATION);
@@ -5116,6 +5217,96 @@ struct TransportRotationLoadInfo
     }
 };
 
+struct UiMapLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_STRING, "Name" },
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "ParentUiMapID" },
+            { true, FT_INT, "Flags" },
+            { true, FT_INT, "System" },
+            { true, FT_INT, "Type" },
+            { false, FT_INT, "LevelRangeMin" },
+            { false, FT_INT, "LevelRangeMax" },
+            { true, FT_INT, "BountySetID" },
+            { false, FT_INT, "BountyDisplayLocation" },
+            { true, FT_INT, "VisibilityPlayerConditionID" },
+            { true, FT_BYTE, "HelpTextPosition" },
+            { true, FT_INT, "BkgAtlasID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiMapMeta::Instance(), HOTFIX_SEL_UI_MAP);
+        return &loadInfo;
+    }
+};
+
+struct UiMapAssignmentLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_FLOAT, "UiMinX" },
+            { false, FT_FLOAT, "UiMinY" },
+            { false, FT_FLOAT, "UiMaxX" },
+            { false, FT_FLOAT, "UiMaxY" },
+            { false, FT_FLOAT, "Region1X" },
+            { false, FT_FLOAT, "Region1Y" },
+            { false, FT_FLOAT, "Region1Z" },
+            { false, FT_FLOAT, "Region2X" },
+            { false, FT_FLOAT, "Region2Y" },
+            { false, FT_FLOAT, "Region2Z" },
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "UiMapID" },
+            { true, FT_INT, "OrderIndex" },
+            { true, FT_INT, "MapID" },
+            { true, FT_INT, "AreaID" },
+            { true, FT_INT, "WmoDoodadPlacementID" },
+            { true, FT_INT, "WmoGroupID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiMapAssignmentMeta::Instance(), HOTFIX_SEL_UI_MAP_ASSIGNMENT);
+        return &loadInfo;
+    }
+};
+
+struct UiMapLinkLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_FLOAT, "UiMinX" },
+            { false, FT_FLOAT, "UiMinY" },
+            { false, FT_FLOAT, "UiMaxX" },
+            { false, FT_FLOAT, "UiMaxY" },
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "ParentUiMapID" },
+            { true, FT_INT, "OrderIndex" },
+            { true, FT_INT, "ChildUiMapID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiMapLinkMeta::Instance(), HOTFIX_SEL_UI_MAP_LINK);
+        return &loadInfo;
+    }
+};
+
+struct UiMapXMapArtLoadInfo
+{
+    static DB2LoadInfo const* Instance()
+    {
+        static DB2FieldMeta const fields[] =
+        {
+            { false, FT_INT, "ID" },
+            { true, FT_INT, "PhaseID" },
+            { true, FT_INT, "UiMapArtID" },
+            { true, FT_INT, "UiMapID" },
+        };
+        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiMapXMapArtMeta::Instance(), HOTFIX_SEL_UI_MAP_X_MAP_ART);
+        return &loadInfo;
+    }
+};
+
 struct UnitPowerBarLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -5127,8 +5318,16 @@ struct UnitPowerBarLoadInfo
             { false, FT_STRING, "Cost" },
             { false, FT_STRING, "OutOfError" },
             { false, FT_STRING, "ToolTip" },
+            { false, FT_INT, "MinPower" },
+            { false, FT_INT, "MaxPower" },
+            { false, FT_SHORT, "StartPower" },
+            { false, FT_BYTE, "CenterPower" },
             { false, FT_FLOAT, "RegenerationPeace" },
             { false, FT_FLOAT, "RegenerationCombat" },
+            { false, FT_BYTE, "BarType" },
+            { false, FT_SHORT, "Flags" },
+            { false, FT_FLOAT, "StartInset" },
+            { false, FT_FLOAT, "EndInset" },
             { true, FT_INT, "FileDataID1" },
             { true, FT_INT, "FileDataID2" },
             { true, FT_INT, "FileDataID3" },
@@ -5141,14 +5340,6 @@ struct UnitPowerBarLoadInfo
             { true, FT_INT, "Color4" },
             { true, FT_INT, "Color5" },
             { true, FT_INT, "Color6" },
-            { false, FT_FLOAT, "StartInset" },
-            { false, FT_FLOAT, "EndInset" },
-            { false, FT_SHORT, "StartPower" },
-            { false, FT_SHORT, "Flags" },
-            { false, FT_BYTE, "CenterPower" },
-            { false, FT_BYTE, "BarType" },
-            { false, FT_INT, "MinPower" },
-            { false, FT_INT, "MaxPower" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UnitPowerBarMeta::Instance(), HOTFIX_SEL_UNIT_POWER_BAR);
         return &loadInfo;
@@ -5163,6 +5354,7 @@ struct VehicleLoadInfo
         {
             { false, FT_INT, "ID" },
             { true, FT_INT, "Flags" },
+            { false, FT_BYTE, "FlagsB" },
             { false, FT_FLOAT, "TurnSpeed" },
             { false, FT_FLOAT, "PitchSpeed" },
             { false, FT_FLOAT, "PitchMin" },
@@ -5174,6 +5366,9 @@ struct VehicleLoadInfo
             { false, FT_FLOAT, "FacingLimitRight" },
             { false, FT_FLOAT, "FacingLimitLeft" },
             { false, FT_FLOAT, "CameraYawOffset" },
+            { false, FT_BYTE, "UiLocomotionType" },
+            { false, FT_SHORT, "VehicleUIIndicatorID" },
+            { true, FT_INT, "MissileTargetingID" },
             { false, FT_SHORT, "SeatID1" },
             { false, FT_SHORT, "SeatID2" },
             { false, FT_SHORT, "SeatID3" },
@@ -5182,13 +5377,9 @@ struct VehicleLoadInfo
             { false, FT_SHORT, "SeatID6" },
             { false, FT_SHORT, "SeatID7" },
             { false, FT_SHORT, "SeatID8" },
-            { false, FT_SHORT, "VehicleUIIndicatorID" },
             { false, FT_SHORT, "PowerDisplayID1" },
             { false, FT_SHORT, "PowerDisplayID2" },
             { false, FT_SHORT, "PowerDisplayID3" },
-            { false, FT_BYTE, "FlagsB" },
-            { false, FT_BYTE, "UiLocomotionType" },
-            { true, FT_INT, "MissileTargetingID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VehicleMeta::Instance(), HOTFIX_SEL_VEHICLE);
         return &loadInfo;
@@ -5202,12 +5393,16 @@ struct VehicleSeatLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "Flags" },
-            { true, FT_INT, "FlagsB" },
-            { true, FT_INT, "FlagsC" },
             { false, FT_FLOAT, "AttachmentOffsetX" },
             { false, FT_FLOAT, "AttachmentOffsetY" },
             { false, FT_FLOAT, "AttachmentOffsetZ" },
+            { false, FT_FLOAT, "CameraOffsetX" },
+            { false, FT_FLOAT, "CameraOffsetY" },
+            { false, FT_FLOAT, "CameraOffsetZ" },
+            { true, FT_INT, "Flags" },
+            { true, FT_INT, "FlagsB" },
+            { true, FT_INT, "FlagsC" },
+            { true, FT_BYTE, "AttachmentID" },
             { false, FT_FLOAT, "EnterPreDelay" },
             { false, FT_FLOAT, "EnterSpeed" },
             { false, FT_FLOAT, "EnterGravity" },
@@ -5215,6 +5410,12 @@ struct VehicleSeatLoadInfo
             { false, FT_FLOAT, "EnterMaxDuration" },
             { false, FT_FLOAT, "EnterMinArcHeight" },
             { false, FT_FLOAT, "EnterMaxArcHeight" },
+            { true, FT_INT, "EnterAnimStart" },
+            { true, FT_INT, "EnterAnimLoop" },
+            { true, FT_INT, "RideAnimStart" },
+            { true, FT_INT, "RideAnimLoop" },
+            { true, FT_INT, "RideUpperAnimStart" },
+            { true, FT_INT, "RideUpperAnimLoop" },
             { false, FT_FLOAT, "ExitPreDelay" },
             { false, FT_FLOAT, "ExitSpeed" },
             { false, FT_FLOAT, "ExitGravity" },
@@ -5222,36 +5423,34 @@ struct VehicleSeatLoadInfo
             { false, FT_FLOAT, "ExitMaxDuration" },
             { false, FT_FLOAT, "ExitMinArcHeight" },
             { false, FT_FLOAT, "ExitMaxArcHeight" },
+            { true, FT_INT, "ExitAnimStart" },
+            { true, FT_INT, "ExitAnimLoop" },
+            { true, FT_INT, "ExitAnimEnd" },
+            { true, FT_SHORT, "VehicleEnterAnim" },
+            { true, FT_BYTE, "VehicleEnterAnimBone" },
+            { true, FT_SHORT, "VehicleExitAnim" },
+            { true, FT_BYTE, "VehicleExitAnimBone" },
+            { true, FT_SHORT, "VehicleRideAnimLoop" },
+            { true, FT_BYTE, "VehicleRideAnimLoopBone" },
+            { true, FT_BYTE, "PassengerAttachmentID" },
             { false, FT_FLOAT, "PassengerYaw" },
             { false, FT_FLOAT, "PassengerPitch" },
             { false, FT_FLOAT, "PassengerRoll" },
             { false, FT_FLOAT, "VehicleEnterAnimDelay" },
             { false, FT_FLOAT, "VehicleExitAnimDelay" },
+            { true, FT_BYTE, "VehicleAbilityDisplay" },
+            { false, FT_INT, "EnterUISoundID" },
+            { false, FT_INT, "ExitUISoundID" },
+            { true, FT_INT, "UiSkinFileDataID" },
             { false, FT_FLOAT, "CameraEnteringDelay" },
             { false, FT_FLOAT, "CameraEnteringDuration" },
             { false, FT_FLOAT, "CameraExitingDelay" },
             { false, FT_FLOAT, "CameraExitingDuration" },
-            { false, FT_FLOAT, "CameraOffsetX" },
-            { false, FT_FLOAT, "CameraOffsetY" },
-            { false, FT_FLOAT, "CameraOffsetZ" },
             { false, FT_FLOAT, "CameraPosChaseRate" },
             { false, FT_FLOAT, "CameraFacingChaseRate" },
             { false, FT_FLOAT, "CameraEnteringZoom" },
             { false, FT_FLOAT, "CameraSeatZoomMin" },
             { false, FT_FLOAT, "CameraSeatZoomMax" },
-            { true, FT_INT, "UiSkinFileDataID" },
-            { true, FT_SHORT, "EnterAnimStart" },
-            { true, FT_SHORT, "EnterAnimLoop" },
-            { true, FT_SHORT, "RideAnimStart" },
-            { true, FT_SHORT, "RideAnimLoop" },
-            { true, FT_SHORT, "RideUpperAnimStart" },
-            { true, FT_SHORT, "RideUpperAnimLoop" },
-            { true, FT_SHORT, "ExitAnimStart" },
-            { true, FT_SHORT, "ExitAnimLoop" },
-            { true, FT_SHORT, "ExitAnimEnd" },
-            { true, FT_SHORT, "VehicleEnterAnim" },
-            { true, FT_SHORT, "VehicleExitAnim" },
-            { true, FT_SHORT, "VehicleRideAnimLoop" },
             { true, FT_SHORT, "EnterAnimKitID" },
             { true, FT_SHORT, "RideAnimKitID" },
             { true, FT_SHORT, "ExitAnimKitID" },
@@ -5259,14 +5458,6 @@ struct VehicleSeatLoadInfo
             { true, FT_SHORT, "VehicleRideAnimKitID" },
             { true, FT_SHORT, "VehicleExitAnimKitID" },
             { true, FT_SHORT, "CameraModeID" },
-            { true, FT_BYTE, "AttachmentID" },
-            { true, FT_BYTE, "PassengerAttachmentID" },
-            { true, FT_BYTE, "VehicleEnterAnimBone" },
-            { true, FT_BYTE, "VehicleExitAnimBone" },
-            { true, FT_BYTE, "VehicleRideAnimLoopBone" },
-            { true, FT_BYTE, "VehicleAbilityDisplay" },
-            { false, FT_INT, "EnterUISoundID" },
-            { false, FT_INT, "ExitUISoundID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VehicleSeatMeta::Instance(), HOTFIX_SEL_VEHICLE_SEAT);
         return &loadInfo;
@@ -5280,20 +5471,20 @@ struct WmoAreaTableLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_STRING, "AreaName" },
+            { false, FT_INT, "ID" },
+            { false, FT_SHORT, "WmoID" },
+            { false, FT_BYTE, "NameSetID" },
             { true, FT_INT, "WmoGroupID" },
+            { false, FT_BYTE, "SoundProviderPref" },
+            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
             { false, FT_SHORT, "AmbienceID" },
+            { false, FT_SHORT, "UwAmbience" },
             { false, FT_SHORT, "ZoneMusic" },
+            { false, FT_INT, "UwZoneMusic" },
             { false, FT_SHORT, "IntroSound" },
-            { false, FT_SHORT, "AreaTableID" },
             { false, FT_SHORT, "UwIntroSound" },
-            { false, FT_SHORT, "UwAmbience" },
-            { false, FT_BYTE, "NameSetID" },
-            { false, FT_BYTE, "SoundProviderPref" },
-            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
+            { false, FT_SHORT, "AreaTableID" },
             { false, FT_BYTE, "Flags" },
-            { false, FT_INT, "ID" },
-            { false, FT_INT, "UwZoneMusic" },
-            { false, FT_SHORT, "WmoID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WMOAreaTableMeta::Instance(), HOTFIX_SEL_WMO_AREA_TABLE);
         return &loadInfo;
@@ -5307,63 +5498,33 @@ struct WorldEffectLoadInfo
         static DB2FieldMeta const fields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "TargetAsset" },
-            { false, FT_SHORT, "CombatConditionID" },
-            { false, FT_BYTE, "TargetType" },
-            { false, FT_BYTE, "WhenToDisplay" },
             { false, FT_INT, "QuestFeedbackEffectID" },
+            { false, FT_BYTE, "WhenToDisplay" },
+            { false, FT_BYTE, "TargetType" },
+            { true, FT_INT, "TargetAsset" },
             { false, FT_INT, "PlayerConditionID" },
+            { false, FT_SHORT, "CombatConditionID" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldEffectMeta::Instance(), HOTFIX_SEL_WORLD_EFFECT);
         return &loadInfo;
     }
 };
 
-struct WorldMapAreaLoadInfo
-{
-    static DB2LoadInfo const* Instance()
-    {
-        static DB2FieldMeta const fields[] =
-        {
-            { false, FT_STRING_NOT_LOCALIZED, "AreaName" },
-            { false, FT_FLOAT, "LocLeft" },
-            { false, FT_FLOAT, "LocRight" },
-            { false, FT_FLOAT, "LocTop" },
-            { false, FT_FLOAT, "LocBottom" },
-            { false, FT_INT, "Flags" },
-            { true, FT_SHORT, "MapID" },
-            { false, FT_SHORT, "AreaID" },
-            { true, FT_SHORT, "DisplayMapID" },
-            { false, FT_SHORT, "DefaultDungeonFloor" },
-            { false, FT_SHORT, "ParentWorldMapID" },
-            { false, FT_BYTE, "LevelRangeMin" },
-            { false, FT_BYTE, "LevelRangeMax" },
-            { false, FT_BYTE, "BountySetID" },
-            { false, FT_BYTE, "BountyDisplayLocation" },
-            { false, FT_INT, "ID" },
-            { false, FT_INT, "VisibilityPlayerConditionID" },
-        };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldMapAreaMeta::Instance(), HOTFIX_SEL_WORLD_MAP_AREA);
-        return &loadInfo;
-    }
-};
-
 struct WorldMapOverlayLoadInfo
 {
     static DB2LoadInfo const* Instance()
     {
         static DB2FieldMeta const fields[] =
         {
-            { false, FT_STRING_NOT_LOCALIZED, "TextureName" },
             { false, FT_INT, "ID" },
+            { false, FT_INT, "UiMapArtID" },
             { false, FT_SHORT, "TextureWidth" },
             { false, FT_SHORT, "TextureHeight" },
-            { false, FT_INT, "MapAreaID" },
             { true, FT_INT, "OffsetX" },
             { true, FT_INT, "OffsetY" },
             { true, FT_INT, "HitRectTop" },
-            { true, FT_INT, "HitRectLeft" },
             { true, FT_INT, "HitRectBottom" },
+            { true, FT_INT, "HitRectLeft" },
             { true, FT_INT, "HitRectRight" },
             { false, FT_INT, "PlayerConditionID" },
             { false, FT_INT, "Flags" },
@@ -5377,35 +5538,6 @@ struct WorldMapOverlayLoadInfo
     }
 };
 
-struct WorldMapTransformsLoadInfo
-{
-    static DB2LoadInfo const* Instance()
-    {
-        static DB2FieldMeta const fields[] =
-        {
-            { false, FT_INT, "ID" },
-            { false, FT_FLOAT, "RegionMinX" },
-            { false, FT_FLOAT, "RegionMinY" },
-            { false, FT_FLOAT, "RegionMinZ" },
-            { false, FT_FLOAT, "RegionMaxX" },
-            { false, FT_FLOAT, "RegionMaxY" },
-            { false, FT_FLOAT, "RegionMaxZ" },
-            { false, FT_FLOAT, "RegionOffsetX" },
-            { false, FT_FLOAT, "RegionOffsetY" },
-            { false, FT_FLOAT, "RegionScale" },
-            { false, FT_SHORT, "MapID" },
-            { false, FT_SHORT, "AreaID" },
-            { false, FT_SHORT, "NewMapID" },
-            { false, FT_SHORT, "NewDungeonMapID" },
-            { false, FT_SHORT, "NewAreaID" },
-            { false, FT_BYTE, "Flags" },
-            { true, FT_INT, "Priority" },
-        };
-        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldMapTransformsMeta::Instance(), HOTFIX_SEL_WORLD_MAP_TRANSFORMS);
-        return &loadInfo;
-    }
-};
-
 struct WorldSafeLocsLoadInfo
 {
     static DB2LoadInfo const* Instance()
@@ -5417,8 +5549,8 @@ struct WorldSafeLocsLoadInfo
             { false, FT_FLOAT, "LocX" },
             { false, FT_FLOAT, "LocY" },
             { false, FT_FLOAT, "LocZ" },
-            { false, FT_FLOAT, "Facing" },
             { false, FT_SHORT, "MapID" },
+            { false, FT_FLOAT, "Facing" },
         };
         static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldSafeLocsMeta::Instance(), HOTFIX_SEL_WORLD_SAFE_LOCS);
         return &loadInfo;
diff --git a/src/server/game/DataStores/DB2Metadata.h b/src/server/game/DataStores/DB2Metadata.h
index f65b1190066..1d2e317b148 100644
--- a/src/server/game/DataStores/DB2Metadata.h
+++ b/src/server/game/DataStores/DB2Metadata.h
@@ -24,9 +24,25 @@ struct AchievementMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sssihhhhhbbbiii";
-        static uint8 const arraySizes[15] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(12, 15, 0x2C4BE18C, types, arraySizes, 7);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(3, 15, 0x13CB7BEE, fields, 11);
         return &instance;
     }
 };
@@ -35,9 +51,14 @@ struct Achievement_CategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shbi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(3, 4, 0xED226BC9, types, arraySizes, 2);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(1, 4, 0x0B008A91, fields, 3);
         return &instance;
     }
 };
@@ -46,9 +67,32 @@ struct AdventureJournalMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sssssiihhhhhhbbbbbbbii";
-        static uint8 const arraySizes[22] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1 };
-        static DB2Meta instance(-1, 22, 0xB2FFA8DD, types, arraySizes, -1);
+        static DB2MetaField const fields[22] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 2, false },
+            { FT_BYTE, 2, false },
+        };
+        static DB2Meta instance(-1, 22, 0x9D620FC8, fields, -1);
         return &instance;
     }
 };
@@ -57,9 +101,22 @@ struct AdventureMapPOIMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssfibiiiiiiii";
-        static uint8 const arraySizes[13] = { 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 13, 0x0C288A82, types, arraySizes, -1);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 2, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 12, 0x4AABC870, fields, -1);
         return &instance;
     }
 };
@@ -68,9 +125,18 @@ struct AlliedRaceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiiiii";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(1, 8, 0xB13ABE04, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 8, 0xE89FA2D2, fields, -1);
         return &instance;
     }
 };
@@ -79,9 +145,15 @@ struct AlliedRaceRacialAbilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssbii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x9EBF9B09, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x96902165, fields, 4);
         return &instance;
     }
 };
@@ -90,9 +162,13 @@ struct AnimKitMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x81D6D250, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x0C4BCDEC, fields, -1);
         return &instance;
     }
 };
@@ -101,9 +177,15 @@ struct AnimKitBoneSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbbbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xFE4B9B1F, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x1C432613, fields, -1);
         return &instance;
     }
 };
@@ -112,9 +194,12 @@ struct AnimKitBoneSetAliasMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xEA8B67BC, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xB307E8FC, fields, -1);
         return &instance;
     }
 };
@@ -123,9 +208,11 @@ struct AnimKitConfigMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x8A70ED4C, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0x972D46F8, fields, -1);
         return &instance;
     }
 };
@@ -134,9 +221,13 @@ struct AnimKitConfigBoneSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x3D9B3BA7, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x48518303, fields, 2);
         return &instance;
     }
 };
@@ -145,9 +236,11 @@ struct AnimKitPriorityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "b";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x5E93C107, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0x27ED596B, fields, -1);
         return &instance;
     }
 };
@@ -156,9 +249,15 @@ struct AnimKitReplacementMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhih";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(3, 5, 0x0735DB83, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(0, 5, 0xB0BBA55F, fields, 4);
         return &instance;
     }
 };
@@ -167,9 +266,28 @@ struct AnimKitSegmentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiifihhhhhhbbbbbbi";
-        static uint8 const arraySizes[18] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 18, 0x08F09B89, types, arraySizes, 5);
+        static DB2MetaField const fields[18] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 18, 0xEBF796F5, fields, 0);
         return &instance;
     }
 };
@@ -178,9 +296,15 @@ struct AnimReplacementMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhih";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(3, 5, 0x2C8B0F35, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(0, 5, 0x5D91ABFD, fields, 4);
         return &instance;
     }
 };
@@ -189,9 +313,11 @@ struct AnimReplacementSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "b";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x3761247A, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0x15AFC3D6, fields, -1);
         return &instance;
     }
 };
@@ -200,9 +326,48 @@ struct AnimationDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihhb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x03182786, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(-1, 4, 0xFB408E92, fields, -1);
+        return &instance;
+    }
+};
+
+struct AoiBoxMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 6, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x173154C8, fields, 4);
+        return &instance;
+    }
+};
+
+struct AreaConditionalDataMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(1, 5, 0xBE8C656A, fields, 4);
         return &instance;
     }
 };
@@ -211,9 +376,14 @@ struct AreaFarClipOverrideMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iffii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(4, 5, 0xEB5921CC, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xD7028AD6, fields, -1);
         return &instance;
     }
 };
@@ -222,9 +392,12 @@ struct AreaGroupMemberMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x50AA43EE, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x27C84A16, fields, 1);
         return &instance;
     }
 };
@@ -233,9 +406,27 @@ struct AreaPOIMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssifiihhhhbbiiii";
-        static uint8 const arraySizes[16] = { 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 16, 0xB161EE90, types, arraySizes, -1);
+        static DB2MetaField const fields[17] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(2, 17, 0x34D56581, fields, 11);
         return &instance;
     }
 };
@@ -244,9 +435,15 @@ struct AreaPOIStateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbbih";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x673BDA80, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xEB8CA12C, fields, 4);
         return &instance;
     }
 };
@@ -255,9 +452,33 @@ struct AreaTableMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssifhhhhhhhhhhbbbbbbbbi";
-        static uint8 const arraySizes[23] = { 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 23, 0x0CA01129, types, arraySizes, -1);
+        static DB2MetaField const fields[23] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 2, true },
+            { FT_SHORT, 4, false },
+        };
+        static DB2Meta instance(-1, 23, 0x22229BE7, fields, -1);
         return &instance;
     }
 };
@@ -266,9 +487,25 @@ struct AreaTriggerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffhhhhhbbbi";
-        static uint8 const arraySizes[15] = { 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(14, 15, 0x378573E8, types, arraySizes, 6);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(1, 15, 0x61A4F966, fields, 2);
         return &instance;
     }
 };
@@ -277,9 +514,11 @@ struct AreaTriggerActionSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "h";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x5DA480BD, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xBE34F649, fields, -1);
         return &instance;
     }
 };
@@ -288,9 +527,25 @@ struct AreaTriggerBoxMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "f";
-        static uint8 const arraySizes[1] = { 3 };
-        static DB2Meta instance(-1, 1, 0x602CFDA6, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_FLOAT, 3, true },
+        };
+        static DB2Meta instance(-1, 1, 0x14918F12, fields, -1);
+        return &instance;
+    }
+};
+
+struct AreaTriggerCreatePropertiesMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xAAE6E300, fields, -1);
         return &instance;
     }
 };
@@ -299,9 +554,13 @@ struct AreaTriggerCylinderMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fff";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x26D4052D, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x867834A9, fields, -1);
         return &instance;
     }
 };
@@ -310,9 +569,11 @@ struct AreaTriggerSphereMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "f";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x9141AC7F, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF1D2220B, fields, -1);
         return &instance;
     }
 };
@@ -321,9 +582,15 @@ struct ArmorLocationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffff";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xCCFBD16E, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x1C0BBC02, fields, -1);
         return &instance;
     }
 };
@@ -332,9 +599,21 @@ struct ArtifactMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siiihhbbii";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x76CF31A8, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(1, 11, 0x780D61EA, fields, -1);
         return &instance;
     }
 };
@@ -343,9 +622,25 @@ struct ArtifactAppearanceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siffihhbbbbiiii";
-        static uint8 const arraySizes[15] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(11, 15, 0xAEED7395, types, arraySizes, 5);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(1, 15, 0x330F75C9, fields, 2);
         return &instance;
     }
 };
@@ -354,9 +649,19 @@ struct ArtifactAppearanceSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sshhbbbib";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 9, 0x53DFED74, types, arraySizes, 8);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(2, 9, 0xBB4DB4D3, fields, 8);
         return &instance;
     }
 };
@@ -365,9 +670,27 @@ struct ArtifactCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x21328475, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x484A6D55, fields, -1);
+        return &instance;
+    }
+};
+
+struct ArtifactItemToTransmogMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xD54CBBE1, fields, 0);
         return &instance;
     }
 };
@@ -376,9 +699,17 @@ struct ArtifactPowerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbbbbii";
-        static uint8 const arraySizes[7] = { 2, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(5, 7, 0x45240818, types, arraySizes, 1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(1, 7, 0x1F7637C8, fields, 2);
         return &instance;
     }
 };
@@ -387,9 +718,12 @@ struct ArtifactPowerLinkMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xE179618C, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xBB7E3584, fields, -1);
         return &instance;
     }
 };
@@ -398,9 +732,11 @@ struct ArtifactPowerPickerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x2D6AF006, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0x253242BA, fields, -1);
         return &instance;
     }
 };
@@ -409,9 +745,15 @@ struct ArtifactPowerRankMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifhbh";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xA87EACC4, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x7DC78F1E, fields, 4);
         return &instance;
     }
 };
@@ -420,9 +762,11 @@ struct ArtifactQuestXPMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 10 };
-        static DB2Meta instance(-1, 1, 0x86397302, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 10, false },
+        };
+        static DB2Meta instance(-1, 1, 0x7E00C5B6, fields, -1);
         return &instance;
     }
 };
@@ -431,9 +775,15 @@ struct ArtifactTierMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x1A5A50B9, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xA47F6D9D, fields, -1);
         return &instance;
     }
 };
@@ -442,9 +792,15 @@ struct ArtifactUnlockMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbiib";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x52839A77, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x40C54B9F, fields, 4);
         return &instance;
     }
 };
@@ -453,9 +809,105 @@ struct AuctionHouseMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x51CFEEFF, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x61E641BA, fields, -1);
+        return &instance;
+    }
+};
+
+struct AzeriteEmpoweredItemMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x4078BECD, fields, -1);
+        return &instance;
+    }
+};
+
+struct AzeriteItemMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xDAC6A93C, fields, -1);
+        return &instance;
+    }
+};
+
+struct AzeriteItemMilestonePowerMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x7C4DC43D, fields, -1);
+        return &instance;
+    }
+};
+
+struct AzeritePowerMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xE7FE46AC, fields, -1);
+        return &instance;
+    }
+};
+
+struct AzeritePowerSetMemberMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[5] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xDB24A281, fields, 4);
+        return &instance;
+    }
+};
+
+struct AzeriteTierUnlockMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x2B04F059, fields, 3);
         return &instance;
     }
 };
@@ -464,9 +916,11 @@ struct BankBagSlotPricesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xEA0AC2AA, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0x897A4D1E, fields, -1);
         return &instance;
     }
 };
@@ -475,9 +929,13 @@ struct BannedAddonsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xF779B6E5, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xF4525F59, fields, -1);
         return &instance;
     }
 };
@@ -486,9 +944,18 @@ struct BarberShopStyleMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssfbbbbi";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 8, 0x670C71AE, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(2, 8, 0x2DD3952C, fields, -1);
         return &instance;
     }
 };
@@ -497,9 +964,17 @@ struct BattlePetAbilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssihbbi";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x0F29944D, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0x4C3AF583, fields, -1);
         return &instance;
     }
 };
@@ -508,9 +983,17 @@ struct BattlePetAbilityEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhhhbi";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 6, 1, 1 };
-        static DB2Meta instance(6, 7, 0x5D30EBC5, types, arraySizes, 0);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 6, true },
+        };
+        static DB2Meta instance(0, 7, 0xC850B549, fields, 1);
         return &instance;
     }
 };
@@ -519,9 +1002,13 @@ struct BattlePetAbilityStateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x0E40A884, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x73DDAA6A, fields, 2);
         return &instance;
     }
 };
@@ -530,9 +1017,16 @@ struct BattlePetAbilityTurnMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhbbbi";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(5, 6, 0xCB063F4F, types, arraySizes, 0);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(0, 6, 0xF2218887, fields, 1);
         return &instance;
     }
 };
@@ -541,9 +1035,12 @@ struct BattlePetBreedQualityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xBDE74E1D, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x6CD46EB5, fields, -1);
         return &instance;
     }
 };
@@ -552,9 +1049,13 @@ struct BattlePetBreedStateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x68D5C999, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xC1A59CCF, fields, 2);
         return &instance;
     }
 };
@@ -563,9 +1064,14 @@ struct BattlePetDisplayOverrideMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiib";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xDE5129EA, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x6F9CB092, fields, -1);
         return &instance;
     }
 };
@@ -574,9 +1080,13 @@ struct BattlePetEffectPropertiesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shb";
-        static uint8 const arraySizes[3] = { 6, 1, 6 };
-        static DB2Meta instance(-1, 3, 0x56070751, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 6, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 6, false },
+        };
+        static DB2Meta instance(-1, 3, 0xA2D4ADF5, fields, -1);
         return &instance;
     }
 };
@@ -585,9 +1095,11 @@ struct BattlePetNPCTeamMemberMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x4423F004, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x9F2C8370, fields, -1);
         return &instance;
     }
 };
@@ -596,9 +1108,21 @@ struct BattlePetSpeciesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssiiihbbiii";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(8, 11, 0x8A3D97A4, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(2, 11, 0x78A6B928, fields, -1);
         return &instance;
     }
 };
@@ -607,9 +1131,13 @@ struct BattlePetSpeciesStateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x8F958D5C, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x99EBACAA, fields, 2);
         return &instance;
     }
 };
@@ -618,9 +1146,14 @@ struct BattlePetSpeciesXAbilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbh";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x9EE27D6A, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x630BA932, fields, 3);
         return &instance;
     }
 };
@@ -629,9 +1162,13 @@ struct BattlePetStateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x1797AB4A, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xF9579FAC, fields, -1);
         return &instance;
     }
 };
@@ -640,9 +1177,17 @@ struct BattlePetVisualMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihhhbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x097E0F6C, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0x284AF258, fields, -1);
         return &instance;
     }
 };
@@ -651,9 +1196,27 @@ struct BattlemasterListMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssssihhhbbbbbbbbb";
-        static uint8 const arraySizes[17] = { 1, 1, 1, 1, 1, 16, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 17, 0xD8AAA088, types, arraySizes, -1);
+        static DB2MetaField const fields[17] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 16, true },
+        };
+        static DB2Meta instance(-1, 17, 0x167284E8, fields, -1);
         return &instance;
     }
 };
@@ -662,9 +1225,20 @@ struct BeamEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iffihhhhhh";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x42C18603, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 10, 0x0E55B843, fields, -1);
         return &instance;
     }
 };
@@ -673,9 +1247,12 @@ struct BoneWindModifierModelMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x577A0772, types, arraySizes, 0);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x77B007CA, fields, 0);
         return &instance;
     }
 };
@@ -684,9 +1261,28 @@ struct BoneWindModifiersMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ff";
-        static uint8 const arraySizes[2] = { 3, 1 };
-        static DB2Meta instance(-1, 2, 0xB4E7449E, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xC6F446CE, fields, -1);
+        return &instance;
+    }
+};
+
+struct BonusRollMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xF7A194FA, fields, -1);
         return &instance;
     }
 };
@@ -695,9 +1291,15 @@ struct BountyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihhib";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xE76E716C, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x797CCAA0, fields, 4);
         return &instance;
     }
 };
@@ -706,9 +1308,12 @@ struct BountySetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hi";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x96B908A5, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xB67E3F83, fields, -1);
         return &instance;
     }
 };
@@ -717,9 +1322,21 @@ struct BroadcastTextMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sshhhbbii";
-        static uint8 const arraySizes[9] = { 1, 1, 3, 3, 1, 1, 1, 1, 2 };
-        static DB2Meta instance(-1, 9, 0x51BF0C33, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 2, false },
+            { FT_SHORT, 3, false },
+            { FT_SHORT, 3, false },
+        };
+        static DB2Meta instance(2, 11, 0x6318993B, fields, -1);
         return &instance;
     }
 };
@@ -728,9 +1345,11 @@ struct CameraEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "b";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xF6AB4622, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0xAB0FD78E, fields, -1);
         return &instance;
     }
 };
@@ -739,9 +1358,26 @@ struct CameraEffectEntryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffffhbbbbbbh";
-        static uint8 const arraySizes[16] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 16, 0xC5105557, types, arraySizes, 15);
+        static DB2MetaField const fields[16] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 16, 0xED27DC2F, fields, 15);
         return &instance;
     }
 };
@@ -750,9 +1386,70 @@ struct CameraModeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffffhbbbbb";
-        static uint8 const arraySizes[11] = { 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 11, 0xCDB6BC2F, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 11, 0xEE5489F4, fields, -1);
+        return &instance;
+    }
+};
+
+struct CampaignMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(3, 7, 0x2D49AABD, fields, -1);
+        return &instance;
+    }
+};
+
+struct CampaignXConditionMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x638FC159, fields, 2);
+        return &instance;
+    }
+};
+
+struct CampaignXQuestLineMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x7303E0F9, fields, 0);
         return &instance;
     }
 };
@@ -761,9 +1458,12 @@ struct CastableRaidBuffsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x5BDD4028, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x3B349C01, fields, 1);
         return &instance;
     }
 };
@@ -772,9 +1472,25 @@ struct CelestialBodyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiiifffffffhi";
-        static uint8 const arraySizes[15] = { 1, 1, 2, 1, 1, 2, 2, 2, 1, 2, 1, 3, 1, 1, 1 };
-        static DB2Meta instance(14, 15, 0xD09BE31C, types, arraySizes, -1);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 2, true },
+            { FT_FLOAT, 2, true },
+            { FT_INT, 2, true },
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 2, true },
+        };
+        static DB2Meta instance(1, 15, 0xFC417DCA, fields, -1);
         return &instance;
     }
 };
@@ -783,9 +1499,15 @@ struct Cfg_CategoriesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shbbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x705B82C8, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xB6FEB874, fields, -1);
         return &instance;
     }
 };
@@ -794,9 +1516,14 @@ struct Cfg_ConfigsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fhbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xC618392F, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xA275539B, fields, -1);
         return &instance;
     }
 };
@@ -805,9 +1532,15 @@ struct Cfg_RegionsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siihb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x9F4272BF, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x0125202F, fields, -1);
         return &instance;
     }
 };
@@ -816,9 +1549,12 @@ struct CharBaseInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x9E9939B8, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x10AA45F8, fields, -1);
         return &instance;
     }
 };
@@ -827,9 +1563,13 @@ struct CharBaseSectionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x4F08B5F3, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xF9D1C513, fields, -1);
         return &instance;
     }
 };
@@ -838,9 +1578,12 @@ struct CharComponentTextureLayoutsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x0F515E34, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x48D8D7BC, fields, -1);
         return &instance;
     }
 };
@@ -849,9 +1592,17 @@ struct CharComponentTextureSectionsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihhhhbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0xCE76000F, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0xD6EDA743, fields, -1);
         return &instance;
     }
 };
@@ -860,9 +1611,20 @@ struct CharHairGeosetsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibbbbbbbbi";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x33EB32D2, types, arraySizes, 1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 10, 0xE3732EA9, fields, 0);
         return &instance;
     }
 };
@@ -871,9 +1633,17 @@ struct CharSectionsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbbbbb";
-        static uint8 const arraySizes[7] = { 3, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0xE349E55B, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 3, true },
+        };
+        static DB2Meta instance(-1, 7, 0x273A7F6F, fields, -1);
         return &instance;
     }
 };
@@ -882,9 +1652,19 @@ struct CharShipmentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiihhbb";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0xE6D3C7C1, types, arraySizes, 5);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 9, 0xD47EC921, fields, 0);
         return &instance;
     }
 };
@@ -893,9 +1673,26 @@ struct CharShipmentContainerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssihhhhhhbbbbbbi";
-        static uint8 const arraySizes[16] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 16, 0x194896E3, types, arraySizes, -1);
+        static DB2MetaField const fields[16] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 16, 0x13048703, fields, -1);
         return &instance;
     }
 };
@@ -904,9 +1701,17 @@ struct CharStartOutfitMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibbbbb";
-        static uint8 const arraySizes[7] = { 24, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x0EEBEE24, types, arraySizes, 6);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 24, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0x0F59DD96, fields, 6);
         return &instance;
     }
 };
@@ -915,9 +1720,14 @@ struct CharTitlesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sshb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x7A58AA5F, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x81B69C5F, fields, -1);
         return &instance;
     }
 };
@@ -926,9 +1736,15 @@ struct CharacterFaceBoneSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibbbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x1C634076, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x3C6DE4D7, fields, 4);
         return &instance;
     }
 };
@@ -937,9 +1753,14 @@ struct CharacterFacialHairStylesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibbb";
-        static uint8 const arraySizes[4] = { 5, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x47D79688, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 5, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xAA817A08, fields, -1);
         return &instance;
     }
 };
@@ -948,9 +1769,13 @@ struct CharacterLoadoutMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "lbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x87B51673, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_LONG, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xA07F9727, fields, -1);
         return &instance;
     }
 };
@@ -959,9 +1784,12 @@ struct CharacterLoadoutItemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ih";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x3C3D40B9, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xD892CDA9, fields, 0);
         return &instance;
     }
 };
@@ -970,9 +1798,21 @@ struct CharacterServiceInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sssiiiiiiii";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 11, 0xADE120EF, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 11, 0xC263D77C, fields, -1);
         return &instance;
     }
 };
@@ -981,9 +1821,14 @@ struct ChatChannelsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssib";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x1A325E80, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x113E92FA, fields, -1);
         return &instance;
     }
 };
@@ -992,9 +1837,12 @@ struct ChatProfanityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x328E1FE6, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xAF5F92A6, fields, -1);
         return &instance;
     }
 };
@@ -1003,9 +1851,16 @@ struct ChrClassRaceSexMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbbiii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x5E29DFA1, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0x204BD561, fields, -1);
         return &instance;
     }
 };
@@ -1014,9 +1869,13 @@ struct ChrClassTitleMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xC155DB2C, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xA01D47C8, fields, -1);
         return &instance;
     }
 };
@@ -1025,9 +1884,13 @@ struct ChrClassUIDisplayMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x59A95A73, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x3D58F88F, fields, -1);
         return &instance;
     }
 };
@@ -1036,9 +1899,13 @@ struct ChrClassVillainMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xA6AC18CD, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x601C7CCD, fields, -1);
         return &instance;
     }
 };
@@ -1047,9 +1914,30 @@ struct ChrClassesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sssssiiiiihhhbbbbbbi";
-        static uint8 const arraySizes[20] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(19, 20, 0x6F7AB8E7, types, arraySizes, -1);
+        static DB2MetaField const fields[20] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(5, 20, 0x2CD115AC, fields, -1);
         return &instance;
     }
 };
@@ -1058,9 +1946,12 @@ struct ChrClassesXPowerTypesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xAF977B23, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x6DE888E7, fields, 1);
         return &instance;
     }
 };
@@ -1069,9 +1960,17 @@ struct ChrCustomizationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siiiii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 3, 1 };
-        static DB2Meta instance(-1, 6, 0x71833CE5, types, arraySizes, 5);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 3, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 7, 0xC29562A3, fields, 6);
         return &instance;
     }
 };
@@ -1080,9 +1979,56 @@ struct ChrRacesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssssssiiiiiffiiihhhhbbbbbbbbbbiiiiiiii";
-        static uint8 const arraySizes[38] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3 };
-        static DB2Meta instance(30, 38, 0x51C511F9, types, arraySizes, -1);
+        static DB2MetaField const fields[46] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, true },
+            { FT_INT, 3, false },
+            { FT_INT, 3, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(6, 46, 0xC8BCDC89, fields, -1);
         return &instance;
     }
 };
@@ -1091,9 +2037,23 @@ struct ChrSpecializationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sssibbbbbiiii";
-        static uint8 const arraySizes[13] = { 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(9, 13, 0x3D86B8F7, types, arraySizes, 4);
+        static DB2MetaField const fields[13] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(3, 13, 0xFF9DD5DD, fields, 4);
         return &instance;
     }
 };
@@ -1102,9 +2062,13 @@ struct ChrUpgradeBucketMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hib";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(1, 3, 0xACF64A80, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(0, 3, 0x81B7C74C, fields, 2);
         return &instance;
     }
 };
@@ -1113,9 +2077,12 @@ struct ChrUpgradeBucketSpellMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ih";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xDF939031, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xC665F469, fields, 1);
         return &instance;
     }
 };
@@ -1124,9 +2091,14 @@ struct ChrUpgradeTierMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbbi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(3, 4, 0x2C87937D, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(1, 4, 0xEC517FDD, fields, -1);
         return &instance;
     }
 };
@@ -1135,9 +2107,14 @@ struct CinematicCameraMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iffi";
-        static uint8 const arraySizes[4] = { 1, 3, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x0062B0F4, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x20C5E540, fields, -1);
         return &instance;
     }
 };
@@ -1146,9 +2123,25 @@ struct CinematicSequencesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ih";
-        static uint8 const arraySizes[2] = { 1, 8 };
-        static DB2Meta instance(-1, 2, 0x470FDA8C, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 8, false },
+        };
+        static DB2Meta instance(-1, 2, 0x6A232AD4, fields, -1);
+        return &instance;
+    }
+};
+
+struct ClientSceneEffectMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x00EE4486, fields, -1);
         return &instance;
     }
 };
@@ -1157,9 +2150,37 @@ struct CloakDampeningMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffffff";
-        static uint8 const arraySizes[7] = { 5, 5, 2, 2, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0xB2DF7F2A, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 5, true },
+            { FT_FLOAT, 5, true },
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 2, true },
+        };
+        static DB2Meta instance(-1, 7, 0xF7C03F6E, fields, -1);
+        return &instance;
+    }
+};
+
+struct CloneEffectMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[8] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 8, 0x2F946F74, fields, -1);
         return &instance;
     }
 };
@@ -1168,9 +2189,21 @@ struct CombatConditionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhhhbbbbbb";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 2, 2, 2, 2, 1, 2, 2, 1 };
-        static DB2Meta instance(-1, 11, 0x28D253C6, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 2, false },
+            { FT_BYTE, 2, false },
+            { FT_BYTE, 2, false },
+            { FT_SHORT, 2, false },
+            { FT_BYTE, 2, false },
+            { FT_BYTE, 2, false },
+        };
+        static DB2Meta instance(-1, 11, 0x75A29044, fields, -1);
         return &instance;
     }
 };
@@ -1179,9 +2212,12 @@ struct CommentatorStartLocationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fi";
-        static uint8 const arraySizes[2] = { 3, 1 };
-        static DB2Meta instance(-1, 2, 0xEFD540EF, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xF552D58F, fields, -1);
         return &instance;
     }
 };
@@ -1190,9 +2226,29 @@ struct CommentatorTrackedCooldownMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbih";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x84985168, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x3A1476FC, fields, 3);
+        return &instance;
+    }
+};
+
+struct CommunityIconMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 3, 0x7E19DEAD, fields, -1);
         return &instance;
     }
 };
@@ -1201,9 +2257,14 @@ struct ComponentModelFileDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x25BB55A7, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x0F90AFAF, fields, -1);
         return &instance;
     }
 };
@@ -1212,9 +2273,13 @@ struct ComponentTextureFileDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x50C58D4F, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x263AACE3, fields, -1);
         return &instance;
     }
 };
@@ -1223,9 +2288,30 @@ struct ConfigurationWarningMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "si";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x0B350390, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x99BCBA2D, fields, -1);
+        return &instance;
+    }
+};
+
+struct ContentTuningMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 6, 0xD1A210D1, fields, -1);
         return &instance;
     }
 };
@@ -1234,9 +2320,49 @@ struct ContributionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssiiii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 4, 1 };
-        static DB2Meta instance(2, 6, 0x8EDF6090, types, arraySizes, 3);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 4, true },
+        };
+        static DB2Meta instance(2, 7, 0x37C49135, fields, 3);
+        return &instance;
+    }
+};
+
+struct ContributionStyleMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 7, 0x799AE511, fields, -1);
+        return &instance;
+    }
+};
+
+struct ContributionStyleContainerMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 5, true },
+        };
+        static DB2Meta instance(-1, 1, 0x55DAA69B, fields, -1);
         return &instance;
     }
 };
@@ -1245,9 +2371,18 @@ struct ConversationLineMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiihhbbb";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0x032B137B, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 8, 0x227B5003, fields, -1);
         return &instance;
     }
 };
@@ -1256,9 +2391,21 @@ struct CreatureMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssssiiifbbbb";
-        static uint8 const arraySizes[12] = { 1, 1, 1, 1, 3, 1, 4, 4, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 12, 0xCFB508A9, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 4, true },
+            { FT_FLOAT, 4, true },
+            { FT_INT, 3, true },
+        };
+        static DB2Meta instance(-1, 11, 0x0D492BF3, fields, -1);
         return &instance;
     }
 };
@@ -1267,9 +2414,17 @@ struct CreatureDifficultyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbbbi";
-        static uint8 const arraySizes[6] = { 7, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x4291EEC6, types, arraySizes, 5);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 7, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 7, 0xD344A642, fields, 6);
         return &instance;
     }
 };
@@ -1278,9 +2433,12 @@ struct CreatureDispXUiCameraMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ih";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x6E0E7C15, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xD3D075FD, fields, -1);
         return &instance;
     }
 };
@@ -1289,9 +2447,35 @@ struct CreatureDisplayInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifhhbbbiibhfibhihhbifii";
-        static uint8 const arraySizes[23] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3 };
-        static DB2Meta instance(0, 23, 0x406268DF, types, arraySizes, -1);
+        static DB2MetaField const fields[25] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 3, true },
+        };
+        static DB2Meta instance(0, 25, 0x613413D1, fields, -1);
         return &instance;
     }
 };
@@ -1300,9 +2484,25 @@ struct CreatureDisplayInfoCondMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "liiibbiiiiiiiii";
-        static uint8 const arraySizes[15] = { 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1 };
-        static DB2Meta instance(-1, 15, 0x26CD44AB, types, arraySizes, 14);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_LONG, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 2, true },
+            { FT_INT, 2, true },
+            { FT_INT, 2, true },
+            { FT_INT, 3, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 15, 0x596B4605, fields, 14);
         return &instance;
     }
 };
@@ -1311,9 +2511,14 @@ struct CreatureDisplayInfoEvtMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x3FEF69BB, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x16C6EC13, fields, 3);
         return &instance;
     }
 };
@@ -1322,9 +2527,37 @@ struct CreatureDisplayInfoExtraMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibbbbbbbbbb";
-        static uint8 const arraySizes[12] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1 };
-        static DB2Meta instance(-1, 12, 0x6DF98EF6, types, arraySizes, -1);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 3, false },
+        };
+        static DB2Meta instance(-1, 12, 0x89E31B13, fields, -1);
+        return &instance;
+    }
+};
+
+struct CreatureDisplayInfoGeosetDataMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x13350FA0, fields, 2);
         return &instance;
     }
 };
@@ -1333,9 +2566,16 @@ struct CreatureDisplayInfoTrnMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifiiii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x8E687740, types, arraySizes, 5);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 6, 0xC3E28858, fields, 5);
         return &instance;
     }
 };
@@ -1344,9 +2584,19 @@ struct CreatureFamilyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sffihhbbb";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 2, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0xE2DC5126, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 2, true },
+        };
+        static DB2Meta instance(-1, 9, 0x9D14B492, fields, -1);
         return &instance;
     }
 };
@@ -1355,9 +2605,19 @@ struct CreatureImmunitiesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibbbbbiii";
-        static uint8 const arraySizes[9] = { 2, 1, 1, 1, 1, 1, 1, 8, 16 };
-        static DB2Meta instance(-1, 9, 0x2D20050B, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 2, true },
+            { FT_INT, 9, false },
+            { FT_INT, 16, false },
+        };
+        static DB2Meta instance(-1, 9, 0x36D9340F, fields, -1);
         return &instance;
     }
 };
@@ -1366,9 +2626,38 @@ struct CreatureModelDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffffffffffffffiiiiiiiiii";
-        static uint8 const arraySizes[28] = { 1, 1, 1, 1, 1, 1, 1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 28, 0x983BD312, types, arraySizes, -1);
+        static DB2MetaField const fields[28] =
+        {
+            { FT_FLOAT, 6, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 28, 0xF61D550A, fields, -1);
         return &instance;
     }
 };
@@ -1377,9 +2666,11 @@ struct CreatureMovementInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "f";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x39F710E3, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x31BE6397, fields, -1);
         return &instance;
     }
 };
@@ -1388,9 +2679,47 @@ struct CreatureSoundDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffbiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii";
-        static uint8 const arraySizes[37] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 4 };
-        static DB2Meta instance(-1, 37, 0x7C3C39B9, types, arraySizes, -1);
+        static DB2MetaField const fields[37] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 5, false },
+            { FT_INT, 4, false },
+        };
+        static DB2Meta instance(-1, 37, 0xA58BDB91, fields, -1);
         return &instance;
     }
 };
@@ -1399,9 +2728,12 @@ struct CreatureTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x7BA9D2F8, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x218D575A, fields, -1);
         return &instance;
     }
 };
@@ -1410,9 +2742,30 @@ struct CreatureXContributionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(0, 3, 0x3448DF58, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 3, 0x2DC69C04, fields, 2);
+        return &instance;
+    }
+};
+
+struct CreatureXDisplayInfoMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x44D147A6, fields, 4);
         return &instance;
     }
 };
@@ -1421,9 +2774,21 @@ struct CriteriaMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiihhbbbbb";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 11, 0xA87A5BB9, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 11, 0x754DDF45, fields, -1);
         return &instance;
     }
 };
@@ -1432,9 +2797,17 @@ struct CriteriaTreeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihbiii";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x0A1B99C2, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 7, 0xC926CF94, fields, -1);
         return &instance;
     }
 };
@@ -1443,9 +2816,12 @@ struct CriteriaTreeXEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hi";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x929D9B0C, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x80C700F5, fields, 1);
         return &instance;
     }
 };
@@ -1454,9 +2830,33 @@ struct CurrencyCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xC3735D76, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x0DB1F53C, fields, -1);
+        return &instance;
+    }
+};
+
+struct CurrencyContainerMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[8] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 8, 0xAC6030BF, fields, 7);
         return &instance;
     }
 };
@@ -1465,9 +2865,21 @@ struct CurrencyTypesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssiiibbbii";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x6CC25CBF, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 11, 0x998F0AAA, fields, -1);
         return &instance;
     }
 };
@@ -1476,9 +2888,12 @@ struct CurveMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x17EA5154, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x4E6F1184, fields, -1);
         return &instance;
     }
 };
@@ -1487,9 +2902,13 @@ struct CurvePointMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fhb";
-        static uint8 const arraySizes[3] = { 2, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xF36752EB, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xFA003217, fields, -1);
         return &instance;
     }
 };
@@ -1498,9 +2917,14 @@ struct DeathThudLookupsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xD469085C, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x3BF7542C, fields, -1);
         return &instance;
     }
 };
@@ -1509,9 +2933,28 @@ struct DecalPropertiesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiffffffffbbiiiii";
-        static uint8 const arraySizes[17] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(0, 17, 0xDD48C72A, types, arraySizes, -1);
+        static DB2MetaField const fields[18] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(0, 18, 0xB11F3B40, fields, -1);
         return &instance;
     }
 };
@@ -1520,9 +2963,12 @@ struct DeclinedWordMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "si";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(1, 2, 0x3FF5EC3E, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(1, 2, 0x10D7C6A6, fields, -1);
         return &instance;
     }
 };
@@ -1531,9 +2977,13 @@ struct DeclinedWordCasesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x821A20A9, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x3E19B9C5, fields, 2);
         return &instance;
     }
 };
@@ -1542,9 +2992,32 @@ struct DestructibleModelDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhhhbbbbbbbbbbbbbbbbb";
-        static uint8 const arraySizes[22] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 22, 0x1092C9AF, types, arraySizes, -1);
+        static DB2MetaField const fields[22] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 22, 0xF245BA93, fields, -1);
         return &instance;
     }
 };
@@ -1553,9 +3026,12 @@ struct DeviceBlacklistMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xD956413D, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x2A350905, fields, -1);
         return &instance;
     }
 };
@@ -1564,9 +3040,13 @@ struct DeviceDefaultSettingsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x90CFEC8C, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x2AB8A38C, fields, -1);
         return &instance;
     }
 };
@@ -1575,9 +3055,23 @@ struct DifficultyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shhhbbbbbbbbb";
-        static uint8 const arraySizes[13] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 13, 0x92302BB8, types, arraySizes, -1);
+        static DB2MetaField const fields[13] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 13, 0x29FC158C, fields, -1);
         return &instance;
     }
 };
@@ -1586,9 +3080,24 @@ struct DissolveEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffffbbiiii";
-        static uint8 const arraySizes[14] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 14, 0x566413E7, types, arraySizes, -1);
+        static DB2MetaField const fields[14] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 14, 0x77C510EC, fields, -1);
         return &instance;
     }
 };
@@ -1597,9 +3106,17 @@ struct DriverBlacklistMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iihbbbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x1466ACAD, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0x88C28C05, fields, -1);
         return &instance;
     }
 };
@@ -1608,130 +3125,218 @@ struct DungeonEncounterMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihbbbiii";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(6, 9, 0xB04A2596, types, arraySizes, 2);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(1, 9, 0x6E5C2332, fields, 2);
         return &instance;
     }
 };
 
-struct DungeonMapMeta
+struct DurabilityCostsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffhhbbbi";
-        static uint8 const arraySizes[8] = { 2, 2, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 8, 0xB5A245F4, types, arraySizes, 2);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 21, false },
+            { FT_SHORT, 8, false },
+        };
+        static DB2Meta instance(-1, 2, 0xBB493F52, fields, -1);
         return &instance;
     }
 };
 
-struct DungeonMapChunkMeta
+struct DurabilityQualityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fihhh";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x7927A3A7, types, arraySizes, 2);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xCFF4EEC9, fields, -1);
         return &instance;
     }
 };
 
-struct DurabilityCostsMeta
+struct EdgeGlowEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 21, 8 };
-        static DB2Meta instance(-1, 2, 0x8447966A, types, arraySizes, -1);
+        static DB2MetaField const fields[13] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 13, 0xCBCC7336, fields, -1);
         return &instance;
     }
 };
 
-struct DurabilityQualityMeta
+struct EmotesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "f";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x6F64793D, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_LONG, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 9, 0xA909E182, fields, -1);
         return &instance;
     }
 };
 
-struct EdgeGlowEffectMeta
+struct EmotesTextMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffffffbii";
-        static uint8 const arraySizes[13] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 13, 0x083BF2C4, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xE255C6B0, fields, -1);
         return &instance;
     }
 };
 
-struct EmotesMeta
+struct EmotesTextDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "lsiihbiii";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0x14467F27, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x460E8F09, fields, 2);
         return &instance;
     }
 };
 
-struct EmotesTextMeta
+struct EmotesTextSoundMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xE85AFA10, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x3A15105C, fields, 4);
         return &instance;
     }
 };
 
-struct EmotesTextDataMeta
+struct EnvironmentalDamageMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x0E19BCF1, types, arraySizes, 2);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x448422B4, fields, -1);
         return &instance;
     }
 };
 
-struct EmotesTextSoundMeta
+struct ExhaustionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbbih";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x6DFAF9BC, types, arraySizes, 4);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(2, 8, 0xF0F48BB5, fields, -1);
         return &instance;
     }
 };
 
-struct EnvironmentalDamageMeta
+struct ExpectedStatMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xC4552C14, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 11, 0xF0E61875, fields, 10);
         return &instance;
     }
 };
 
-struct ExhaustionMeta
+struct ExpectedStatModMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssiffffi";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 8, 0xE6E16045, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 9, 0xEA56E599, fields, -1);
         return &instance;
     }
 };
@@ -1740,9 +3345,26 @@ struct FactionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "lssiifihhhhhbbbb";
-        static uint8 const arraySizes[16] = { 4, 1, 1, 1, 4, 2, 4, 1, 4, 4, 1, 1, 2, 1, 1, 1 };
-        static DB2Meta instance(3, 16, 0x6BFE8737, types, arraySizes, -1);
+        static DB2MetaField const fields[16] =
+        {
+            { FT_LONG, 4, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 4, true },
+            { FT_SHORT, 4, false },
+            { FT_INT, 4, true },
+            { FT_INT, 4, true },
+            { FT_FLOAT, 2, true },
+            { FT_BYTE, 2, false },
+        };
+        static DB2Meta instance(3, 16, 0x86FE2D69, fields, -1);
         return &instance;
     }
 };
@@ -1751,9 +3373,16 @@ struct FactionGroupMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssibii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(2, 6, 0x7A7F9A51, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(2, 6, 0xB9B4369B, fields, -1);
         return &instance;
     }
 };
@@ -1762,9 +3391,17 @@ struct FactionTemplateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhhbbb";
-        static uint8 const arraySizes[7] = { 1, 1, 4, 4, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x6F1D2135, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 4, false },
+            { FT_SHORT, 4, false },
+        };
+        static DB2Meta instance(-1, 7, 0xD7143473, fields, -1);
         return &instance;
     }
 };
@@ -1773,9 +3410,13 @@ struct FootprintTexturesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xFD6FF285, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xF82F1359, fields, -1);
         return &instance;
     }
 };
@@ -1784,9 +3425,14 @@ struct FootstepTerrainLookupMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x454895AE, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xC70AACC6, fields, -1);
         return &instance;
     }
 };
@@ -1795,9 +3441,13 @@ struct FriendshipRepReactionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x9C412E5B, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x8B096063, fields, 1);
         return &instance;
     }
 };
@@ -1806,9 +3456,14 @@ struct FriendshipReputationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(3, 4, 0x406EE0AB, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(1, 4, 0xECCE459C, fields, -1);
         return &instance;
     }
 };
@@ -1817,9 +3472,38 @@ struct FullScreenEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffffffffffffffffffffffiiii";
-        static uint8 const arraySizes[27] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 27, 0x5CBF1D1B, types, arraySizes, -1);
+        static DB2MetaField const fields[28] =
+        {
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 28, 0x9854A6AC, fields, -1);
         return &instance;
     }
 };
@@ -1828,9 +3512,13 @@ struct GMSurveyAnswersMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x422747F6, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xDE59EC07, fields, 2);
         return &instance;
     }
 };
@@ -1839,9 +3527,11 @@ struct GMSurveyCurrentSurveyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "b";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x617205BF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0xAD0D7453, fields, -1);
         return &instance;
     }
 };
@@ -1850,9 +3540,11 @@ struct GMSurveyQuestionsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x9D852FDC, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x12B097E1, fields, -1);
         return &instance;
     }
 };
@@ -1861,9 +3553,11 @@ struct GMSurveySurveysMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "b";
-        static uint8 const arraySizes[1] = { 15 };
-        static DB2Meta instance(-1, 1, 0x17FEF812, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 15, false },
+        };
+        static DB2Meta instance(-1, 1, 0x24BB51BE, fields, -1);
         return &instance;
     }
 };
@@ -1872,9 +3566,12 @@ struct GameObjectArtKitMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 3 };
-        static DB2Meta instance(-1, 2, 0x6F65BC41, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 3, true },
+        };
+        static DB2Meta instance(-1, 2, 0xECF16719, fields, -1);
         return &instance;
     }
 };
@@ -1883,9 +3580,14 @@ struct GameObjectDiffAnimMapMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x89A617CF, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xDB3508F3, fields, 3);
         return &instance;
     }
 };
@@ -1894,9 +3596,15 @@ struct GameObjectDisplayInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifffh";
-        static uint8 const arraySizes[5] = { 1, 6, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x9F2098D1, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 6, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x7A816799, fields, -1);
         return &instance;
     }
 };
@@ -1905,9 +3613,13 @@ struct GameObjectDisplayInfoXSoundKitMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x4BBA66F2, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x456E4627, fields, 2);
         return &instance;
     }
 };
@@ -1916,9 +3628,22 @@ struct GameObjectsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sfffihhhhbbi";
-        static uint8 const arraySizes[12] = { 1, 3, 4, 1, 8, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(11, 12, 0x597E8643, types, arraySizes, 5);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 4, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 8, true },
+        };
+        static DB2Meta instance(3, 12, 0x0995B956, fields, 4);
         return &instance;
     }
 };
@@ -1927,9 +3652,14 @@ struct GameTipsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shhb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x547E3F0F, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x768EB877, fields, -1);
         return &instance;
     }
 };
@@ -1938,9 +3668,18 @@ struct GarrAbilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssihhbbi";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 8, 0x5DF95DBD, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(2, 8, 0x8256E595, fields, -1);
         return &instance;
     }
 };
@@ -1949,9 +3688,11 @@ struct GarrAbilityCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x9F2C8370, fields, -1);
         return &instance;
     }
 };
@@ -1960,9 +3701,22 @@ struct GarrAbilityEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffihbbbbbbi";
-        static uint8 const arraySizes[12] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(11, 12, 0xE6A6CB99, types, arraySizes, 4);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(0, 12, 0x682EE0E1, fields, 1);
         return &instance;
     }
 };
@@ -1971,9 +3725,34 @@ struct GarrBuildingMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssssiiihhhhhhhhbbbbbbiii";
-        static uint8 const arraySizes[24] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 24, 0x200F9858, types, arraySizes, -1);
+        static DB2MetaField const fields[24] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 24, 0x158D48D4, fields, -1);
         return &instance;
     }
 };
@@ -1982,9 +3761,15 @@ struct GarrBuildingDoodadSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbbbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x2A861C7F, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x9A6DE309, fields, -1);
         return &instance;
     }
 };
@@ -1993,9 +3778,15 @@ struct GarrBuildingPlotInstMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fhhbi";
-        static uint8 const arraySizes[5] = { 2, 1, 1, 1, 1 };
-        static DB2Meta instance(4, 5, 0xF45B6227, types, arraySizes, 3);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(1, 5, 0xFB61E627, fields, 2);
         return &instance;
     }
 };
@@ -2004,9 +3795,18 @@ struct GarrClassSpecMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssshhbbi";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 8, 0x194CD478, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(3, 8, 0x644E1AC4, fields, -1);
         return &instance;
     }
 };
@@ -2015,9 +3815,16 @@ struct GarrClassSpecPlayerCondMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sibiii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x06936172, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0x561DEBFE, fields, -1);
         return &instance;
     }
 };
@@ -2026,9 +3833,17 @@ struct GarrEncounterMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siffiii";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(5, 7, 0x63EF121A, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(1, 7, 0xD193D559, fields, -1);
         return &instance;
     }
 };
@@ -2037,9 +3852,13 @@ struct GarrEncounterSetXEncounterMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(0, 3, 0x3AA64423, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(0, 3, 0xCA7143E7, fields, 2);
         return &instance;
     }
 };
@@ -2048,9 +3867,13 @@ struct GarrEncounterXMechanicMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x97080E17, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x0960A66B, fields, 2);
         return &instance;
     }
 };
@@ -2059,9 +3882,14 @@ struct GarrFollItemSetMemberMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbh";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xCA1C4CBF, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x9166B16F, fields, 3);
         return &instance;
     }
 };
@@ -2070,9 +3898,14 @@ struct GarrFollSupportSpellMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xB7DBA2D1, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xDB563FC8, fields, 3);
         return &instance;
     }
 };
@@ -2081,9 +3914,42 @@ struct GarrFollowerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sssiiiiiihhhhhhbbbbbbbbbbbbbbbbi";
-        static uint8 const arraySizes[32] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(31, 32, 0xAAB75E04, types, arraySizes, -1);
+        static DB2MetaField const fields[32] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(3, 32, 0x7C5C19F1, fields, -1);
         return &instance;
     }
 };
@@ -2092,9 +3958,14 @@ struct GarrFollowerLevelXPMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x1ED485E2, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xABD178B2, fields, -1);
         return &instance;
     }
 };
@@ -2103,9 +3974,17 @@ struct GarrFollowerQualityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbbbbi";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0xAFF4CF7E, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0xCAE87042, fields, -1);
         return &instance;
     }
 };
@@ -2114,9 +3993,12 @@ struct GarrFollowerSetXFollowerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xDB0E0A17, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x621C60FF, fields, 1);
         return &instance;
     }
 };
@@ -2125,9 +4007,17 @@ struct GarrFollowerTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbbbbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0xD676FBC0, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0xB4B34EF0, fields, -1);
         return &instance;
     }
 };
@@ -2136,9 +4026,16 @@ struct GarrFollowerUICreatureMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifbbbh";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x7E275E96, types, arraySizes, 5);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0x93A1FAA6, fields, 5);
         return &instance;
     }
 };
@@ -2147,9 +4044,14 @@ struct GarrFollowerXAbilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x996447F1, types, arraySizes, 2);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x590C69F7, fields, 3);
         return &instance;
     }
 };
@@ -2158,9 +4060,15 @@ struct GarrItemLevelUpgradeDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(0, 5, 0x069F44E5, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 5, 0x6B8723A1, fields, -1);
         return &instance;
     }
 };
@@ -2169,9 +4077,13 @@ struct GarrMechanicMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xAB49DA61, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xA83BF5A9, fields, -1);
         return &instance;
     }
 };
@@ -2180,9 +4092,13 @@ struct GarrMechanicSetXMechanicMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(1, 3, 0x59514F7B, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(0, 3, 0xFC7F16A3, fields, 2);
         return &instance;
     }
 };
@@ -2191,9 +4107,15 @@ struct GarrMechanicTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssibi";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(4, 5, 0x6FEA569F, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(2, 5, 0x05F19FE7, fields, -1);
         return &instance;
     }
 };
@@ -2202,9 +4124,39 @@ struct GarrMissionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sssiiffhhhbbbbbbbbbiiiiiiiiii";
-        static uint8 const arraySizes[29] = { 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(19, 29, 0xDDD70490, types, arraySizes, 28);
+        static DB2MetaField const fields[29] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 2, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(5, 29, 0x00777205, fields, 28);
         return &instance;
     }
 };
@@ -2213,9 +4165,12 @@ struct GarrMissionTextureMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fh";
-        static uint8 const arraySizes[2] = { 2, 1 };
-        static DB2Meta instance(-1, 2, 0x3071301C, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x0D378464, fields, -1);
         return &instance;
     }
 };
@@ -2224,9 +4179,13 @@ struct GarrMissionTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xA289655E, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x3FC87149, fields, -1);
         return &instance;
     }
 };
@@ -2235,9 +4194,15 @@ struct GarrMissionXEncounterMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "biiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(1, 5, 0xBCB016C6, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 5, 0x539B5B1B, fields, 4);
         return &instance;
     }
 };
@@ -2246,9 +4211,13 @@ struct GarrMissionXFollowerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x1EBABA29, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xFB9C7E3D, fields, 2);
         return &instance;
     }
 };
@@ -2257,9 +4226,15 @@ struct GarrMssnBonusAbilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fihbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x35F5AE92, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x91DD4CE6, fields, -1);
         return &instance;
     }
 };
@@ -2268,9 +4243,17 @@ struct GarrPlotMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siibbbi";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 2 };
-        static DB2Meta instance(-1, 7, 0xE12049E0, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 2, false },
+        };
+        static DB2Meta instance(-1, 7, 0x3897880E, fields, -1);
         return &instance;
     }
 };
@@ -2279,9 +4262,12 @@ struct GarrPlotBuildingMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x3F77A6FA, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x1ECDCE0A, fields, -1);
         return &instance;
     }
 };
@@ -2290,9 +4276,12 @@ struct GarrPlotInstanceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xB708BB37, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x1FD77CCF, fields, -1);
         return &instance;
     }
 };
@@ -2301,9 +4290,12 @@ struct GarrPlotUICategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xA94645EE, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x867482E6, fields, -1);
         return &instance;
     }
 };
@@ -2312,9 +4304,19 @@ struct GarrSiteLevelMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fhhhhhbbb";
-        static uint8 const arraySizes[9] = { 2, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0xD3979C38, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 9, 0x4D823E68, fields, -1);
         return &instance;
     }
 };
@@ -2323,9 +4325,14 @@ struct GarrSiteLevelPlotInstMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fhbb";
-        static uint8 const arraySizes[4] = { 2, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xC4E74201, types, arraySizes, 1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xA3DF8AD1, fields, 1);
         return &instance;
     }
 };
@@ -2334,9 +4341,17 @@ struct GarrSpecializationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssifbbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 2, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x797A0F2F, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 2, true },
+        };
+        static DB2Meta instance(-1, 7, 0x8400A7E7, fields, -1);
         return &instance;
     }
 };
@@ -2345,9 +4360,11 @@ struct GarrStringMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xE1C08C0C, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF404C7D8, fields, -1);
         return &instance;
     }
 };
@@ -2356,9 +4373,30 @@ struct GarrTalentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssiibbbiiiiiiiiiiiii";
-        static uint8 const arraySizes[20] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 20, 0x53D5FD16, types, arraySizes, 8);
+        static DB2MetaField const fields[20] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(2, 20, 0x96BE787E, fields, 3);
         return &instance;
     }
 };
@@ -2367,9 +4405,17 @@ struct GarrTalentTreeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x676CBC04, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0x9A3BC97D, fields, -1);
         return &instance;
     }
 };
@@ -2378,9 +4424,15 @@ struct GarrTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 2 };
-        static DB2Meta instance(-1, 5, 0x7C52F3B7, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(-1, 5, 0xCCA7D7B5, fields, -1);
         return &instance;
     }
 };
@@ -2389,9 +4441,16 @@ struct GarrUiAnimClassInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbbiii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0xDBF4633D, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0xF6444415, fields, -1);
         return &instance;
     }
 };
@@ -2400,9 +4459,23 @@ struct GarrUiAnimRaceInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffffffffb";
-        static uint8 const arraySizes[13] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 13, 0x44B9C1DE, types, arraySizes, -1);
+        static DB2MetaField const fields[13] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 13, 0x62B1D302, fields, -1);
         return &instance;
     }
 };
@@ -2411,9 +4484,13 @@ struct GemPropertiesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x84558CAB, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xBCE902DB, fields, -1);
         return &instance;
     }
 };
@@ -2422,9 +4499,13 @@ struct GlobalStringsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x2CA3EA1E, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x843675FD, fields, -1);
         return &instance;
     }
 };
@@ -2433,9 +4514,12 @@ struct GlyphBindableSpellMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ih";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xEA228DFA, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x03429C72, fields, 1);
         return &instance;
     }
 };
@@ -2444,9 +4528,11 @@ struct GlyphExclusiveCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xFE598FCD, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x59622339, fields, -1);
         return &instance;
     }
 };
@@ -2455,9 +4541,14 @@ struct GlyphPropertiesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xD0046829, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x7C1C2F11, fields, -1);
         return &instance;
     }
 };
@@ -2466,9 +4557,12 @@ struct GlyphRequiredSpecMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xDD6481CE, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x70D4ECC6, fields, 1);
         return &instance;
     }
 };
@@ -2477,9 +4571,14 @@ struct GroundEffectDoodadMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffbi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x0376B2D6, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xAB0C6E12, fields, -1);
         return &instance;
     }
 };
@@ -2488,9 +4587,14 @@ struct GroundEffectTextureMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbi";
-        static uint8 const arraySizes[4] = { 4, 4, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x84549F0A, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 4, false },
+            { FT_BYTE, 4, true },
+        };
+        static DB2Meta instance(-1, 4, 0xCCBD52E8, fields, -1);
         return &instance;
     }
 };
@@ -2499,9 +4603,24 @@ struct GroupFinderActivityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sshhhbbbbbbbbb";
-        static uint8 const arraySizes[14] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 14, 0x3EF2F3BD, types, arraySizes, -1);
+        static DB2MetaField const fields[14] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 14, 0xEC40E4B1, fields, -1);
         return &instance;
     }
 };
@@ -2510,9 +4629,12 @@ struct GroupFinderActivityGrpMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xC9458196, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x1EC8D046, fields, -1);
         return &instance;
     }
 };
@@ -2521,9 +4643,13 @@ struct GroupFinderCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x9213552F, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xBFF47DC0, fields, -1);
         return &instance;
     }
 };
@@ -2532,9 +4658,13 @@ struct GuildColorBackgroundMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xCC0CEFF1, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xCC5FFB4D, fields, -1);
         return &instance;
     }
 };
@@ -2543,9 +4673,13 @@ struct GuildColorBorderMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xCC0CEFF1, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xCC5FFB4D, fields, -1);
         return &instance;
     }
 };
@@ -2554,9 +4688,13 @@ struct GuildColorEmblemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xCC0CEFF1, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xCC5FFB4D, fields, -1);
         return &instance;
     }
 };
@@ -2565,9 +4703,11 @@ struct GuildPerkSpellsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xC15D6E9F, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xC9961BEB, fields, -1);
         return &instance;
     }
 };
@@ -2576,9 +4716,20 @@ struct HeirloomMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siiiiihbbi";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 3, 3, 1, 1, 1 };
-        static DB2Meta instance(9, 10, 0x36887C6F, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 3, true },
+            { FT_SHORT, 3, false },
+        };
+        static DB2Meta instance(1, 10, 0xB5925FE9, fields, -1);
         return &instance;
     }
 };
@@ -2587,9 +4738,13 @@ struct HelmetAnimScalingMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xB9EC1058, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xC43CA2FC, fields, 2);
         return &instance;
     }
 };
@@ -2598,9 +4753,11 @@ struct HelmetGeosetVisDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 9 };
-        static DB2Meta instance(-1, 1, 0x3B38D999, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 9, true },
+        };
+        static DB2Meta instance(-1, 1, 0x2E7C7FED, fields, -1);
         return &instance;
     }
 };
@@ -2609,9 +4766,15 @@ struct HighlightColorMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiibb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x5FADC5D3, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xDC14DB43, fields, -1);
         return &instance;
     }
 };
@@ -2620,9 +4783,11 @@ struct HolidayDescriptionsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x92A95550, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xE70F298C, fields, -1);
         return &instance;
     }
 };
@@ -2631,9 +4796,11 @@ struct HolidayNamesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF2917D77, fields, -1);
         return &instance;
     }
 };
@@ -2642,20 +4809,37 @@ struct HolidaysMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iihhbbbbbiii";
-        static uint8 const arraySizes[12] = { 1, 16, 10, 1, 1, 10, 1, 1, 1, 1, 1, 3 };
-        static DB2Meta instance(0, 12, 0x7C3E60FC, types, arraySizes, -1);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 10, false },
+            { FT_INT, 16, false },
+            { FT_BYTE, 10, false },
+            { FT_INT, 3, true },
+        };
+        static DB2Meta instance(0, 12, 0xF6DA3904, fields, -1);
         return &instance;
     }
 };
 
-struct HotfixMeta
+struct HotfixesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x3747930B, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xB67D3F47, fields, -1);
         return &instance;
     }
 };
@@ -2664,9 +4848,14 @@ struct ImportPriceArmorMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffff";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x1F7A850F, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xC4C8D847, fields, -1);
         return &instance;
     }
 };
@@ -2675,9 +4864,11 @@ struct ImportPriceQualityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "f";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x6F64793D, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xCFF4EEC9, fields, -1);
         return &instance;
     }
 };
@@ -2686,9 +4877,11 @@ struct ImportPriceShieldMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "f";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x6F64793D, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xCFF4EEC9, fields, -1);
         return &instance;
     }
 };
@@ -2697,9 +4890,11 @@ struct ImportPriceWeaponMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "f";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x6F64793D, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xCFF4EEC9, fields, -1);
         return &instance;
     }
 };
@@ -2708,9 +4903,20 @@ struct InvasionClientDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sfiiiiiiii";
-        static uint8 const arraySizes[10] = { 1, 2, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(2, 10, 0x4C93379F, types, arraySizes, 9);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 2, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(2, 10, 0x04FC0B4F, fields, 9);
         return &instance;
     }
 };
@@ -2719,9 +4925,18 @@ struct ItemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibbbbbbb";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0x0DFCC83D, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 8, 0xF9600007, fields, -1);
         return &instance;
     }
 };
@@ -2730,9 +4945,14 @@ struct ItemAppearanceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiib";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x06D35A59, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x422F764D, fields, -1);
         return &instance;
     }
 };
@@ -2741,9 +4961,12 @@ struct ItemAppearanceXUiCameraMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x67747E15, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xCD3677FD, fields, -1);
         return &instance;
     }
 };
@@ -2752,9 +4975,11 @@ struct ItemArmorQualityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fh";
-        static uint8 const arraySizes[2] = { 7, 1 };
-        static DB2Meta instance(-1, 2, 0x85642CC0, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_FLOAT, 7, true },
+        };
+        static DB2Meta instance(-1, 1, 0x0B17E016, fields, -1);
         return &instance;
     }
 };
@@ -2763,9 +4988,12 @@ struct ItemArmorShieldMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fh";
-        static uint8 const arraySizes[2] = { 7, 1 };
-        static DB2Meta instance(-1, 2, 0xC2186F95, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_FLOAT, 7, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xC88C8C8D, fields, -1);
         return &instance;
     }
 };
@@ -2774,9 +5002,15 @@ struct ItemArmorTotalMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffh";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x45C396DD, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0xC4CD0FD9, fields, -1);
         return &instance;
     }
 };
@@ -2785,9 +5019,11 @@ struct ItemBagFamilyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x9F2C8370, fields, -1);
         return &instance;
     }
 };
@@ -2796,9 +5032,14 @@ struct ItemBonusMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbb";
-        static uint8 const arraySizes[4] = { 3, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xE12FB1A0, types, arraySizes, 1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 3, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xB96C1748, fields, 1);
         return &instance;
     }
 };
@@ -2807,9 +5048,12 @@ struct ItemBonusListLevelDeltaMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hi";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(1, 2, 0xDFBF5AC9, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(1, 2, 0x819C0CC1, fields, -1);
         return &instance;
     }
 };
@@ -2818,9 +5062,15 @@ struct ItemBonusTreeNodeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhbh";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x84FE93B7, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x1DDAA885, fields, 4);
         return &instance;
     }
 };
@@ -2829,9 +5079,13 @@ struct ItemChildEquipmentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xB6940674, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x48E64550, fields, 2);
         return &instance;
     }
 };
@@ -2840,9 +5094,14 @@ struct ItemClassMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sfbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xA1E4663C, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xB6C67A3D, fields, -1);
         return &instance;
     }
 };
@@ -2851,9 +5110,16 @@ struct ItemContextPickerEntryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbiiii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x4A6DF90B, types, arraySizes, 5);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0x1596EAF3, fields, 5);
         return &instance;
     }
 };
@@ -2862,9 +5128,11 @@ struct ItemCurrencyCostMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xE2FF5688, types, arraySizes, 0);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xDAC6A93C, fields, 0);
         return &instance;
     }
 };
@@ -2873,9 +5141,12 @@ struct ItemDamageAmmoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fh";
-        static uint8 const arraySizes[2] = { 7, 1 };
-        static DB2Meta instance(-1, 2, 0xC2186F95, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 7, true },
+        };
+        static DB2Meta instance(-1, 2, 0x1309BE8D, fields, -1);
         return &instance;
     }
 };
@@ -2884,9 +5155,12 @@ struct ItemDamageOneHandMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fh";
-        static uint8 const arraySizes[2] = { 7, 1 };
-        static DB2Meta instance(-1, 2, 0xC2186F95, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 7, true },
+        };
+        static DB2Meta instance(-1, 2, 0x1309BE8D, fields, -1);
         return &instance;
     }
 };
@@ -2895,9 +5169,12 @@ struct ItemDamageOneHandCasterMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fh";
-        static uint8 const arraySizes[2] = { 7, 1 };
-        static DB2Meta instance(-1, 2, 0xC2186F95, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 7, true },
+        };
+        static DB2Meta instance(-1, 2, 0x1309BE8D, fields, -1);
         return &instance;
     }
 };
@@ -2906,9 +5183,12 @@ struct ItemDamageTwoHandMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fh";
-        static uint8 const arraySizes[2] = { 7, 1 };
-        static DB2Meta instance(-1, 2, 0xC2186F95, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 7, true },
+        };
+        static DB2Meta instance(-1, 2, 0x1309BE8D, fields, -1);
         return &instance;
     }
 };
@@ -2917,9 +5197,12 @@ struct ItemDamageTwoHandCasterMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fh";
-        static uint8 const arraySizes[2] = { 7, 1 };
-        static DB2Meta instance(-1, 2, 0xC2186F95, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 7, true },
+        };
+        static DB2Meta instance(-1, 2, 0x1309BE8D, fields, -1);
         return &instance;
     }
 };
@@ -2928,9 +5211,17 @@ struct ItemDisenchantLootMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhbbbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0xC0D926CC, types, arraySizes, 6);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0x146B9F40, fields, 6);
         return &instance;
     }
 };
@@ -2939,9 +5230,25 @@ struct ItemDisplayInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiiiiiiiiiiii";
-        static uint8 const arraySizes[15] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 4, 4, 2 };
-        static DB2Meta instance(-1, 15, 0x99606089, types, arraySizes, -1);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 2, false },
+            { FT_INT, 2, true },
+            { FT_INT, 6, true },
+            { FT_INT, 6, true },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(-1, 15, 0x089404D9, fields, -1);
         return &instance;
     }
 };
@@ -2950,9 +5257,13 @@ struct ItemDisplayInfoMaterialResMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xDEE4ED7B, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x936E6A99, fields, 2);
         return &instance;
     }
 };
@@ -2961,9 +5272,12 @@ struct ItemDisplayXUiCameraMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ih";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xE57737B2, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x3E999EAA, fields, -1);
         return &instance;
     }
 };
@@ -2972,9 +5286,19 @@ struct ItemEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiihhhbbi";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0xA390FA40, types, arraySizes, 8);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 9, 0x46818AA6, fields, 8);
         return &instance;
     }
 };
@@ -2983,9 +5307,20 @@ struct ItemExtendedCostMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iihhhbbbbb";
-        static uint8 const arraySizes[10] = { 5, 5, 5, 1, 5, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0xC31F4DEF, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 5, true },
+            { FT_SHORT, 5, false },
+            { FT_SHORT, 5, false },
+            { FT_INT, 5, false },
+        };
+        static DB2Meta instance(-1, 10, 0x2AC5BE11, fields, -1);
         return &instance;
     }
 };
@@ -2994,9 +5329,11 @@ struct ItemGroupSoundsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 4 };
-        static DB2Meta instance(-1, 1, 0xDC2EE466, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 4, false },
+        };
+        static DB2Meta instance(-1, 1, 0x909375D2, fields, -1);
         return &instance;
     }
 };
@@ -3005,9 +5342,12 @@ struct ItemLevelSelectorMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x8143060E, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x3112276E, fields, -1);
         return &instance;
     }
 };
@@ -3016,9 +5356,13 @@ struct ItemLevelSelectorQualityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xB7174A51, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xC40169D5, fields, 2);
         return &instance;
     }
 };
@@ -3027,9 +5371,12 @@ struct ItemLevelSelectorQualitySetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x20055BA8, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x89657A48, fields, -1);
         return &instance;
     }
 };
@@ -3038,9 +5385,13 @@ struct ItemLimitCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xB6BB188D, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xE068171C, fields, -1);
         return &instance;
     }
 };
@@ -3049,9 +5400,13 @@ struct ItemLimitCategoryConditionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xDE8EAD49, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x7F847085, fields, 2);
         return &instance;
     }
 };
@@ -3060,9 +5415,16 @@ struct ItemModifiedAppearanceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibhbb";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(1, 6, 0xE64FD18B, types, arraySizes, 0);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(0, 6, 0x9C32B7FF, fields, 1);
         return &instance;
     }
 };
@@ -3071,9 +5433,15 @@ struct ItemModifiedAppearanceExtraMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x77212236, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x7E2FD302, fields, -1);
         return &instance;
     }
 };
@@ -3082,9 +5450,12 @@ struct ItemNameDescriptionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "si";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x16760BD4, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xBBF04CCC, fields, -1);
         return &instance;
     }
 };
@@ -3093,9 +5464,11 @@ struct ItemPetFoodMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xE4923C1F, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xD6AB60EB, fields, -1);
         return &instance;
     }
 };
@@ -3104,9 +5477,13 @@ struct ItemPriceBaseMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x4BD234D7, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xC90092C7, fields, -1);
         return &instance;
     }
 };
@@ -3115,9 +5492,12 @@ struct ItemRandomPropertiesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sh";
-        static uint8 const arraySizes[2] = { 1, 5 };
-        static DB2Meta instance(-1, 2, 0xB67375F8, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 5, false },
+        };
+        static DB2Meta instance(-1, 2, 0xBDA8BFCD, fields, -1);
         return &instance;
     }
 };
@@ -3126,9 +5506,13 @@ struct ItemRandomSuffixMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shh";
-        static uint8 const arraySizes[3] = { 1, 5, 5 };
-        static DB2Meta instance(-1, 3, 0x95CAB825, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 5, false },
+            { FT_SHORT, 5, false },
+        };
+        static DB2Meta instance(-1, 3, 0xABCC4871, fields, -1);
         return &instance;
     }
 };
@@ -3137,9 +5521,14 @@ struct ItemRangedDisplayInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x687A28D1, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xA6B99F0D, fields, -1);
         return &instance;
     }
 };
@@ -3148,9 +5537,24 @@ struct ItemSearchNameMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "lsiihbbbhbihhi";
-        static uint8 const arraySizes[14] = { 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(2, 14, 0x2D4B72FA, types, arraySizes, -1);
+        static DB2MetaField const fields[14] =
+        {
+            { FT_LONG, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 4, true },
+        };
+        static DB2Meta instance(2, 14, 0xF0940AFC, fields, -1);
         return &instance;
     }
 };
@@ -3159,9 +5563,15 @@ struct ItemSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihii";
-        static uint8 const arraySizes[5] = { 1, 17, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x847FF58A, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 17, false },
+        };
+        static DB2Meta instance(-1, 5, 0xB02A9041, fields, -1);
         return &instance;
     }
 };
@@ -3170,9 +5580,14 @@ struct ItemSetSpellMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbh";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xF65D0AF8, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xD6AEEA60, fields, 3);
         return &instance;
     }
 };
@@ -3181,9 +5596,74 @@ struct ItemSparseMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "lsssssiffiiiiiiiffififhhhhhhhhhhhhhhhhhhhhhhhbbbbbbbbbbbbbbbbbbb";
-        static uint8 const arraySizes[64] = { 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 64, 0x4007DE16, types, arraySizes, -1);
+        static DB2MetaField const fields[64] =
+        {
+            { FT_LONG, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 10, true },
+            { FT_INT, 10, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 4, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 3, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 10, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 64, 0xF9021F01, fields, -1);
         return &instance;
     }
 };
@@ -3192,9 +5672,16 @@ struct ItemSpecMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbbbb";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0xB17B7986, types, arraySizes, 3);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0xEB138F8E, fields, 2);
         return &instance;
     }
 };
@@ -3203,9 +5690,12 @@ struct ItemSpecOverrideMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hi";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xE499CD2A, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xB235D33A, fields, 1);
         return &instance;
     }
 };
@@ -3214,9 +5704,20 @@ struct ItemSubClassMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sshbbbbbbb";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0xDAD92A67, types, arraySizes, 3);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 10, 0xC7178B11, fields, 2);
         return &instance;
     }
 };
@@ -3225,9 +5726,13 @@ struct ItemSubClassMaskMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sib";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xFC1DA850, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x146E3154, fields, -1);
         return &instance;
     }
 };
@@ -3236,9 +5741,15 @@ struct ItemUpgradeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihhbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x8F3A4137, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x706FA369, fields, -1);
         return &instance;
     }
 };
@@ -3247,9 +5758,11 @@ struct ItemVisualsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 5 };
-        static DB2Meta instance(-1, 1, 0x485EA782, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 5, true },
+        };
+        static DB2Meta instance(-1, 1, 0x4025FA36, fields, -1);
         return &instance;
     }
 };
@@ -3258,9 +5771,12 @@ struct ItemXBonusTreeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hi";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x87C4B605, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x57244BD5, fields, 1);
         return &instance;
     }
 };
@@ -3269,9 +5785,20 @@ struct JournalEncounterMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssfhhhhbbii";
-        static uint8 const arraySizes[11] = { 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 11, 0x2935A0FD, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 2, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 10, 0x5E057FAD, fields, -1);
         return &instance;
     }
 };
@@ -3280,9 +5807,18 @@ struct JournalEncounterCreatureMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssiiihbi";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 8, 0x22C79A42, types, arraySizes, 5);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(2, 8, 0x71CE658D, fields, 3);
         return &instance;
     }
 };
@@ -3291,9 +5827,16 @@ struct JournalEncounterItemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbbbi";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(5, 6, 0x39230FF9, types, arraySizes, 1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(0, 6, 0x5FD94071, fields, 1);
         return &instance;
     }
 };
@@ -3302,9 +5845,25 @@ struct JournalEncounterSectionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssiiiihhhhhhbbb";
-        static uint8 const arraySizes[15] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 15, 0x13E56B12, types, arraySizes, -1);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 15, 0x582FB4F6, fields, -1);
         return &instance;
     }
 };
@@ -3313,9 +5872,12 @@ struct JournalEncounterXDifficultyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x321FD542, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x436676BA, fields, 1);
         return &instance;
     }
 };
@@ -3324,9 +5886,15 @@ struct JournalEncounterXMapLocMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbiiii";
-        static uint8 const arraySizes[6] = { 2, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x430540E4, types, arraySizes, 5);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0xBCE56697, fields, 4);
         return &instance;
     }
 };
@@ -3335,9 +5903,21 @@ struct JournalInstanceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssiiiihhbbi";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(10, 11, 0x1691CC3D, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(2, 11, 0xBB10478F, fields, -1);
         return &instance;
     }
 };
@@ -3346,9 +5926,12 @@ struct JournalItemXDifficultyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x60D9CA15, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xF938F4BD, fields, 1);
         return &instance;
     }
 };
@@ -3357,9 +5940,12 @@ struct JournalSectionXDifficultyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x243822A7, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xE02C355F, fields, 1);
         return &instance;
     }
 };
@@ -3368,9 +5954,11 @@ struct JournalTierMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x8046B23F, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xE0D727CB, fields, -1);
         return &instance;
     }
 };
@@ -3379,9 +5967,12 @@ struct JournalTierXInstanceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x9C4F4D2A, types, arraySizes, 0);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xD584CE6A, fields, 0);
         return &instance;
     }
 };
@@ -3390,9 +5981,11 @@ struct KeychainMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "b";
-        static uint8 const arraySizes[1] = { 32 };
-        static DB2Meta instance(-1, 1, 0x5B214E82, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 32, false },
+        };
+        static DB2Meta instance(-1, 1, 0x67DDA82E, fields, -1);
         return &instance;
     }
 };
@@ -3401,9 +5994,14 @@ struct KeystoneAffixMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x1BCB46AA, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(2, 4, 0x60D97B7F, fields, -1);
         return &instance;
     }
 };
@@ -3412,9 +6010,17 @@ struct LFGDungeonExpansionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbbiih";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0xB41DEA61, types, arraySizes, 6);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0x6754EDAB, fields, 6);
         return &instance;
     }
 };
@@ -3423,9 +6029,14 @@ struct LFGDungeonGroupMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x724D58E7, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x4E84BE76, fields, -1);
         return &instance;
     }
 };
@@ -3434,9 +6045,43 @@ struct LFGDungeonsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssifhhhhhhhhhbbbbbbbbbbbbbbbbbiii";
-        static uint8 const arraySizes[33] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 33, 0xF02081A0, types, arraySizes, -1);
+        static DB2MetaField const fields[33] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(-1, 33, 0xD9B678AD, fields, -1);
         return &instance;
     }
 };
@@ -3445,9 +6090,13 @@ struct LFGRoleRequirementMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bih";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x7EB8A359, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x35B34A59, fields, 2);
         return &instance;
     }
 };
@@ -3456,9 +6105,12 @@ struct LanguageWordsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xC15912BD, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xFBB33D15, fields, -1);
         return &instance;
     }
 };
@@ -3467,9 +6119,12 @@ struct LanguagesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "si";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(1, 2, 0x6FA5D0C4, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(1, 2, 0xAA508D47, fields, -1);
         return &instance;
     }
 };
@@ -3478,9 +6133,13 @@ struct LfgDungeonsGroupingMapMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x8CB35C50, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xD50B89E4, fields, 2);
         return &instance;
     }
 };
@@ -3489,9 +6148,15 @@ struct LightMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffhh";
-        static uint8 const arraySizes[5] = { 3, 1, 1, 1, 8 };
-        static DB2Meta instance(-1, 5, 0x25025A13, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 8, false },
+        };
+        static DB2Meta instance(-1, 5, 0x04052B1F, fields, -1);
         return &instance;
     }
 };
@@ -3500,9 +6165,46 @@ struct LightDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiiiiiiiiiiiiiiifffffffffiiiiiihh";
-        static uint8 const arraySizes[35] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 35, 0x2D2BA7FA, types, arraySizes, 34);
+        static DB2MetaField const fields[36] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 36, 0xE7CA3F85, fields, 0);
         return &instance;
     }
 };
@@ -3511,9 +6213,22 @@ struct LightParamsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffhbbbi";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(10, 11, 0xF67DE2AF, types, arraySizes, -1);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(1, 12, 0xA08FAABA, fields, -1);
         return &instance;
     }
 };
@@ -3522,9 +6237,60 @@ struct LightSkyboxMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siib";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x8817C02C, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x757E9EB6, fields, -1);
+        return &instance;
+    }
+};
+
+struct LightningMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[34] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_INT, 3, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 34, 0x8B6D192C, fields, -1);
         return &instance;
     }
 };
@@ -3533,9 +6299,12 @@ struct LiquidMaterialMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x62BE0340, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x6A7287A2, fields, -1);
         return &instance;
     }
 };
@@ -3544,9 +6313,15 @@ struct LiquidObjectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffhbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xACC168A6, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x7AF380AA, fields, -1);
         return &instance;
     }
 };
@@ -3555,9 +6330,31 @@ struct LiquidTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssifffffifihhbbbbbi";
-        static uint8 const arraySizes[19] = { 1, 6, 1, 1, 1, 1, 1, 1, 2, 18, 4, 1, 1, 1, 1, 1, 1, 6, 1 };
-        static DB2Meta instance(-1, 19, 0x3313BBF3, types, arraySizes, -1);
+        static DB2MetaField const fields[21] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 6, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 6, false },
+            { FT_INT, 2, true },
+            { FT_FLOAT, 18, true },
+            { FT_INT, 4, false },
+            { FT_FLOAT, 4, true },
+        };
+        static DB2Meta instance(-1, 21, 0x29F8C65E, fields, -1);
         return &instance;
     }
 };
@@ -3566,9 +6363,15 @@ struct LoadingScreenTaxiSplinesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffhhb";
-        static uint8 const arraySizes[5] = { 10, 10, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x4D6292C3, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 10, true },
+            { FT_FLOAT, 10, true },
+        };
+        static DB2Meta instance(-1, 5, 0xCDF5DDF1, fields, -1);
         return &instance;
     }
 };
@@ -3577,9 +6380,13 @@ struct LoadingScreensMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x99C0EB78, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xA2488A1C, fields, -1);
         return &instance;
     }
 };
@@ -3588,9 +6395,14 @@ struct LocaleMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x592AE13B, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x65638FD5, fields, -1);
         return &instance;
     }
 };
@@ -3599,9 +6411,12 @@ struct LocationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ff";
-        static uint8 const arraySizes[2] = { 3, 3 };
-        static DB2Meta instance(-1, 2, 0xBBC1BE7A, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+        };
+        static DB2Meta instance(-1, 2, 0x71BD1122, fields, -1);
         return &instance;
     }
 };
@@ -3610,9 +6425,14 @@ struct LockMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbb";
-        static uint8 const arraySizes[4] = { 8, 8, 8, 8 };
-        static DB2Meta instance(-1, 4, 0xDAC7F42F, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 8, true },
+            { FT_SHORT, 8, false },
+            { FT_BYTE, 8, false },
+            { FT_BYTE, 8, false },
+        };
+        static DB2Meta instance(-1, 4, 0x156C0BD7, fields, -1);
         return &instance;
     }
 };
@@ -3621,9 +6441,15 @@ struct LockTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssssi";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(4, 5, 0xCD5E1D2F, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(4, 5, 0x3F736720, fields, -1);
         return &instance;
     }
 };
@@ -3632,9 +6458,28 @@ struct LookAtControllerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffhhhhbbbbbiiiii";
-        static uint8 const arraySizes[18] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 18, 0x543C0D56, types, arraySizes, -1);
+        static DB2MetaField const fields[18] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 18, 0x2E077E56, fields, -1);
         return &instance;
     }
 };
@@ -3643,9 +6488,11 @@ struct MailTemplateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x25C8D6CC, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xC6E0D9B5, fields, -1);
         return &instance;
     }
 };
@@ -3654,9 +6501,20 @@ struct ManagedWorldStateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiiiiiii";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(9, 10, 0xBA06FC33, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 4, true },
+        };
+        static DB2Meta instance(0, 10, 0x043BFC8F, fields, -1);
         return &instance;
     }
 };
@@ -3665,9 +6523,14 @@ struct ManagedWorldStateBuffMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x6D201DC7, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x049B986F, fields, 3);
         return &instance;
     }
 };
@@ -3676,9 +6539,13 @@ struct ManagedWorldStateInputMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x0FC1A9B0, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x21237CDC, fields, -1);
         return &instance;
     }
 };
@@ -3687,9 +6554,11 @@ struct ManifestInterfaceActionIconMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(0, 1, 0x6A529F37, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(0, 1, 0xB5EE0DCB, fields, -1);
         return &instance;
     }
 };
@@ -3698,9 +6567,12 @@ struct ManifestInterfaceDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ss";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x9E5F4C99, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x03E4C021, fields, -1);
         return &instance;
     }
 };
@@ -3709,9 +6581,11 @@ struct ManifestInterfaceItemIconMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(0, 1, 0x6A529F37, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(0, 1, 0xB5EE0DCB, fields, -1);
         return &instance;
     }
 };
@@ -3720,9 +6594,11 @@ struct ManifestInterfaceTOCDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x6F7D397D, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xD00DAF09, fields, -1);
         return &instance;
     }
 };
@@ -3731,9 +6607,11 @@ struct ManifestMP3Meta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(0, 1, 0x6A529F37, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(0, 1, 0xB5EE0DCB, fields, -1);
         return &instance;
     }
 };
@@ -3742,9 +6620,32 @@ struct MapMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssssssiffhhhhhhhbbbbb";
-        static uint8 const arraySizes[21] = { 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 21, 0xF568DF12, types, arraySizes, -1);
+        static DB2MetaField const fields[22] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 2, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(-1, 22, 0x503A3E58, fields, -1);
         return &instance;
     }
 };
@@ -3753,9 +6654,13 @@ struct MapCelestialBodyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hih";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xBDE1C11C, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x14543648, fields, 2);
         return &instance;
     }
 };
@@ -3764,9 +6669,15 @@ struct MapChallengeModeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihhb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 3, 1 };
-        static DB2Meta instance(1, 5, 0xC5261662, types, arraySizes, 2);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 3, true },
+        };
+        static DB2Meta instance(1, 5, 0x50F3ABC2, fields, 2);
         return &instance;
     }
 };
@@ -3775,9 +6686,20 @@ struct MapDifficultyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbbbbbbih";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0x2B3B759E, types, arraySizes, 8);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 10, 0xF876E8BA, fields, 9);
         return &instance;
     }
 };
@@ -3786,9 +6708,14 @@ struct MapDifficultyXConditionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x5F5D7102, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x8DBA5D16, fields, 3);
         return &instance;
     }
 };
@@ -3797,9 +6724,15 @@ struct MapLoadingScreenMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffiii";
-        static uint8 const arraySizes[5] = { 2, 2, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xBBE57FE4, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 2, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0xC4CFD9A8, fields, 4);
         return &instance;
     }
 };
@@ -3808,9 +6741,17 @@ struct MarketingPromotionsXLocaleMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siiiibb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x80362F57, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 7, 0xC04E61FB, fields, -1);
         return &instance;
     }
 };
@@ -3819,9 +6760,14 @@ struct MaterialMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "biii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x0BC8C134, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x370D43B4, fields, -1);
         return &instance;
     }
 };
@@ -3830,9 +6776,13 @@ struct MinorTalentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xAAEF0DF8, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x09F57B9C, fields, 2);
         return &instance;
     }
 };
@@ -3841,9 +6791,22 @@ struct MissileTargetingMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffffffffiii";
-        static uint8 const arraySizes[12] = { 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2 };
-        static DB2Meta instance(-1, 12, 0x2305491E, types, arraySizes, -1);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 2, true },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(-1, 12, 0xF695DDBA, fields, -1);
         return &instance;
     }
 };
@@ -3852,9 +6815,13 @@ struct ModelAnimCloakDampeningMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x839B4263, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xAA668B4F, fields, 2);
         return &instance;
     }
 };
@@ -3863,9 +6830,14 @@ struct ModelFileDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(1, 3, 0xA395EB50, types, arraySizes, 2);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(0, 4, 0x9C9B4543, fields, 3);
         return &instance;
     }
 };
@@ -3874,9 +6846,12 @@ struct ModelRibbonQualityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bi";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x38F764D9, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xA26E8DD1, fields, 1);
         return &instance;
     }
 };
@@ -3885,9 +6860,17 @@ struct ModifierTreeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiibbbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x7718AFC2, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 7, 0x643002AE, fields, -1);
         return &instance;
     }
 };
@@ -3896,9 +6879,21 @@ struct MountMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sssifhhbiii";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(8, 11, 0x4D812F19, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(3, 11, 0x629E87E2, fields, -1);
         return &instance;
     }
 };
@@ -3907,9 +6902,18 @@ struct MountCapabilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iihhhbii";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(6, 8, 0xB0D11D52, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(0, 8, 0xD8A906D6, fields, -1);
         return &instance;
     }
 };
@@ -3918,9 +6922,13 @@ struct MountTypeXCapabilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xA34A8445, types, arraySizes, 0);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x613701E9, fields, 0);
         return &instance;
     }
 };
@@ -3929,9 +6937,13 @@ struct MountXDisplayMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xD59B9FE4, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x2D4F3D78, fields, 2);
         return &instance;
     }
 };
@@ -3940,9 +6952,14 @@ struct MovieMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xF3E9AE3B, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x4848C4FB, fields, -1);
         return &instance;
     }
 };
@@ -3951,9 +6968,11 @@ struct MovieFileDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "h";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xAA16D59F, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0xB24F82EB, fields, -1);
         return &instance;
     }
 };
@@ -3962,9 +6981,69 @@ struct MovieVariationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iih";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x3BFD250E, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xAEA671AA, fields, 2);
+        return &instance;
+    }
+};
+
+struct MultiStatePropertiesMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[11] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 11, 0x50BB5EDC, fields, 10);
+        return &instance;
+    }
+};
+
+struct MultiTransitionPropertiesMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x5720F452, fields, -1);
+        return &instance;
+    }
+};
+
+struct MythicPlusSeasonRewardLevelsMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xAD6A6D9F, fields, 3);
         return &instance;
     }
 };
@@ -3973,9 +7052,13 @@ struct NPCModelItemSlotDisplayInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x11D16204, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xB8EC2628, fields, 2);
         return &instance;
     }
 };
@@ -3984,9 +7067,11 @@ struct NPCSoundsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 4 };
-        static DB2Meta instance(-1, 1, 0x672E1A6B, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 4, false },
+        };
+        static DB2Meta instance(-1, 1, 0x5EF56D1F, fields, -1);
         return &instance;
     }
 };
@@ -3995,9 +7080,13 @@ struct NameGenMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x2EF936CD, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xB0EBC6C9, fields, -1);
         return &instance;
     }
 };
@@ -4006,9 +7095,12 @@ struct NamesProfanityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xDFB56E0E, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xCD33D2BE, fields, -1);
         return &instance;
     }
 };
@@ -4017,9 +7109,11 @@ struct NamesReservedMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xE4923C1F, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xECCAE96B, fields, -1);
         return &instance;
     }
 };
@@ -4028,9 +7122,28 @@ struct NamesReservedLocaleMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xC1403093, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x5AAEEDD3, fields, -1);
+        return &instance;
+    }
+};
+
+struct NumTalentsAtLevelMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 4, 0xDE3268EF, fields, -1);
         return &instance;
     }
 };
@@ -4039,9 +7152,18 @@ struct ObjectEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fhbbbbii";
-        static uint8 const arraySizes[8] = { 3, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0x6A0CF743, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 8, 0x48D89FCF, fields, -1);
         return &instance;
     }
 };
@@ -4050,9 +7172,14 @@ struct ObjectEffectModifierMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbbb";
-        static uint8 const arraySizes[4] = { 4, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xA482B053, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_FLOAT, 4, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x68D120B3, fields, -1);
         return &instance;
     }
 };
@@ -4061,9 +7188,66 @@ struct ObjectEffectPackageElemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x8CF043E5, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x3B8C53F9, fields, -1);
+        return &instance;
+    }
+};
+
+struct OccluderMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[9] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(0, 9, 0xFEDCAAB3, fields, -1);
+        return &instance;
+    }
+};
+
+struct OccluderLocationMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[4] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(2, 4, 0x95F8BBE4, fields, -1);
+        return &instance;
+    }
+};
+
+struct OccluderNodeMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 4, 0x19A34490, fields, -1);
         return &instance;
     }
 };
@@ -4072,9 +7256,16 @@ struct OutlineEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fiiiii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x466B2BC4, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 2, false },
+        };
+        static DB2Meta instance(-1, 6, 0xECA16738, fields, -1);
         return &instance;
     }
 };
@@ -4083,9 +7274,13 @@ struct OverrideSpellDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iib";
-        static uint8 const arraySizes[3] = { 10, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x9417628C, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 10, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xCEE01938, fields, -1);
         return &instance;
     }
 };
@@ -4094,9 +7289,12 @@ struct PVPBracketTypesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bi";
-        static uint8 const arraySizes[2] = { 1, 4 };
-        static DB2Meta instance(-1, 2, 0x7C55E5BB, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_INT, 4, false },
+        };
+        static DB2Meta instance(-1, 2, 0x54CF87FB, fields, -1);
         return &instance;
     }
 };
@@ -4105,9 +7303,14 @@ struct PVPDifficultyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbbh";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x970B5E15, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x794DB95D, fields, 3);
         return &instance;
     }
 };
@@ -4116,9 +7319,12 @@ struct PVPItemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ib";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xBD449801, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x0CD750C1, fields, -1);
         return &instance;
     }
 };
@@ -4127,9 +7333,11 @@ struct PageTextMaterialMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF6F6B04B, fields, -1);
         return &instance;
     }
 };
@@ -4138,9 +7346,13 @@ struct PaperDollItemFrameMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x66B0597E, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xB85F646E, fields, -1);
         return &instance;
     }
 };
@@ -4149,9 +7361,13 @@ struct ParagonReputationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xD7712F98, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xF9AC6E2E, fields, 0);
         return &instance;
     }
 };
@@ -4160,9 +7376,30 @@ struct ParticleColorMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 3, 3, 3 };
-        static DB2Meta instance(-1, 3, 0x1576D1E1, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 3, true },
+            { FT_INT, 3, true },
+            { FT_INT, 3, true },
+        };
+        static DB2Meta instance(-1, 3, 0xB44B4D4D, fields, -1);
+        return &instance;
+    }
+};
+
+struct ParticulateSoundMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0xF60E0955, fields, 0);
         return &instance;
     }
 };
@@ -4171,9 +7408,17 @@ struct PathMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbbbbbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x5017579F, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0x3551690B, fields, -1);
         return &instance;
     }
 };
@@ -4182,9 +7427,14 @@ struct PathNodeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iihh";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(0, 4, 0x76615830, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 4, 0x19A34490, fields, -1);
         return &instance;
     }
 };
@@ -4193,9 +7443,15 @@ struct PathNodePropertyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhbii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(3, 5, 0x92C03009, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 5, 0x578DA815, fields, -1);
         return &instance;
     }
 };
@@ -4204,9 +7460,14 @@ struct PathPropertyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(3, 4, 0x3D29C266, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 4, 0x3B269A90, fields, -1);
         return &instance;
     }
 };
@@ -4215,9 +7476,11 @@ struct PhaseMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "h";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x0043219C, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0x60D39728, fields, -1);
         return &instance;
     }
 };
@@ -4226,9 +7489,23 @@ struct PhaseShiftZoneSoundsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhhhbbbbiiii";
-        static uint8 const arraySizes[13] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 13, 0x85ACB830, types, arraySizes, -1);
+        static DB2MetaField const fields[13] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 13, 0x7CA0A010, fields, -1);
         return &instance;
     }
 };
@@ -4237,9 +7514,12 @@ struct PhaseXPhaseGroupMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x66517AF6, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xF00195AE, fields, 1);
         return &instance;
     }
 };
@@ -4248,9 +7528,91 @@ struct PlayerConditionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "lsibhhibbibbihbibbbbiiiiibihbbbiiiihibbbbbbbhiiihhbbbbbiihhhibhhhiiihiibhbbihiiii";
-        static uint8 const arraySizes[81] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 3, 3, 4, 4, 4, 4, 4, 4, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 2 };
-        static DB2Meta instance(2, 81, 0x5B3DA113, types, arraySizes, -1);
+        static DB2MetaField const fields[81] =
+        {
+            { FT_LONG, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 4, false },
+            { FT_SHORT, 4, false },
+            { FT_SHORT, 4, false },
+            { FT_INT, 3, false },
+            { FT_BYTE, 3, false },
+            { FT_SHORT, 4, false },
+            { FT_SHORT, 4, false },
+            { FT_SHORT, 4, false },
+            { FT_INT, 4, true },
+            { FT_INT, 4, true },
+            { FT_INT, 4, false },
+            { FT_SHORT, 2, false },
+            { FT_INT, 2, false },
+            { FT_INT, 4, true },
+            { FT_BYTE, 4, false },
+            { FT_SHORT, 4, false },
+            { FT_SHORT, 4, false },
+            { FT_BYTE, 4, false },
+            { FT_BYTE, 4, false },
+            { FT_INT, 4, false },
+            { FT_INT, 4, false },
+            { FT_INT, 4, false },
+            { FT_INT, 6, false },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(2, 81, 0xF28CBD18, fields, -1);
         return &instance;
     }
 };
@@ -4259,9 +7621,14 @@ struct PositionerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fhbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xE830F1B1, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x533B33CB, fields, -1);
         return &instance;
     }
 };
@@ -4270,9 +7637,18 @@ struct PositionerStateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbiiiiii";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0x6C975DF4, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 8, 0x9E87B63A, fields, -1);
         return &instance;
     }
 };
@@ -4281,9 +7657,21 @@ struct PositionerStateEntryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffhhhhbbbbi";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 11, 0x667ED965, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 11, 0xBA9A19C4, fields, -1);
         return &instance;
     }
 };
@@ -4292,9 +7680,15 @@ struct PowerDisplayMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbbbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xFD152E5B, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xEB89C62F, fields, -1);
         return &instance;
     }
 };
@@ -4303,9 +7697,22 @@ struct PowerTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssffhhhbbbbb";
-        static uint8 const arraySizes[12] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 12, 0x0C3844E1, types, arraySizes, -1);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 12, 0x6D438CB5, fields, -1);
         return &instance;
     }
 };
@@ -4314,64 +7721,113 @@ struct PrestigeLevelInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sibb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xA7B2D559, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x31BD813F, fields, -1);
         return &instance;
     }
 };
 
-struct PvpRewardMeta
+struct PvpScalingEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x72F4C016, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xAF88F6DB, fields, 1);
         return &instance;
     }
 };
 
-struct PvpScalingEffectMeta
+struct PvpScalingEffectTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x52121A41, types, arraySizes, 1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF6F6B04B, fields, -1);
         return &instance;
     }
 };
 
-struct PvpScalingEffectTypeMeta
+struct PvpTalentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(1, 9, 0x340BABA3, fields, 2);
         return &instance;
     }
 };
 
-struct PvpTalentMeta
+struct PvpTalentCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siiiiiiiii";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x6EB51740, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0xBB4B5731, fields, -1);
         return &instance;
     }
 };
 
-struct PvpTalentUnlockMeta
+struct PvpTalentSlotUnlockMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x465C83BC, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x572DDD84, fields, -1);
+        return &instance;
+    }
+};
+
+struct PvpTierMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[8] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 8, 0x689983C8, fields, 5);
         return &instance;
     }
 };
@@ -4380,9 +7836,11 @@ struct QuestFactionRewardMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "h";
-        static uint8 const arraySizes[1] = { 10 };
-        static DB2Meta instance(-1, 1, 0xB0E02541, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_SHORT, 10, true },
+        };
+        static DB2Meta instance(-1, 1, 0x504FAFB5, fields, -1);
         return &instance;
     }
 };
@@ -4391,9 +7849,16 @@ struct QuestFeedbackEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbbbb";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x89D55A27, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0x58E79FBF, fields, -1);
         return &instance;
     }
 };
@@ -4402,9 +7867,14 @@ struct QuestInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x4F45F445, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xDDB38B83, fields, -1);
         return &instance;
     }
 };
@@ -4413,9 +7883,13 @@ struct QuestLineMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x8046B23F, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xC4BD3235, fields, -1);
         return &instance;
     }
 };
@@ -4424,9 +7898,13 @@ struct QuestLineXQuestMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x8FA4A9C7, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x57EF18BF, fields, 0);
         return &instance;
     }
 };
@@ -4435,9 +7913,11 @@ struct QuestMoneyRewardMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 10 };
-        static DB2Meta instance(-1, 1, 0x86397302, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 10, false },
+        };
+        static DB2Meta instance(-1, 1, 0x7E00C5B6, fields, -1);
         return &instance;
     }
 };
@@ -4446,9 +7926,18 @@ struct QuestObjectiveMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siibbbbh";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0xDD995180, types, arraySizes, 7);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 8, 0x37353FB6, fields, 7);
         return &instance;
     }
 };
@@ -4457,9 +7946,17 @@ struct QuestPOIBlobMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihhbbiii";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(0, 8, 0xEC15976E, types, arraySizes, 2);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(0, 7, 0x5DF4B040, fields, 1);
         return &instance;
     }
 };
@@ -4468,9 +7965,14 @@ struct QuestPOIPointMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihhi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(0, 4, 0x8CF2B119, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 4, 0x18D6E719, fields, 3);
         return &instance;
     }
 };
@@ -4479,9 +7981,14 @@ struct QuestPackageItemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xCF9401CF, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xEB0764D1, fields, -1);
         return &instance;
     }
 };
@@ -4490,9 +7997,12 @@ struct QuestSortMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xAD7072C6, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x2F5E2228, fields, -1);
         return &instance;
     }
 };
@@ -4501,9 +8011,11 @@ struct QuestV2Meta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "h";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x70495C9B, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 1, 0x638D02EF, fields, -1);
         return &instance;
     }
 };
@@ -4512,9 +8024,34 @@ struct QuestV2CliTaskMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "lssihhhhhhbbbbbbbbbbiiii";
-        static uint8 const arraySizes[24] = { 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(20, 24, 0x3F026A14, types, arraySizes, -1);
+        static DB2MetaField const fields[24] =
+        {
+            { FT_LONG, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 3, false },
+        };
+        static DB2Meta instance(3, 24, 0xC0387D4E, fields, -1);
         return &instance;
     }
 };
@@ -4523,9 +8060,12 @@ struct QuestXGroupActivityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x06CC45D3, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xAA88A593, fields, -1);
         return &instance;
     }
 };
@@ -4534,9 +8074,11 @@ struct QuestXPMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "h";
-        static uint8 const arraySizes[1] = { 10 };
-        static DB2Meta instance(-1, 1, 0xCB76B4C0, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_SHORT, 10, false },
+        };
+        static DB2Meta instance(-1, 1, 0xC33E0774, fields, -1);
         return &instance;
     }
 };
@@ -4545,9 +8087,14 @@ struct RandPropPointsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 5, 5, 5 };
-        static DB2Meta instance(-1, 3, 0x4E2C0BCC, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 5, false },
+            { FT_INT, 5, false },
+            { FT_INT, 5, false },
+        };
+        static DB2Meta instance(-1, 4, 0x7741F65C, fields, -1);
         return &instance;
     }
 };
@@ -4556,9 +8103,13 @@ struct RelicSlotTierRequirementMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x129FCC09, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x22CDBDE9, fields, -1);
         return &instance;
     }
 };
@@ -4567,9 +8118,15 @@ struct RelicTalentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x7A5963FD, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x8BEAE937, fields, -1);
         return &instance;
     }
 };
@@ -4578,9 +8135,16 @@ struct ResearchBranchMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihbii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x58A3876E, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 6, 0xA6CB64A5, fields, -1);
         return &instance;
     }
 };
@@ -4589,9 +8153,13 @@ struct ResearchFieldMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(2, 3, 0x85868B9F, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(1, 3, 0xD7448990, fields, -1);
         return &instance;
     }
 };
@@ -4600,9 +8168,19 @@ struct ResearchProjectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssihbbiii";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(6, 9, 0xB1CAB80B, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(2, 9, 0x4A748755, fields, -1);
         return &instance;
     }
 };
@@ -4611,9 +8189,14 @@ struct ResearchSiteMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x25F7DCC7, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x14F7693B, fields, -1);
         return &instance;
     }
 };
@@ -4622,9 +8205,13 @@ struct ResistancesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xA3EAE5AE, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xF7F049B5, fields, -1);
         return &instance;
     }
 };
@@ -4633,9 +8220,16 @@ struct RewardPackMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifbbii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0xDB6CC0AB, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0xB0527FA7, fields, -1);
         return &instance;
     }
 };
@@ -4644,9 +8238,13 @@ struct RewardPackXCurrencyTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x217E6712, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xEA88FC16, fields, 2);
         return &instance;
     }
 };
@@ -4655,9 +8253,13 @@ struct RewardPackXItemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x74F6B9BD, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x277E8179, fields, 2);
         return &instance;
     }
 };
@@ -4666,9 +8268,15 @@ struct RibbonQualityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffbi";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xC75DAEA8, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xBB0CC4F4, fields, -1);
         return &instance;
     }
 };
@@ -4677,9 +8285,12 @@ struct RulesetItemUpgradeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ih";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xFB641AE0, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xA03B4C48, fields, -1);
         return &instance;
     }
 };
@@ -4688,20 +8299,11 @@ struct SDReplacementModelMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xE1F906C2, types, arraySizes, -1);
-        return &instance;
-    }
-};
-
-struct SandboxScalingMeta
-{
-    static DB2Meta const* Instance()
-    {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x5200B7F5, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xD9C05976, fields, -1);
         return &instance;
     }
 };
@@ -4710,9 +8312,13 @@ struct ScalingStatDistributionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xDED48286, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x34B9A97A, fields, -1);
         return &instance;
     }
 };
@@ -4721,9 +8327,15 @@ struct ScenarioMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xD052232A, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x0857765A, fields, -1);
         return &instance;
     }
 };
@@ -4732,9 +8344,12 @@ struct ScenarioEventEntryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x02E80455, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x34B30E13, fields, -1);
         return &instance;
     }
 };
@@ -4743,9 +8358,21 @@ struct ScenarioStepMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sshhhbbii";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0x201B0EFC, types, arraySizes, 2);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 11, 0x8FF5E1E6, fields, 2);
         return &instance;
     }
 };
@@ -4754,9 +8381,12 @@ struct SceneScriptMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xC694B81E, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xEF472E96, fields, -1);
         return &instance;
     }
 };
@@ -4765,9 +8395,12 @@ struct SceneScriptGlobalTextMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ss";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xB9F8FDF1, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xDE6E2251, fields, -1);
         return &instance;
     }
 };
@@ -4776,9 +8409,11 @@ struct SceneScriptPackageMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF6F6B04B, fields, -1);
         return &instance;
     }
 };
@@ -4787,9 +8422,14 @@ struct SceneScriptPackageMemberMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x787A715F, types, arraySizes, 0);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x9E18D06F, fields, 0);
         return &instance;
     }
 };
@@ -4798,9 +8438,12 @@ struct SceneScriptTextMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ss";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xB9F8FDF1, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xDE6E2251, fields, -1);
         return &instance;
     }
 };
@@ -4809,9 +8452,15 @@ struct ScheduledIntervalMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x5DD2FF46, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x0C287F7A, fields, -1);
         return &instance;
     }
 };
@@ -4820,9 +8469,18 @@ struct ScheduledWorldStateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiiiii";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0xFCB13A6A, types, arraySizes, 0);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 8, 0xDC45735A, fields, 0);
         return &instance;
     }
 };
@@ -4831,9 +8489,15 @@ struct ScheduledWorldStateGroupMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x21F6EE03, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0xCF71B287, fields, -1);
         return &instance;
     }
 };
@@ -4842,9 +8506,13 @@ struct ScheduledWorldStateXUniqCatMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(0, 3, 0x7EFF57FD, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 3, 0xF512C749, fields, 2);
         return &instance;
     }
 };
@@ -4853,9 +8521,22 @@ struct ScreenEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihhhhbbbiii";
-        static uint8 const arraySizes[12] = { 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 12, 0x4D5B91C5, types, arraySizes, -1);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 4, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 12, 0x7A371491, fields, -1);
         return &instance;
     }
 };
@@ -4864,9 +8545,11 @@ struct ScreenLocationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF6F6B04B, fields, -1);
         return &instance;
     }
 };
@@ -4875,9 +8558,11 @@ struct SeamlessSiteMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xBFE7B9D3, types, arraySizes, 0);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x9E36592F, fields, 0);
         return &instance;
     }
 };
@@ -4886,9 +8571,11 @@ struct ServerMessagesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x1C7A1347, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xCC7971DF, fields, -1);
         return &instance;
     }
 };
@@ -4897,9 +8584,39 @@ struct ShadowyEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iifffffffbbii";
-        static uint8 const arraySizes[13] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 13, 0xE909BB18, types, arraySizes, -1);
+        static DB2MetaField const fields[13] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 13, 0x7292BC4C, fields, -1);
+        return &instance;
+    }
+};
+
+struct SiegeablePropertiesMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x98E42A9F, fields, -1);
         return &instance;
     }
 };
@@ -4908,9 +8625,23 @@ struct SkillLineMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssshbbii";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0x3F7E88AF, types, arraySizes, -1);
+        static DB2MetaField const fields[13] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(5, 13, 0xEC83FE8A, fields, -1);
         return &instance;
     }
 };
@@ -4919,9 +8650,25 @@ struct SkillLineAbilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "liiihhhhhbihbb";
-        static uint8 const arraySizes[14] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(1, 14, 0x97B5A653, types, arraySizes, 4);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_LONG, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(1, 15, 0xA38AD072, fields, 2);
         return &instance;
     }
 };
@@ -4930,9 +8677,17 @@ struct SkillRaceClassInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "lhhhbbi";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x9752C2CE, types, arraySizes, 1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_LONG, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 7, 0x4CFD464E, fields, 1);
         return &instance;
     }
 };
@@ -4941,9 +8696,16 @@ struct SoundAmbienceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "biii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 2 };
-        static DB2Meta instance(-1, 4, 0xB073D4B5, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 2, false },
+            { FT_INT, 2, false },
+            { FT_INT, 2, false },
+        };
+        static DB2Meta instance(-1, 6, 0x625245C7, fields, -1);
         return &instance;
     }
 };
@@ -4952,9 +8714,13 @@ struct SoundAmbienceFlavorMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iih";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x2C58D929, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x41E33D5D, fields, 2);
         return &instance;
     }
 };
@@ -4963,9 +8729,18 @@ struct SoundBusMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbbbbbih";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(6, 8, 0xB2ACDE2A, types, arraySizes, 7);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(0, 8, 0x7CC84C2D, fields, 7);
         return &instance;
     }
 };
@@ -4974,9 +8749,17 @@ struct SoundBusOverrideMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifbbbii";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(0, 7, 0x6D887F48, types, arraySizes, 5);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(0, 7, 0xF321EA82, fields, 1);
         return &instance;
     }
 };
@@ -4985,9 +8768,12 @@ struct SoundEmitterPillPointsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fh";
-        static uint8 const arraySizes[2] = { 3, 1 };
-        static DB2Meta instance(-1, 2, 0x41FCF15B, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xD63C5DE3, fields, 1);
         return &instance;
     }
 };
@@ -4996,9 +8782,22 @@ struct SoundEmittersMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sffhhbbbiiih";
-        static uint8 const arraySizes[12] = { 1, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(8, 12, 0x55A3B17E, types, arraySizes, 11);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(3, 12, 0x1FDCDD5A, fields, 11);
         return &instance;
     }
 };
@@ -5007,9 +8806,17 @@ struct SoundEnvelopeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iihhhbi";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x5B78031C, types, arraySizes, 0);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0xBD6F1248, fields, 0);
         return &instance;
     }
 };
@@ -5018,9 +8825,11 @@ struct SoundFilterMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF6F6B04B, fields, -1);
         return &instance;
     }
 };
@@ -5029,9 +8838,13 @@ struct SoundFilterElemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbb";
-        static uint8 const arraySizes[3] = { 9, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xE17AC589, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_FLOAT, 9, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x84F8D205, fields, 2);
         return &instance;
     }
 };
@@ -5040,9 +8853,26 @@ struct SoundKitMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifffhhbbbfffffhb";
-        static uint8 const arraySizes[16] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(0, 16, 0x0E9CB7AE, types, arraySizes, -1);
+        static DB2MetaField const fields[16] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(0, 16, 0xAF055926, fields, -1);
         return &instance;
     }
 };
@@ -5051,9 +8881,53 @@ struct SoundKitAdvancedMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifffffiifbiiiiiiiiiibffffbhffiiibbiiiiii";
-        static uint8 const arraySizes[40] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(0, 40, 0x73F6F023, types, arraySizes, -1);
+        static DB2MetaField const fields[43] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(0, 43, 0x6EAFA63E, fields, -1);
         return &instance;
     }
 };
@@ -5062,9 +8936,12 @@ struct SoundKitChildMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x2827A3B5, types, arraySizes, 0);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x4215B0DD, fields, 1);
         return &instance;
     }
 };
@@ -5073,9 +8950,14 @@ struct SoundKitEntryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibf";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x6ED6E26F, types, arraySizes, 0);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xCBC66B5F, fields, 0);
         return &instance;
     }
 };
@@ -5084,9 +8966,12 @@ struct SoundKitFallbackMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xB1A5106F, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x53D01CD7, fields, -1);
         return &instance;
     }
 };
@@ -5095,9 +8980,11 @@ struct SoundKitNameMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF6F6B04B, fields, -1);
         return &instance;
     }
 };
@@ -5106,9 +8993,15 @@ struct SoundOverrideMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xFB7643F6, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x4EC15243, fields, -1);
         return &instance;
     }
 };
@@ -5117,9 +9010,33 @@ struct SoundProviderPreferencesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sfffffffffffffffhhhhhbb";
-        static uint8 const arraySizes[23] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 23, 0x85F218A4, types, arraySizes, -1);
+        static DB2MetaField const fields[23] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 23, 0xF0F42A22, fields, -1);
         return &instance;
     }
 };
@@ -5128,9 +9045,14 @@ struct SourceInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbbi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x7C214135, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xA94C7962, fields, 3);
         return &instance;
     }
 };
@@ -5139,9 +9061,25 @@ struct SpamMessagesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x0D4BA7E7, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x1A080193, fields, -1);
+        return &instance;
+    }
+};
+
+struct SpecSetMemberMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xC05B6C73, fields, 1);
         return &instance;
     }
 };
@@ -5150,9 +9088,30 @@ struct SpecializationSpellsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siihbi";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(5, 6, 0xAE3436F3, types, arraySizes, 3);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(1, 6, 0x88A56A2F, fields, 2);
+        return &instance;
+    }
+};
+
+struct SpecializationSpellsDisplayMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 6, false },
+        };
+        static DB2Meta instance(-1, 2, 0xBD5EEC46, fields, 0);
         return &instance;
     }
 };
@@ -5161,9 +9120,13 @@ struct SpellMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssss";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x2273DFFF, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xFFF1DA38, fields, -1);
         return &instance;
     }
 };
@@ -5172,9 +9135,12 @@ struct SpellActionBarPrefMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ih";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x1EF80B2B, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xCF471C9B, fields, -1);
         return &instance;
     }
 };
@@ -5183,9 +9149,18 @@ struct SpellActivationOverlayMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiifibbi";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 4, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0x23568FC7, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_INT, 4, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 8, 0xE72C81EF, fields, -1);
         return &instance;
     }
 };
@@ -5194,9 +9169,18 @@ struct SpellAuraOptionsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiihhbbi";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0xE05BE94F, types, arraySizes, 7);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 2, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 8, 0xCBDA0981, fields, 7);
         return &instance;
     }
 };
@@ -5205,9 +9189,20 @@ struct SpellAuraRestrictionsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiibbbbbi";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x7CDF3311, types, arraySizes, 9);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 10, 0xD7479271, fields, 9);
         return &instance;
     }
 };
@@ -5216,9 +9211,12 @@ struct SpellAuraVisXChrSpecMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xA65B6A4A, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x8F54FD52, fields, 1);
         return &instance;
     }
 };
@@ -5227,9 +9225,14 @@ struct SpellAuraVisibilityMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(2, 4, 0xA549F79C, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 4, 0xB7F28C20, fields, 3);
         return &instance;
     }
 };
@@ -5238,9 +9241,13 @@ struct SpellCastTimesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iih";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x4129C6A4, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xA66E197C, fields, -1);
         return &instance;
     }
 };
@@ -5249,9 +9256,17 @@ struct SpellCastingRequirementsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihhhbbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0xD8B56E5D, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 7, 0xC6D7C649, fields, -1);
         return &instance;
     }
 };
@@ -5260,9 +9275,19 @@ struct SpellCategoriesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhbbbbbi";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0x14E916CC, types, arraySizes, 8);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 9, 0xEF1D2548, fields, 8);
         return &instance;
     }
 };
@@ -5271,9 +9296,16 @@ struct SpellCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sibbbi";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0xEA60E384, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 6, 0x53EB1CD3, fields, -1);
         return &instance;
     }
 };
@@ -5282,9 +9314,70 @@ struct SpellChainEffectsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffiiffffffffffffffffffffffffffffffffffiffffhhhhbbbbbbbbbbii";
-        static uint8 const arraySizes[60] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3 };
-        static DB2Meta instance(-1, 60, 0x4E8FF369, types, arraySizes, -1);
+        static DB2MetaField const fields[60] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 11, false },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 3, true },
+        };
+        static DB2Meta instance(-1, 60, 0x461F9829, fields, -1);
         return &instance;
     }
 };
@@ -5293,9 +9386,14 @@ struct SpellClassOptionsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibi";
-        static uint8 const arraySizes[4] = { 1, 4, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x80FBD67A, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 4, true },
+        };
+        static DB2Meta instance(-1, 4, 0xB4E205E0, fields, -1);
         return &instance;
     }
 };
@@ -5304,9 +9402,15 @@ struct SpellCooldownsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiibi";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xCA8D8B3C, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x24886B08, fields, 4);
         return &instance;
     }
 };
@@ -5315,9 +9419,11 @@ struct SpellDescriptionVariablesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xA8EDE75B, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x9C318DAF, fields, -1);
         return &instance;
     }
 };
@@ -5326,9 +9432,14 @@ struct SpellDispelTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xE9DDA799, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xAA83295A, fields, -1);
         return &instance;
     }
 };
@@ -5337,9 +9448,13 @@ struct SpellDurationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x0D6C9082, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x22236CBC, fields, -1);
         return &instance;
     }
 };
@@ -5348,9 +9463,59 @@ struct SpellEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiiififfiiiiffififfffffiiiii";
-        static uint8 const arraySizes[30] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 2, 2, 2, 1 };
-        static DB2Meta instance(0, 30, 0x3244098B, types, arraySizes, 29);
+        static DB2MetaField const fields[28] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 2, true },
+            { FT_INT, 2, false },
+            { FT_INT, 4, true },
+            { FT_SHORT, 2, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 28, 0x803150B7, fields, 27);
+        return &instance;
+    }
+};
+
+struct SpellEffectAutoDescriptionMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[9] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 9, 0x7C523D94, fields, -1);
         return &instance;
     }
 };
@@ -5359,9 +9524,14 @@ struct SpellEffectEmissionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffhb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xC6E61A9B, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x66D096CB, fields, -1);
         return &instance;
     }
 };
@@ -5370,9 +9540,14 @@ struct SpellEquippedItemsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiib";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xCE628176, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xA0588766, fields, -1);
         return &instance;
     }
 };
@@ -5381,9 +9556,16 @@ struct SpellFlyoutMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "lssbii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x437671BD, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_LONG, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 6, 0x1F516F53, fields, -1);
         return &instance;
     }
 };
@@ -5392,9 +9574,13 @@ struct SpellFlyoutItemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xF86ADE09, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x650A0B4D, fields, 2);
         return &instance;
     }
 };
@@ -5403,9 +9589,11 @@ struct SpellFocusObjectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x96663ABF, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x9F2C8370, fields, -1);
         return &instance;
     }
 };
@@ -5414,9 +9602,15 @@ struct SpellInterruptsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bhiii";
-        static uint8 const arraySizes[5] = { 1, 1, 2, 2, 1 };
-        static DB2Meta instance(-1, 5, 0x2FA8EA94, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_INT, 2, true },
+            { FT_INT, 2, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0xF551B940, fields, 4);
         return &instance;
     }
 };
@@ -5425,9 +9619,30 @@ struct SpellItemEnchantmentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sifiihhhhhhbbbbbbbi";
-        static uint8 const arraySizes[19] = { 1, 3, 3, 1, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 19, 0x80DEA734, types, arraySizes, -1);
+        static DB2MetaField const fields[20] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 3, false },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 3, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 3, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 20, 0x96D1828E, fields, -1);
         return &instance;
     }
 };
@@ -5436,9 +9651,16 @@ struct SpellItemEnchantmentConditionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibbbbb";
-        static uint8 const arraySizes[6] = { 5, 5, 5, 5, 5, 5 };
-        static DB2Meta instance(-1, 6, 0xB9C16961, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_BYTE, 5, false },
+            { FT_INT, 5, false },
+            { FT_BYTE, 5, false },
+            { FT_BYTE, 5, false },
+            { FT_BYTE, 5, false },
+            { FT_BYTE, 5, false },
+        };
+        static DB2Meta instance(-1, 6, 0xFAA95A11, fields, -1);
         return &instance;
     }
 };
@@ -5447,9 +9669,13 @@ struct SpellKeyboundOverrideMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sib";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x6ECA16FC, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xFB8AD330, fields, -1);
         return &instance;
     }
 };
@@ -5458,9 +9684,12 @@ struct SpellLabelMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x68E44736, types, arraySizes, 1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xCCA24F16, fields, 1);
         return &instance;
     }
 };
@@ -5469,9 +9698,13 @@ struct SpellLearnSpellMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x153EBA26, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xCC8637D2, fields, -1);
         return &instance;
     }
 };
@@ -5480,9 +9713,16 @@ struct SpellLevelsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhbbi";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x9E7D1CCD, types, arraySizes, 5);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 6, 0xE3096221, fields, 5);
         return &instance;
     }
 };
@@ -5491,9 +9731,11 @@ struct SpellMechanicMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xF2075D8C, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x24C6F0F3, fields, -1);
         return &instance;
     }
 };
@@ -5502,9 +9744,22 @@ struct SpellMiscMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhbififbii";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 14, 1 };
-        static DB2Meta instance(-1, 11, 0xCDC114D5, types, arraySizes, 10);
+        static DB2MetaField const fields[12] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 14, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 12, 0x76E982BB, fields, 11);
         return &instance;
     }
 };
@@ -5513,9 +9768,25 @@ struct SpellMissileMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifffffffffffffb";
-        static uint8 const arraySizes[15] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 15, 0x1D35645E, types, arraySizes, -1);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 15, 0xAF286A50, fields, -1);
         return &instance;
     }
 };
@@ -5524,9 +9795,27 @@ struct SpellMissileMotionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x6B78A45B, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xA61A5983, fields, -1);
+        return &instance;
+    }
+};
+
+struct SpellNameMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x9F2C8370, fields, -1);
         return &instance;
     }
 };
@@ -5535,9 +9824,24 @@ struct SpellPowerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iffifbbiiiiiii";
-        static uint8 const arraySizes[14] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 14, 0x8E5E46EC, types, arraySizes, 13);
+        static DB2MetaField const fields[14] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 14, 0x12ED7A99, fields, 13);
         return &instance;
     }
 };
@@ -5546,9 +9850,13 @@ struct SpellPowerDifficultyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(2, 3, 0x74714FF7, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(0, 3, 0x08FEDBFF, fields, -1);
         return &instance;
     }
 };
@@ -5557,9 +9865,13 @@ struct SpellProceduralEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbi";
-        static uint8 const arraySizes[3] = { 4, 1, 1 };
-        static DB2Meta instance(2, 3, 0x3E47F4EF, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 4, true },
+        };
+        static DB2Meta instance(0, 3, 0xF320E3AD, fields, -1);
         return &instance;
     }
 };
@@ -5568,9 +9880,12 @@ struct SpellProcsPerMinuteMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x4BC1931B, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xBEBE0C8B, fields, -1);
         return &instance;
     }
 };
@@ -5579,9 +9894,14 @@ struct SpellProcsPerMinuteModMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fhbh";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x2503C18B, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xE5827335, fields, 3);
         return &instance;
     }
 };
@@ -5590,9 +9910,14 @@ struct SpellRadiusMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffff";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xC12E5C90, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0xAE4257F8, fields, -1);
         return &instance;
     }
 };
@@ -5601,9 +9926,15 @@ struct SpellRangeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssffb";
-        static uint8 const arraySizes[5] = { 1, 1, 2, 2, 1 };
-        static DB2Meta instance(-1, 5, 0xDE2E3F8E, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 2, true },
+        };
+        static DB2Meta instance(-1, 5, 0x6B9E2FD2, fields, -1);
         return &instance;
     }
 };
@@ -5612,9 +9943,13 @@ struct SpellReagentsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iih";
-        static uint8 const arraySizes[3] = { 1, 8, 8 };
-        static DB2Meta instance(-1, 3, 0x0463C688, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 8, true },
+            { FT_SHORT, 8, true },
+        };
+        static DB2Meta instance(-1, 3, 0x4B7DC644, fields, -1);
         return &instance;
     }
 };
@@ -5623,9 +9958,13 @@ struct SpellReagentsCurrencyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x90A5E5D2, types, arraySizes, 0);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x4D3F01C6, fields, 0);
         return &instance;
     }
 };
@@ -5634,9 +9973,15 @@ struct SpellScalingMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xF67A5719, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x4B0C2E65, fields, -1);
         return &instance;
     }
 };
@@ -5645,9 +9990,14 @@ struct SpellShapeshiftMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiib";
-        static uint8 const arraySizes[4] = { 1, 2, 2, 1 };
-        static DB2Meta instance(-1, 4, 0xA461C24D, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 2, true },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(-1, 4, 0x91C4FFE9, fields, -1);
         return &instance;
     }
 };
@@ -5656,9 +10006,20 @@ struct SpellShapeshiftFormMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sfihhbbiii";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 4, 8 };
-        static DB2Meta instance(-1, 10, 0x130819AF, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 4, false },
+            { FT_INT, 8, false },
+        };
+        static DB2Meta instance(-1, 10, 0x7082136E, fields, -1);
         return &instance;
     }
 };
@@ -5667,9 +10028,12 @@ struct SpellSpecialUnitEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hi";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x76989615, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0xF084B84D, fields, -1);
         return &instance;
     }
 };
@@ -5678,9 +10042,18 @@ struct SpellTargetRestrictionsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffihbbii";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0x7B330026, types, arraySizes, 7);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 8, 0x47BE0E0C, fields, 7);
         return &instance;
     }
 };
@@ -5689,9 +10062,13 @@ struct SpellTotemsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iih";
-        static uint8 const arraySizes[3] = { 1, 2, 2 };
-        static DB2Meta instance(-1, 3, 0xEC0C4866, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 2, false },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(-1, 3, 0x5214FD94, fields, -1);
         return &instance;
     }
 };
@@ -5700,9 +10077,25 @@ struct SpellVisualMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffihbbiiiihiii";
-        static uint8 const arraySizes[14] = { 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 14, 0x1C1301D2, types, arraySizes, -1);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 15, 0x514F85ED, fields, -1);
         return &instance;
     }
 };
@@ -5711,9 +10104,13 @@ struct SpellVisualAnimMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x0ABD7A19, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xB27FB4A5, fields, -1);
         return &instance;
     }
 };
@@ -5722,9 +10119,21 @@ struct SpellVisualColorEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fifhhhhhbbi";
-        static uint8 const arraySizes[11] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 11, 0x7E5B2E66, types, arraySizes, -1);
+        static DB2MetaField const fields[11] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 11, 0x773CE0DE, fields, -1);
         return &instance;
     }
 };
@@ -5733,9 +10142,24 @@ struct SpellVisualEffectNameMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffiiibiii";
-        static uint8 const arraySizes[13] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 13, 0xB930A934, types, arraySizes, -1);
+        static DB2MetaField const fields[14] =
+        {
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 14, 0x10206967, fields, -1);
         return &instance;
     }
 };
@@ -5744,9 +10168,19 @@ struct SpellVisualEventMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiiiiii";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0xAE75BC3C, types, arraySizes, 8);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 9, 0x8352EE58, fields, 8);
         return &instance;
     }
 };
@@ -5755,9 +10189,15 @@ struct SpellVisualKitMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifihh";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xDC04F488, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0x3F538334, fields, -1);
         return &instance;
     }
 };
@@ -5766,9 +10206,16 @@ struct SpellVisualKitAreaModelMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifffhb";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0xBE76E593, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 6, 0x34C79353, fields, -1);
         return &instance;
     }
 };
@@ -5777,9 +10224,13 @@ struct SpellVisualKitEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xB78084B7, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xF104E59F, fields, 2);
         return &instance;
     }
 };
@@ -5788,9 +10239,32 @@ struct SpellVisualKitModelAttachMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffihbbhffffffffhhhhifi";
-        static uint8 const arraySizes[22] = { 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(2, 22, 0xBCE18649, types, arraySizes, 21);
+        static DB2MetaField const fields[22] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(2, 22, 0x75650E39, fields, 21);
         return &instance;
     }
 };
@@ -5799,9 +10273,26 @@ struct SpellVisualMissileMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiffhhhhhbbiiih";
-        static uint8 const arraySizes[16] = { 1, 1, 1, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(12, 16, 0x00BA67A5, types, arraySizes, 15);
+        static DB2MetaField const fields[16] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(2, 16, 0x0A0345EB, fields, 15);
         return &instance;
     }
 };
@@ -5810,9 +10301,12 @@ struct SpellXDescriptionVariablesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xB08E6876, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xFBC7B7AE, fields, -1);
         return &instance;
     }
 };
@@ -5821,9 +10315,23 @@ struct SpellXSpellVisualMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iifhhhhiibbbi";
-        static uint8 const arraySizes[13] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(1, 13, 0x4F4B8A2A, types, arraySizes, 12);
+        static DB2MetaField const fields[13] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 13, 0xCDAF2854, fields, 12);
         return &instance;
     }
 };
@@ -5832,9 +10340,13 @@ struct StartupFilesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x51FEBBB5, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xF1381769, fields, -1);
         return &instance;
     }
 };
@@ -5843,9 +10355,12 @@ struct Startup_StringsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ss";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xF8CDDEE7, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x82058A06, fields, -1);
         return &instance;
     }
 };
@@ -5854,9 +10369,13 @@ struct StationeryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bii";
-        static uint8 const arraySizes[3] = { 1, 1, 2 };
-        static DB2Meta instance(-1, 3, 0x20F6BABD, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(-1, 3, 0x8B250029, fields, -1);
         return &instance;
     }
 };
@@ -5865,9 +10384,15 @@ struct SummonPropertiesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xFB8338FC, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x4134937A, fields, -1);
         return &instance;
     }
 };
@@ -5876,9 +10401,11 @@ struct TactKeyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "b";
-        static uint8 const arraySizes[1] = { 16 };
-        static DB2Meta instance(-1, 1, 0xF0F98B62, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 16, false },
+        };
+        static DB2Meta instance(-1, 1, 0xA55E1CCE, fields, -1);
         return &instance;
     }
 };
@@ -5887,9 +10414,11 @@ struct TactKeyLookupMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "b";
-        static uint8 const arraySizes[1] = { 8 };
-        static DB2Meta instance(-1, 1, 0x3C1AC92A, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 8, false },
+        };
+        static DB2Meta instance(-1, 1, 0x1A696886, fields, -1);
         return &instance;
     }
 };
@@ -5898,9 +10427,19 @@ struct TalentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siihbbbbb";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 1, 1, 1, 2, 1 };
-        static DB2Meta instance(-1, 9, 0xE8850B48, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_BYTE, 2, false },
+        };
+        static DB2Meta instance(-1, 9, 0x2661E6C2, fields, -1);
         return &instance;
     }
 };
@@ -5909,9 +10448,24 @@ struct TaxiNodesMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sfifffhhhbii";
-        static uint8 const arraySizes[12] = { 1, 3, 2, 2, 1, 2, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 12, 0xB46C6A8B, types, arraySizes, -1);
+        static DB2MetaField const fields[14] =
+        {
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 2, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 2, true },
+        };
+        static DB2Meta instance(4, 14, 0x91ADBF11, fields, 5);
         return &instance;
     }
 };
@@ -5920,9 +10474,14 @@ struct TaxiPathMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(2, 4, 0xF44E2BF5, types, arraySizes, 0);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(0, 4, 0x3716BBCD, fields, 1);
         return &instance;
     }
 };
@@ -5931,9 +10490,19 @@ struct TaxiPathNodeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fhhbibihh";
-        static uint8 const arraySizes[9] = { 3, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(4, 9, 0xD38E8C01, types, arraySizes, 1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(1, 9, 0xE28C3360, fields, 2);
         return &instance;
     }
 };
@@ -5942,9 +10511,13 @@ struct TerrainMaterialMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x19D9496F, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x9F25E6D3, fields, -1);
         return &instance;
     }
 };
@@ -5953,9 +10526,15 @@ struct TerrainTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shhbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x4FE20345, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xB4573071, fields, -1);
         return &instance;
     }
 };
@@ -5964,9 +10543,11 @@ struct TerrainTypeSoundsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xE4923C1F, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xECCAE96B, fields, -1);
         return &instance;
     }
 };
@@ -5975,9 +10556,20 @@ struct TextureBlendSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifffffbbbb";
-        static uint8 const arraySizes[10] = { 3, 3, 3, 3, 3, 4, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0xA2323E0C, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_INT, 3, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 4, true },
+        };
+        static DB2Meta instance(-1, 10, 0xF2AFFE4C, fields, -1);
         return &instance;
     }
 };
@@ -5986,9 +10578,13 @@ struct TextureFileDataMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iib";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(0, 3, 0xE0790D00, types, arraySizes, 1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 3, 0x71D3BD92, fields, 2);
         return &instance;
     }
 };
@@ -5997,9 +10593,13 @@ struct TotemCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sib";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x20B9177A, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x2AA9FB1E, fields, -1);
         return &instance;
     }
 };
@@ -6008,9 +10608,15 @@ struct ToyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sibbi";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(4, 5, 0x5409C5EA, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(1, 5, 0x6156EBCA, fields, -1);
         return &instance;
     }
 };
@@ -6019,9 +10625,17 @@ struct TradeSkillCategoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shhhb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x5D3ADD4D, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(2, 7, 0xAFEA1AAD, fields, -1);
         return &instance;
     }
 };
@@ -6030,9 +10644,12 @@ struct TradeSkillItemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xFDE283DA, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xA90CD5D2, fields, -1);
         return &instance;
     }
 };
@@ -6041,9 +10658,15 @@ struct TransformMatrixMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffff";
-        static uint8 const arraySizes[5] = { 3, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xB6A2C431, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0xBA00B2FD, fields, -1);
         return &instance;
     }
 };
@@ -6052,9 +10675,12 @@ struct TransmogHolidayMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ii";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(0, 2, 0xB420EB18, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 2, 0x6FC325A0, fields, -1);
         return &instance;
     }
 };
@@ -6063,9 +10689,20 @@ struct TransmogSetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shhbiiiiii";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(4, 10, 0xBEDFD7D1, types, arraySizes, 1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(1, 10, 0x3F0E4AEF, fields, 7);
         return &instance;
     }
 };
@@ -6074,9 +10711,12 @@ struct TransmogSetGroupMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "si";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(1, 2, 0xCD072FE5, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(1, 2, 0x0F60CFC9, fields, -1);
         return &instance;
     }
 };
@@ -6085,9 +10725,14 @@ struct TransmogSetItemMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiii";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(0, 4, 0x0E96B3A2, types, arraySizes, 1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 4, 0x23855A82, fields, 1);
         return &instance;
     }
 };
@@ -6096,9 +10741,14 @@ struct TransportAnimationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifbi";
-        static uint8 const arraySizes[4] = { 1, 3, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x099987ED, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x6329464B, fields, 3);
         return &instance;
     }
 };
@@ -6107,9 +10757,20 @@ struct TransportPhysicsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffffff";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x2C1FB208, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 10, 0x0B297C98, fields, -1);
         return &instance;
     }
 };
@@ -6118,9 +10779,13 @@ struct TransportRotationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifi";
-        static uint8 const arraySizes[3] = { 1, 4, 1 };
-        static DB2Meta instance(-1, 3, 0x72035AA9, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_FLOAT, 4, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x5FE3BC91, fields, 2);
         return &instance;
     }
 };
@@ -6129,9 +10794,14 @@ struct TrophyMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shbi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xE16151C5, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x0AE68C93, fields, -1);
         return &instance;
     }
 };
@@ -6140,9 +10810,13 @@ struct UIExpansionDisplayInfoMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x73DFDEC5, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xCD407FA1, fields, -1);
         return &instance;
     }
 };
@@ -6151,9 +10825,13 @@ struct UIExpansionDisplayInfoIconMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x331022F2, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xC9B51E5D, fields, -1);
         return &instance;
     }
 };
@@ -6162,9 +10840,15 @@ struct UiCamFbackTransmogChrRaceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x9FB4CC78, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xB1C9DAC4, fields, -1);
         return &instance;
     }
 };
@@ -6173,9 +10857,14 @@ struct UiCamFbackTransmogWeaponMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x020890B7, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x5148437F, fields, -1);
         return &instance;
     }
 };
@@ -6184,9 +10873,19 @@ struct UiCameraMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sfffhbbbi";
-        static uint8 const arraySizes[9] = { 1, 3, 3, 3, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 9, 0xCA6C98D4, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 9, 0xC54B36EE, fields, -1);
         return &instance;
     }
 };
@@ -6195,20 +10894,209 @@ struct UiCameraTypeMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sii";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x644732AE, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x34F64532, fields, -1);
+        return &instance;
+    }
+};
+
+struct UiCanvasMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(0, 3, 0x77DC2C2A, fields, -1);
+        return &instance;
+    }
+};
+
+struct UiMapMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[13] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(1, 13, 0x4B07CF16, fields, 2);
+        return &instance;
+    }
+};
+
+struct UiMapArtMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xD85EF8B6, fields, -1);
+        return &instance;
+    }
+};
+
+struct UiMapArtStyleLayerMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[9] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 9, 0xAFF6429A, fields, 8);
+        return &instance;
+    }
+};
+
+struct UiMapArtTileMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0xBA5290E9, fields, 4);
+        return &instance;
+    }
+};
+
+struct UiMapAssignmentMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[10] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 6, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(3, 10, 0xFA919770, fields, 4);
         return &instance;
     }
 };
 
-struct UiMapPOIMeta
+struct UiMapFogOfWarMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifiihhi";
-        static uint8 const arraySizes[7] = { 1, 3, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(6, 7, 0x559E1F11, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(0, 4, 0x257E044E, fields, 1);
+        return &instance;
+    }
+};
+
+struct UiMapFogOfWarVisualizationMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xB8110379, fields, -1);
+        return &instance;
+    }
+};
+
+struct UiMapGroupMemberMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x3D1DDDA1, fields, 1);
+        return &instance;
+    }
+};
+
+struct UiMapLinkMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[6] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 2, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(2, 6, 0x1A2F1836, fields, 3);
+        return &instance;
+    }
+};
+
+struct UiMapXMapArtMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0xD74B6E49, fields, 2);
         return &instance;
     }
 };
@@ -6217,9 +11105,12 @@ struct UiModelSceneMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xA7D62B8A, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x0B9EFECA, fields, -1);
         return &instance;
     }
 };
@@ -6228,9 +11119,20 @@ struct UiModelSceneActorMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sfffffbiii";
-        static uint8 const arraySizes[10] = { 1, 3, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(7, 10, 0x679AC95F, types, arraySizes, 9);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(2, 10, 0x8B5BF449, fields, 9);
         return &instance;
     }
 };
@@ -6239,9 +11141,17 @@ struct UiModelSceneActorDisplayMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x6137F4BE, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta instance(-1, 7, 0xDD1DD903, fields, -1);
         return &instance;
     }
 };
@@ -6250,9 +11160,44 @@ struct UiModelSceneCameraMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sfffffffffffbbii";
-        static uint8 const arraySizes[16] = { 1, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(14, 16, 0xC58AA5EC, types, arraySizes, 15);
+        static DB2MetaField const fields[16] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(3, 16, 0xEDFBD5A2, fields, 15);
+        return &instance;
+    }
+};
+
+struct UiPartyPoseMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 6, 0x880480BF, fields, 5);
         return &instance;
     }
 };
@@ -6261,9 +11206,28 @@ struct UiTextureAtlasMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x9879592A, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x6951B2FD, fields, -1);
+        return &instance;
+    }
+};
+
+struct UiTextureAtlasElementMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(1, 2, 0xBBDA0A61, fields, -1);
         return &instance;
     }
 };
@@ -6272,9 +11236,20 @@ struct UiTextureAtlasMemberMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihhhhhb";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(1, 8, 0x81E2055F, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(1, 10, 0x4D58B085, fields, 7);
         return &instance;
     }
 };
@@ -6283,64 +11258,166 @@ struct UiTextureKitMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x2C7E0372, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x1FC1A9C6, fields, -1);
         return &instance;
     }
 };
 
-struct UnitBloodMeta
+struct UiWidgetMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiiii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x4689A9A0, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0xC4C60F67, fields, -1);
         return &instance;
     }
 };
 
-struct UnitBloodLevelsMeta
+struct UiWidgetConstantSourceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "b";
-        static uint8 const arraySizes[1] = { 3 };
-        static DB2Meta instance(-1, 1, 0x31A6BD58, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xFE573B5D, fields, 2);
         return &instance;
     }
 };
 
-struct UnitConditionMeta
+struct UiWidgetDataSourceMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ibbb";
-        static uint8 const arraySizes[4] = { 8, 1, 8, 8 };
-        static DB2Meta instance(-1, 4, 0x62802D9C, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x27BC34FD, fields, 3);
         return &instance;
     }
 };
 
-struct UnitPowerBarMeta
+struct UiWidgetStringSourceMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x86CECC21, fields, 2);
+        return &instance;
+    }
+};
+
+struct UiWidgetVisualizationMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x1DB32AF9, fields, -1);
+        return &instance;
+    }
+};
+
+struct UnitBloodMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0x007ED968, fields, -1);
+        return &instance;
+    }
+};
+
+struct UnitBloodLevelsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssssffiiffhhbbii";
-        static uint8 const arraySizes[16] = { 1, 1, 1, 1, 1, 1, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 16, 0x626C94CD, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_BYTE, 3, false },
+        };
+        static DB2Meta instance(-1, 1, 0x684D24F4, fields, -1);
         return &instance;
     }
 };
 
-struct UnitTestMeta
+struct UnitConditionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssiii";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(2, 5, 0x63B4527B, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 8, false },
+            { FT_BYTE, 8, true },
+            { FT_INT, 8, true },
+        };
+        static DB2Meta instance(-1, 4, 0x215CBCD2, fields, -1);
+        return &instance;
+    }
+};
+
+struct UnitPowerBarMeta
+{
+    static DB2Meta const* Instance()
+    {
+        static DB2MetaField const fields[16] =
+        {
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 6, true },
+            { FT_INT, 6, true },
+        };
+        static DB2Meta instance(-1, 16, 0x2640852D, fields, -1);
         return &instance;
     }
 };
@@ -6349,9 +11426,28 @@ struct VehicleMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifffffffffffhhhbbi";
-        static uint8 const arraySizes[18] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 8, 1, 3, 1, 1, 1 };
-        static DB2Meta instance(-1, 18, 0x1606C582, types, arraySizes, -1);
+        static DB2MetaField const fields[18] =
+        {
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 8, false },
+            { FT_SHORT, 3, false },
+        };
+        static DB2Meta instance(-1, 18, 0x221A0252, fields, -1);
         return &instance;
     }
 };
@@ -6360,9 +11456,71 @@ struct VehicleSeatMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iiiffffffffffffffffffffffffffffffihhhhhhhhhhhhhhhhhhhbbbbbbii";
-        static uint8 const arraySizes[61] = { 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 61, 0x242E0ECD, types, arraySizes, -1);
+        static DB2MetaField const fields[61] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 61, 0x7AB200FA, fields, -1);
         return &instance;
     }
 };
@@ -6371,9 +11529,14 @@ struct VehicleUIIndSeatMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffbh";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x5F688502, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x590E3162, fields, 3);
         return &instance;
     }
 };
@@ -6382,9 +11545,11 @@ struct VehicleUIIndicatorMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "i";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0x68486100, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0x4B1AACBC, fields, -1);
         return &instance;
     }
 };
@@ -6393,9 +11558,19 @@ struct VignetteMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sffiiii";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x52E3B381, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 9, 0xE70E083E, fields, -1);
         return &instance;
     }
 };
@@ -6404,9 +11579,12 @@ struct VirtualAttachmentMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0xEC767C57, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0xA9D90777, fields, -1);
         return &instance;
     }
 };
@@ -6415,9 +11593,13 @@ struct VirtualAttachmentCustomizationMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xC354C931, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 3, 0x5812DF35, fields, -1);
         return &instance;
     }
 };
@@ -6426,9 +11608,14 @@ struct VocalUISoundsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbbi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 2 };
-        static DB2Meta instance(-1, 4, 0xED48CFA9, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 2, false },
+        };
+        static DB2Meta instance(-1, 4, 0x264C4E59, fields, -1);
         return &instance;
     }
 };
@@ -6437,9 +11624,25 @@ struct WMOAreaTableMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihhhhhhbbbbiih";
-        static uint8 const arraySizes[15] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(12, 15, 0x4616C893, types, arraySizes, 14);
+        static DB2MetaField const fields[15] =
+        {
+            { FT_STRING, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(1, 15, 0x60EC930B, fields, 2);
         return &instance;
     }
 };
@@ -6448,9 +11651,15 @@ struct WMOMinimapTextureMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbbh";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0x8F4AE3C0, types, arraySizes, 4);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0x48CE176C, fields, 4);
         return &instance;
     }
 };
@@ -6459,9 +11668,15 @@ struct WbAccessControlListMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shbbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 5, 0xBE044710, types, arraySizes, -1);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 5, 0xDC9D8334, fields, -1);
         return &instance;
     }
 };
@@ -6470,9 +11685,14 @@ struct WbCertWhitelistMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbbb";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x01D13030, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x1524F278, fields, -1);
         return &instance;
     }
 };
@@ -6481,9 +11701,17 @@ struct WeaponImpactSoundsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbbiiii";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 11, 11, 11, 11 };
-        static DB2Meta instance(-1, 7, 0x774C043A, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 11, false },
+            { FT_INT, 11, false },
+            { FT_INT, 11, false },
+            { FT_INT, 11, false },
+        };
+        static DB2Meta instance(-1, 7, 0x9C7F9BA6, fields, -1);
         return &instance;
     }
 };
@@ -6492,9 +11720,13 @@ struct WeaponSwingSounds2Meta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "bbi";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xD45347C3, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x18B6CC57, fields, -1);
         return &instance;
     }
 };
@@ -6503,9 +11735,19 @@ struct WeaponTrailMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ifffiffff";
-        static uint8 const arraySizes[9] = { 1, 1, 1, 1, 3, 3, 3, 3, 3 };
-        static DB2Meta instance(-1, 9, 0x49754C60, types, arraySizes, -1);
+        static DB2MetaField const fields[9] =
+        {
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+        };
+        static DB2Meta instance(-1, 9, 0xB05F809A, fields, -1);
         return &instance;
     }
 };
@@ -6514,9 +11756,13 @@ struct WeaponTrailModelDefMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x7DE7C508, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xCE7AD194, fields, 2);
         return &instance;
     }
 };
@@ -6525,9 +11771,20 @@ struct WeaponTrailParamMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffffbbbbh";
-        static uint8 const arraySizes[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x9B0F7200, types, arraySizes, 9);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 10, 0xC3B87CA4, fields, 9);
         return &instance;
     }
 };
@@ -6536,86 +11793,133 @@ struct WeatherMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffffffhbbbii";
-        static uint8 const arraySizes[14] = { 2, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 14, 0x7C160B07, types, arraySizes, -1);
-        return &instance;
-    }
-};
-
-struct WindSettingsMeta
-{
-    static DB2Meta const* Instance()
-    {
-        static char const* types = "fffffffffb";
-        static uint8 const arraySizes[10] = { 1, 3, 1, 1, 3, 1, 3, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x5308550C, types, arraySizes, -1);
+        static DB2MetaField const fields[22] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_FLOAT, 2, true },
+            { FT_FLOAT, 3, true },
+        };
+        static DB2Meta instance(-1, 22, 0x784E91E0, fields, -1);
         return &instance;
     }
 };
 
-struct WorldBossLockoutMeta
+struct WeatherXParticulateMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sh";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta instance(-1, 2, 0x4D7103A0, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 2, 0x791A7865, fields, 1);
         return &instance;
     }
 };
 
-struct WorldChunkSoundsMeta
+struct WindSettingsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hbbbbb";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0xD06AA126, types, arraySizes, -1);
+        static DB2MetaField const fields[10] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 3, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 10, 0xE09E01C4, fields, -1);
         return &instance;
     }
 };
 
-struct WorldEffectMeta
+struct WorldBossLockoutMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihbbii";
-        static uint8 const arraySizes[6] = { 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 6, 0x2E9B9BFD, types, arraySizes, -1);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_STRING, 1, true },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 2, 0x57E8ADB8, fields, -1);
         return &instance;
     }
 };
 
-struct WorldElapsedTimerMeta
+struct WorldChunkSoundsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sbb";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x6C026FDE, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0xA5616A27, fields, -1);
         return &instance;
     }
 };
 
-struct WorldMapAreaMeta
+struct WorldEffectMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sffffihhhhhbbbbii";
-        static uint8 const arraySizes[17] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(15, 17, 0xC7E90019, types, arraySizes, -1);
+        static DB2MetaField const fields[6] =
+        {
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 6, 0xBCB8719B, fields, -1);
         return &instance;
     }
 };
 
-struct WorldMapContinentMeta
+struct WorldElapsedTimerMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ffffhhbbbbb";
-        static uint8 const arraySizes[11] = { 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 11, 0x8F75E077, types, arraySizes, -1);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_STRING, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0x103B8712, fields, -1);
         return &instance;
     }
 };
@@ -6624,20 +11928,40 @@ struct WorldMapOverlayMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sihhiiiiiiiiii";
-        static uint8 const arraySizes[14] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 };
-        static DB2Meta instance(1, 14, 0xDC4B6AF3, types, arraySizes, 4);
+        static DB2MetaField const fields[13] =
+        {
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 4, false },
+        };
+        static DB2Meta instance(0, 13, 0x837A3DAA, fields, 1);
         return &instance;
     }
 };
 
-struct WorldMapTransformsMeta
+struct WorldMapOverlayTileMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fffhhhhhbi";
-        static uint8 const arraySizes[10] = { 6, 2, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 10, 0x99FB4B71, types, arraySizes, 3);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 5, 0xC4DCC916, fields, 4);
         return &instance;
     }
 };
@@ -6646,9 +11970,14 @@ struct WorldSafeLocsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "sffh";
-        static uint8 const arraySizes[4] = { 1, 3, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x605EA8A6, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING, 1, false },
+            { FT_FLOAT, 3, false },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, false }
+        };
+        static DB2Meta instance(-1, 4, 0x6BF0D7EC, fields, 3);
         return &instance;
     }
 };
@@ -6657,9 +11986,11 @@ struct WorldStateExpressionMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "s";
-        static uint8 const arraySizes[1] = { 1 };
-        static DB2Meta instance(-1, 1, 0xA69C9812, types, arraySizes, -1);
+        static DB2MetaField const fields[1] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+        };
+        static DB2Meta instance(-1, 1, 0xF23806A6, fields, -1);
         return &instance;
     }
 };
@@ -6668,9 +11999,27 @@ struct WorldStateUIMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ssssshhhhhhbbbiii";
-        static uint8 const arraySizes[17] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(14, 17, 0x70808977, types, arraySizes, 5);
+        static DB2MetaField const fields[17] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_INT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 3, false },
+        };
+        static DB2Meta instance(5, 17, 0xE1F042FE, fields, 6);
         return &instance;
     }
 };
@@ -6679,9 +12028,18 @@ struct WorldStateZoneSoundsMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "ihhhhhhb";
-        static uint8 const arraySizes[8] = { 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 8, 0xB9572D3D, types, arraySizes, -1);
+        static DB2MetaField const fields[8] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_INT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 8, 0x44CFA417, fields, -1);
         return &instance;
     }
 };
@@ -6690,9 +12048,17 @@ struct World_PVP_AreaMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "hhhhhbb";
-        static uint8 const arraySizes[7] = { 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 7, 0x6FBBF76B, types, arraySizes, -1);
+        static DB2MetaField const fields[7] =
+        {
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+        };
+        static DB2Meta instance(-1, 7, 0x3F8DDC83, fields, -1);
         return &instance;
     }
 };
@@ -6701,9 +12067,14 @@ struct ZoneIntroMusicTableMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shbi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0x1F8417ED, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0x5453B51D, fields, -1);
         return &instance;
     }
 };
@@ -6712,9 +12083,14 @@ struct ZoneLightMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "shh";
-        static uint8 const arraySizes[3] = { 1, 1, 1 };
-        static DB2Meta instance(-1, 3, 0x3C11F38B, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta instance(-1, 4, 0xD553DE84, fields, -1);
         return &instance;
     }
 };
@@ -6723,9 +12099,13 @@ struct ZoneLightPointMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "fbh";
-        static uint8 const arraySizes[3] = { 2, 1, 1 };
-        static DB2Meta instance(-1, 3, 0xEF93DC50, types, arraySizes, 2);
+        static DB2MetaField const fields[3] =
+        {
+            { FT_FLOAT, 2, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+        };
+        static DB2Meta instance(-1, 3, 0xB21DA554, fields, 2);
         return &instance;
     }
 };
@@ -6734,9 +12114,14 @@ struct ZoneMusicMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "siii";
-        static uint8 const arraySizes[4] = { 1, 2, 2, 2 };
-        static DB2Meta instance(-1, 4, 0x9E2B332D, types, arraySizes, -1);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_INT, 2, false },
+            { FT_INT, 2, false },
+            { FT_INT, 2, false },
+        };
+        static DB2Meta instance(-1, 4, 0x9EBD4495, fields, -1);
         return &instance;
     }
 };
@@ -6745,9 +12130,14 @@ struct ZoneStoryMeta
 {
     static DB2Meta const* Instance()
     {
-        static char const* types = "iibi";
-        static uint8 const arraySizes[4] = { 1, 1, 1, 1 };
-        static DB2Meta instance(-1, 4, 0xEE16D6F3, types, arraySizes, 3);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, true },
+        };
+        static DB2Meta instance(-1, 4, 0x5BFB82E8, fields, 3);
         return &instance;
     }
 };
diff --git a/src/server/game/DataStores/DB2Stores.cpp b/src/server/game/DataStores/DB2Stores.cpp
index fe91d679d97..957d44407e8 100644
--- a/src/server/game/DataStores/DB2Stores.cpp
+++ b/src/server/game/DataStores/DB2Stores.cpp
@@ -27,6 +27,7 @@
 #include "Timer.h"
 #include "Util.h"
 #include <array>
+#include <numeric>
 #include <sstream>
 #include <cctype>
 
@@ -36,6 +37,7 @@
 #endif
 
 DB2Storage<AchievementEntry>                    sAchievementStore("Achievement.db2", AchievementLoadInfo::Instance());
+DB2Storage<AnimationDataEntry>                  sAnimationDataStore("AnimationData.db2", AnimationDataLoadInfo::Instance());
 DB2Storage<AnimKitEntry>                        sAnimKitStore("AnimKit.db2", AnimKitLoadInfo::Instance());
 DB2Storage<AreaGroupMemberEntry>                sAreaGroupMemberStore("AreaGroupMember.db2", AreaGroupMemberLoadInfo::Instance());
 DB2Storage<AreaTableEntry>                      sAreaTableStore("AreaTable.db2", AreaTableLoadInfo::Instance());
@@ -75,6 +77,7 @@ DB2Storage<ChrRacesEntry>                       sChrRacesStore("ChrRaces.db2", C
 DB2Storage<ChrSpecializationEntry>              sChrSpecializationStore("ChrSpecialization.db2", ChrSpecializationLoadInfo::Instance());
 DB2Storage<CinematicCameraEntry>                sCinematicCameraStore("CinematicCamera.db2", CinematicCameraLoadInfo::Instance());
 DB2Storage<CinematicSequencesEntry>             sCinematicSequencesStore("CinematicSequences.db2", CinematicSequencesLoadInfo::Instance());
+DB2Storage<ContentTuningEntry>                  sContentTuningStore("ContentTuning.db2", ContentTuningLoadInfo::Instance());
 DB2Storage<ConversationLineEntry>               sConversationLineStore("ConversationLine.db2", ConversationLineLoadInfo::Instance());
 DB2Storage<CreatureDisplayInfoEntry>            sCreatureDisplayInfoStore("CreatureDisplayInfo.db2", CreatureDisplayInfoLoadInfo::Instance());
 DB2Storage<CreatureDisplayInfoExtraEntry>       sCreatureDisplayInfoExtraStore("CreatureDisplayInfoExtra.db2", CreatureDisplayInfoExtraLoadInfo::Instance());
@@ -94,6 +97,8 @@ DB2Storage<DurabilityQualityEntry>              sDurabilityQualityStore("Durabil
 DB2Storage<EmotesEntry>                         sEmotesStore("Emotes.db2", EmotesLoadInfo::Instance());
 DB2Storage<EmotesTextEntry>                     sEmotesTextStore("EmotesText.db2", EmotesTextLoadInfo::Instance());
 DB2Storage<EmotesTextSoundEntry>                sEmotesTextSoundStore("EmotesTextSound.db2", EmotesTextSoundLoadInfo::Instance());
+DB2Storage<ExpectedStatEntry>                   sExpectedStatStore("ExpectedStat.db2", ExpectedStatLoadInfo::Instance());
+DB2Storage<ExpectedStatModEntry>                sExpectedStatModStore("ExpectedStatMod.db2", ExpectedStatModLoadInfo::Instance());
 DB2Storage<FactionEntry>                        sFactionStore("Faction.db2", FactionLoadInfo::Instance());
 DB2Storage<FactionTemplateEntry>                sFactionTemplateStore("FactionTemplate.db2", FactionTemplateLoadInfo::Instance());
 DB2Storage<GameObjectDisplayInfoEntry>          sGameObjectDisplayInfoStore("GameObjectDisplayInfo.db2", GameobjectDisplayInfoLoadInfo::Instance());
@@ -178,6 +183,7 @@ DB2Storage<NameGenEntry>                        sNameGenStore("NameGen.db2", Nam
 DB2Storage<NamesProfanityEntry>                 sNamesProfanityStore("NamesProfanity.db2", NamesProfanityLoadInfo::Instance());
 DB2Storage<NamesReservedEntry>                  sNamesReservedStore("NamesReserved.db2", NamesReservedLoadInfo::Instance());
 DB2Storage<NamesReservedLocaleEntry>            sNamesReservedLocaleStore("NamesReservedLocale.db2", NamesReservedLocaleLoadInfo::Instance());
+DB2Storage<NumTalentsAtLevelEntry>              sNumTalentsAtLevelStore("NumTalentsAtLevel.db2", NumTalentsAtLevelLoadInfo::Instance());
 DB2Storage<OverrideSpellDataEntry>              sOverrideSpellDataStore("OverrideSpellData.db2", OverrideSpellDataLoadInfo::Instance());
 DB2Storage<PhaseEntry>                          sPhaseStore("Phase.db2", PhaseLoadInfo::Instance());
 DB2Storage<PhaseXPhaseGroupEntry>               sPhaseXPhaseGroupStore("PhaseXPhaseGroup.db2", PhaseXPhaseGroupLoadInfo::Instance());
@@ -187,9 +193,9 @@ DB2Storage<PowerTypeEntry>                      sPowerTypeStore("PowerType.db2",
 DB2Storage<PrestigeLevelInfoEntry>              sPrestigeLevelInfoStore("PrestigeLevelInfo.db2", PrestigeLevelInfoLoadInfo::Instance());
 DB2Storage<PVPDifficultyEntry>                  sPVPDifficultyStore("PVPDifficulty.db2", PvpDifficultyLoadInfo::Instance());
 DB2Storage<PVPItemEntry>                        sPVPItemStore("PVPItem.db2", PvpItemLoadInfo::Instance());
-DB2Storage<PvpRewardEntry>                      sPvpRewardStore("PvpReward.db2", PvpRewardLoadInfo::Instance());
 DB2Storage<PvpTalentEntry>                      sPvpTalentStore("PvpTalent.db2", PvpTalentLoadInfo::Instance());
-DB2Storage<PvpTalentUnlockEntry>                sPvpTalentUnlockStore("PvpTalentUnlock.db2", PvpTalentUnlockLoadInfo::Instance());
+DB2Storage<PvpTalentCategoryEntry>              sPvpTalentCategoryStore("PvpTalentCategory.db2", PvpTalentCategoryLoadInfo::Instance());
+DB2Storage<PvpTalentSlotUnlockEntry>            sPvpTalentSlotUnlockStore("PvpTalentSlotUnlock.db2", PvpTalentSlotUnlockLoadInfo::Instance());
 DB2Storage<QuestFactionRewardEntry>             sQuestFactionRewardStore("QuestFactionReward.db2", QuestFactionRewardLoadInfo::Instance());
 DB2Storage<QuestMoneyRewardEntry>               sQuestMoneyRewardStore("QuestMoneyReward.db2", QuestMoneyRewardLoadInfo::Instance());
 DB2Storage<QuestPackageItemEntry>               sQuestPackageItemStore("QuestPackageItem.db2", QuestPackageItemLoadInfo::Instance());
@@ -201,7 +207,6 @@ DB2Storage<RewardPackEntry>                     sRewardPackStore("RewardPack.db2
 DB2Storage<RewardPackXCurrencyTypeEntry>        sRewardPackXCurrencyTypeStore("RewardPackXCurrencyType.db2", RewardPackXCurrencyTypeLoadInfo::Instance());
 DB2Storage<RewardPackXItemEntry>                sRewardPackXItemStore("RewardPackXItem.db2", RewardPackXItemLoadInfo::Instance());
 DB2Storage<RulesetItemUpgradeEntry>             sRulesetItemUpgradeStore("RulesetItemUpgrade.db2", RulesetItemUpgradeLoadInfo::Instance());
-DB2Storage<SandboxScalingEntry>                 sSandboxScalingStore("SandboxScaling.db2", SandboxScalingLoadInfo::Instance());
 DB2Storage<ScalingStatDistributionEntry>        sScalingStatDistributionStore("ScalingStatDistribution.db2", ScalingStatDistributionLoadInfo::Instance());
 DB2Storage<ScenarioEntry>                       sScenarioStore("Scenario.db2", ScenarioLoadInfo::Instance());
 DB2Storage<ScenarioStepEntry>                   sScenarioStepStore("ScenarioStep.db2", ScenarioStepLoadInfo::Instance());
@@ -214,7 +219,6 @@ DB2Storage<SkillLineAbilityEntry>               sSkillLineAbilityStore("SkillLin
 DB2Storage<SkillRaceClassInfoEntry>             sSkillRaceClassInfoStore("SkillRaceClassInfo.db2", SkillRaceClassInfoLoadInfo::Instance());
 DB2Storage<SoundKitEntry>                       sSoundKitStore("SoundKit.db2", SoundKitLoadInfo::Instance());
 DB2Storage<SpecializationSpellsEntry>           sSpecializationSpellsStore("SpecializationSpells.db2", SpecializationSpellsLoadInfo::Instance());
-DB2Storage<SpellEntry>                          sSpellStore("Spell.db2", SpellLoadInfo::Instance());
 DB2Storage<SpellAuraOptionsEntry>               sSpellAuraOptionsStore("SpellAuraOptions.db2", SpellAuraOptionsLoadInfo::Instance());
 DB2Storage<SpellAuraRestrictionsEntry>          sSpellAuraRestrictionsStore("SpellAuraRestrictions.db2", SpellAuraRestrictionsLoadInfo::Instance());
 DB2Storage<SpellCastTimesEntry>                 sSpellCastTimesStore("SpellCastTimes.db2", SpellCastTimesLoadInfo::Instance());
@@ -233,6 +237,7 @@ DB2Storage<SpellItemEnchantmentConditionEntry>  sSpellItemEnchantmentConditionSt
 DB2Storage<SpellLearnSpellEntry>                sSpellLearnSpellStore("SpellLearnSpell.db2", SpellLearnSpellLoadInfo::Instance());
 DB2Storage<SpellLevelsEntry>                    sSpellLevelsStore("SpellLevels.db2", SpellLevelsLoadInfo::Instance());
 DB2Storage<SpellMiscEntry>                      sSpellMiscStore("SpellMisc.db2", SpellMiscLoadInfo::Instance());
+DB2Storage<SpellNameEntry>                      sSpellNameStore("SpellName.db2", SpellNameLoadInfo::Instance());
 DB2Storage<SpellPowerEntry>                     sSpellPowerStore("SpellPower.db2", SpellPowerLoadInfo::Instance());
 DB2Storage<SpellPowerDifficultyEntry>           sSpellPowerDifficultyStore("SpellPowerDifficulty.db2", SpellPowerDifficultyLoadInfo::Instance());
 DB2Storage<SpellProcsPerMinuteEntry>            sSpellProcsPerMinuteStore("SpellProcsPerMinute.db2", SpellProcsPerMinuteLoadInfo::Instance());
@@ -260,14 +265,16 @@ DB2Storage<TransmogSetGroupEntry>               sTransmogSetGroupStore("Transmog
 DB2Storage<TransmogSetItemEntry>                sTransmogSetItemStore("TransmogSetItem.db2", TransmogSetItemLoadInfo::Instance());
 DB2Storage<TransportAnimationEntry>             sTransportAnimationStore("TransportAnimation.db2", TransportAnimationLoadInfo::Instance());
 DB2Storage<TransportRotationEntry>              sTransportRotationStore("TransportRotation.db2", TransportRotationLoadInfo::Instance());
+DB2Storage<UiMapEntry>                          sUiMapStore("UiMap.db2", UiMapLoadInfo::Instance());
+DB2Storage<UiMapAssignmentEntry>                sUiMapAssignmentStore("UiMapAssignment.db2", UiMapAssignmentLoadInfo::Instance());
+DB2Storage<UiMapLinkEntry>                      sUiMapLinkStore("UiMapLink.db2", UiMapLinkLoadInfo::Instance());
+DB2Storage<UiMapXMapArtEntry>                   sUiMapXMapArtStore("UiMapXMapArt.db2", UiMapXMapArtLoadInfo::Instance());
 DB2Storage<UnitPowerBarEntry>                   sUnitPowerBarStore("UnitPowerBar.db2", UnitPowerBarLoadInfo::Instance());
 DB2Storage<VehicleEntry>                        sVehicleStore("Vehicle.db2", VehicleLoadInfo::Instance());
 DB2Storage<VehicleSeatEntry>                    sVehicleSeatStore("VehicleSeat.db2", VehicleSeatLoadInfo::Instance());
 DB2Storage<WMOAreaTableEntry>                   sWMOAreaTableStore("WMOAreaTable.db2", WmoAreaTableLoadInfo::Instance());
 DB2Storage<WorldEffectEntry>                    sWorldEffectStore("WorldEffect.db2", WorldEffectLoadInfo::Instance());
-DB2Storage<WorldMapAreaEntry>                   sWorldMapAreaStore("WorldMapArea.db2", WorldMapAreaLoadInfo::Instance());
 DB2Storage<WorldMapOverlayEntry>                sWorldMapOverlayStore("WorldMapOverlay.db2", WorldMapOverlayLoadInfo::Instance());
-DB2Storage<WorldMapTransformsEntry>             sWorldMapTransformsStore("WorldMapTransforms.db2", WorldMapTransformsLoadInfo::Instance());
 DB2Storage<WorldSafeLocsEntry>                  sWorldSafeLocsStore("WorldSafeLocs.db2", WorldSafeLocsLoadInfo::Instance());
 
 TaxiMask                                        sTaxiNodesMask;
@@ -317,7 +324,6 @@ typedef std::unordered_map<uint32, std::array<std::vector<NameGenEntry const*>,
 typedef std::array<std::vector<Trinity::wregex>, TOTAL_LOCALES + 1> NameValidationRegexContainer;
 typedef std::unordered_map<uint32, std::vector<uint32>> PhaseGroupContainer;
 typedef std::array<PowerTypeEntry const*, MAX_POWERS> PowerTypesContainer;
-typedef std::vector<PvpTalentEntry const*> PvpTalentsByPosition[MAX_CLASSES][MAX_PVP_TALENT_TIERS][MAX_PVP_TALENT_COLUMNS];
 typedef std::unordered_map<uint32, std::pair<std::vector<QuestPackageItemEntry const*>, std::vector<QuestPackageItemEntry const*>>> QuestPackageItemContainer;
 typedef std::unordered_map<uint32, uint32> RulesetItemUpgradeContainer;
 typedef std::unordered_multimap<uint32, SkillRaceClassInfoEntry const*> SkillRaceClassInfoContainer;
@@ -329,12 +335,20 @@ typedef std::vector<TalentEntry const*> TalentsByPosition[MAX_CLASSES][MAX_TALEN
 typedef std::unordered_set<uint32> ToyItemIdsContainer;
 typedef std::tuple<uint16, uint8, int32> WMOAreaTableKey;
 typedef std::map<WMOAreaTableKey, WMOAreaTableEntry const*> WMOAreaTableLookupContainer;
-typedef std::unordered_map<uint32, WorldMapAreaEntry const*> WorldMapAreaByAreaIDContainer;
 
 namespace
 {
+    struct UiMapBounds
+    {
+        // these coords are mixed when calculated and used... its a mess
+        float Bounds[4];
+        bool IsUiAssignment;
+        bool IsUiLink;
+    };
+
     StorageMap _stores;
     std::map<uint64, int32> _hotfixData;
+    std::map<std::pair<uint32 /*tableHash*/, int32 /*recordId*/>, std::vector<uint8>> _hotfixBlob;
 
     AreaGroupMemberContainer _areaGroupMembers;
     ArtifactPowersContainer _artifactPowers;
@@ -348,6 +362,7 @@ namespace
     ChrSpecialzationByClassContainer _defaultChrSpecializationsByClass;
     CurvePointsContainer _curvePoints;
     EmotesTextSoundContainer _emoteTextSounds;
+    std::unordered_map<std::pair<uint32 /*level*/, int32 /*expansion*/>, ExpectedStatEntry const*> _expectedStatsByLevel;
     FactionTeamContainer _factionTeams;
     HeirloomItemsContainer _heirlooms;
     GlyphBindableSpellsContainer _glyphBindableSpells;
@@ -373,13 +388,12 @@ namespace
     PhaseGroupContainer _phasesByGroup;
     PowerTypesContainer _powerTypes;
     std::unordered_map<uint32, uint8> _pvpItemBonus;
-    std::unordered_map<std::pair<uint32 /*prestige level*/, uint32 /*honor level*/>, uint32> _pvpRewardPack;
-    PvpTalentsByPosition _pvpTalentsByPosition;
-    uint32 _pvpTalentUnlock[MAX_PVP_TALENT_TIERS][MAX_PVP_TALENT_COLUMNS];
+    PvpTalentSlotUnlockEntry const* _pvpTalentSlotUnlock[MAX_PVP_TALENT_SLOTS];
     QuestPackageItemContainer _questPackages;
     std::unordered_map<uint32, std::vector<RewardPackXCurrencyTypeEntry const*>> _rewardPackCurrencyTypes;
     std::unordered_map<uint32, std::vector<RewardPackXItemEntry const*>> _rewardPackItems;
     RulesetItemUpgradeContainer _rulesetItemUpgrade;
+    std::unordered_map<uint32, std::vector<SkillLineAbilityEntry const*>> _skillLineAbilitiesBySkillupSkill;
     SkillRaceClassInfoContainer _skillRaceClassInfoBySkill;
     SpecializationSpellsContainer _specializationSpellsBySpec;
     std::unordered_set<uint8> _spellFamilyNames;
@@ -390,25 +404,28 @@ namespace
     ToyItemIdsContainer _toys;
     std::unordered_map<uint32, std::vector<TransmogSetEntry const*>> _transmogSetsByItemModifiedAppearance;
     std::unordered_map<uint32, std::vector<TransmogSetItemEntry const*>> _transmogSetItemsByTransmogSet;
+    std::unordered_map<int32, UiMapBounds> _uiMapBounds;
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByMap[MAX_UI_MAP_SYSTEM];
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByArea[MAX_UI_MAP_SYSTEM];
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByWmoDoodadPlacement[MAX_UI_MAP_SYSTEM];
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> _uiMapAssignmentByWmoGroup[MAX_UI_MAP_SYSTEM];
+    std::unordered_set<int32> _uiMapPhases;
     WMOAreaTableLookupContainer _wmoAreaTableLookup;
-    WorldMapAreaByAreaIDContainer _worldMapAreaByAreaID;
 }
 
-typedef std::vector<std::string> DB2StoreProblemList;
-
 template<class T, template<class> class DB2>
-inline void LoadDB2(uint32& availableDb2Locales, DB2StoreProblemList& errlist, StorageMap& stores, DB2StorageBase* storage, std::string const& db2Path, uint32 defaultLocale, DB2<T> const& /*hint*/)
+inline void LoadDB2(uint32& availableDb2Locales, std::vector<std::string>& errlist, StorageMap& stores, DB2StorageBase* storage, std::string const& db2Path, uint32 defaultLocale, DB2<T> const& /*hint*/)
 {
     // validate structure
     DB2LoadInfo const* loadInfo = storage->GetLoadInfo();
     {
         std::string clientMetaString, ourMetaString;
         for (std::size_t i = 0; i < loadInfo->Meta->FieldCount; ++i)
-            for (std::size_t j = 0; j < loadInfo->Meta->ArraySizes[i]; ++j)
-                clientMetaString += loadInfo->Meta->Types[i];
+            for (std::size_t j = 0; j < loadInfo->Meta->Fields[i].ArraySize; ++j)
+                clientMetaString += loadInfo->Meta->Fields[i].Type;
 
         for (std::size_t i = loadInfo->Meta->HasIndexFieldInData() ? 0 : 1; i < loadInfo->FieldCount; ++i)
-            ourMetaString += char(std::tolower(loadInfo->Fields[i].Type));
+            ourMetaString += loadInfo->Fields[i].Type;
 
         ASSERT(clientMetaString == ourMetaString,
             "%s C++ structure fields %s do not match generated types from the client %s",
@@ -422,7 +439,7 @@ inline void LoadDB2(uint32& availableDb2Locales, DB2StoreProblemList& errlist, S
 
     if (storage->Load(db2Path + localeNames[defaultLocale] + '/', defaultLocale))
     {
-        storage->LoadFromDB();
+       storage->LoadFromDB();
         // LoadFromDB() always loads strings into enUS locale, other locales are expected to have data in corresponding _locale tables
         // so we need to make additional call to load that data in case said locale is set as default by worldserver.conf (and we do not want to load all this data from .db2 file again)
         if (defaultLocale != LOCALE_enUS)
@@ -471,12 +488,13 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
 
     std::string db2Path = dataPath + "dbc/";
 
-    DB2StoreProblemList bad_db2_files;
+    std::vector<std::string> bad_db2_files;
     uint32 availableDb2Locales = 0xFF;
 
 #define LOAD_DB2(store) LoadDB2(availableDb2Locales, bad_db2_files, _stores, &store, db2Path, defaultLocale, store)
 
     LOAD_DB2(sAchievementStore);
+    LOAD_DB2(sAnimationDataStore);
     LOAD_DB2(sAnimKitStore);
     LOAD_DB2(sAreaGroupMemberStore);
     LOAD_DB2(sAreaTableStore);
@@ -515,6 +533,7 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sChrSpecializationStore);
     LOAD_DB2(sCinematicCameraStore);
     LOAD_DB2(sCinematicSequencesStore);
+    LOAD_DB2(sContentTuningStore);
     LOAD_DB2(sConversationLineStore);
     LOAD_DB2(sCreatureDisplayInfoStore);
     LOAD_DB2(sCreatureDisplayInfoExtraStore);
@@ -534,6 +553,8 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sEmotesStore);
     LOAD_DB2(sEmotesTextStore);
     LOAD_DB2(sEmotesTextSoundStore);
+    LOAD_DB2(sExpectedStatStore);
+    LOAD_DB2(sExpectedStatModStore);
     LOAD_DB2(sFactionStore);
     LOAD_DB2(sFactionTemplateStore);
     LOAD_DB2(sGameObjectsStore);
@@ -618,6 +639,7 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sNamesProfanityStore);
     LOAD_DB2(sNamesReservedStore);
     LOAD_DB2(sNamesReservedLocaleStore);
+    LOAD_DB2(sNumTalentsAtLevelStore);
     LOAD_DB2(sOverrideSpellDataStore);
     LOAD_DB2(sPhaseStore);
     LOAD_DB2(sPhaseXPhaseGroupStore);
@@ -627,9 +649,9 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sPrestigeLevelInfoStore);
     LOAD_DB2(sPVPDifficultyStore);
     LOAD_DB2(sPVPItemStore);
-    LOAD_DB2(sPvpRewardStore);
     LOAD_DB2(sPvpTalentStore);
-    LOAD_DB2(sPvpTalentUnlockStore);
+    LOAD_DB2(sPvpTalentCategoryStore);
+    LOAD_DB2(sPvpTalentSlotUnlockStore);
     LOAD_DB2(sQuestFactionRewardStore);
     LOAD_DB2(sQuestMoneyRewardStore);
     LOAD_DB2(sQuestPackageItemStore);
@@ -641,7 +663,6 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sRewardPackXCurrencyTypeStore);
     LOAD_DB2(sRewardPackXItemStore);
     LOAD_DB2(sRulesetItemUpgradeStore);
-    LOAD_DB2(sSandboxScalingStore);
     LOAD_DB2(sScalingStatDistributionStore);
     LOAD_DB2(sScenarioStore);
     LOAD_DB2(sScenarioStepStore);
@@ -654,7 +675,6 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sSkillRaceClassInfoStore);
     LOAD_DB2(sSoundKitStore);
     LOAD_DB2(sSpecializationSpellsStore);
-    LOAD_DB2(sSpellStore);
     LOAD_DB2(sSpellAuraOptionsStore);
     LOAD_DB2(sSpellAuraRestrictionsStore);
     LOAD_DB2(sSpellCastTimesStore);
@@ -673,6 +693,7 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sSpellLearnSpellStore);
     LOAD_DB2(sSpellLevelsStore);
     LOAD_DB2(sSpellMiscStore);
+    LOAD_DB2(sSpellNameStore);
     LOAD_DB2(sSpellPowerStore);
     LOAD_DB2(sSpellPowerDifficultyStore);
     LOAD_DB2(sSpellProcsPerMinuteStore);
@@ -700,14 +721,16 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     LOAD_DB2(sTransmogSetItemStore);
     LOAD_DB2(sTransportAnimationStore);
     LOAD_DB2(sTransportRotationStore);
+    LOAD_DB2(sUiMapStore);
+    LOAD_DB2(sUiMapAssignmentStore);
+    LOAD_DB2(sUiMapLinkStore);
+    LOAD_DB2(sUiMapXMapArtStore);
     LOAD_DB2(sUnitPowerBarStore);
     LOAD_DB2(sVehicleStore);
     LOAD_DB2(sVehicleSeatStore);
     LOAD_DB2(sWMOAreaTableStore);
     LOAD_DB2(sWorldEffectStore);
-    LOAD_DB2(sWorldMapAreaStore);
     LOAD_DB2(sWorldMapOverlayStore);
-    LOAD_DB2(sWorldMapTransformsStore);
     LOAD_DB2(sWorldSafeLocsStore);
 
 #undef LOAD_DB2
@@ -816,6 +839,9 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     for (EmotesTextSoundEntry const* emoteTextSound : sEmotesTextSoundStore)
         _emoteTextSounds[EmotesTextSoundContainer::key_type(emoteTextSound->EmotesTextID, emoteTextSound->RaceID, emoteTextSound->SexID, emoteTextSound->ClassID)] = emoteTextSound;
 
+    for (ExpectedStatEntry const* expectedStat : sExpectedStatStore)
+        _expectedStatsByLevel[std::make_pair(expectedStat->Lvl, expectedStat->ExpansionID)] = expectedStat;
+
     for (FactionEntry const* faction : sFactionStore)
         if (faction->ParentFactionID)
             _factionTeams[faction->ParentFactionID].push_back(faction->ID);
@@ -969,28 +995,17 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     for (PVPItemEntry const* pvpItem : sPVPItemStore)
         _pvpItemBonus[pvpItem->ItemID] = pvpItem->ItemLevelDelta;
 
-    for (PvpRewardEntry const* pvpReward : sPvpRewardStore)
-        _pvpRewardPack[std::make_pair(pvpReward->PrestigeLevel, pvpReward->HonorLevel)] = pvpReward->RewardPackID;
-
-    for (PvpTalentEntry const* talentInfo : sPvpTalentStore)
+    for (PvpTalentSlotUnlockEntry const* talentUnlock : sPvpTalentSlotUnlockStore)
     {
-        ASSERT(talentInfo->ClassID < MAX_CLASSES);
-        ASSERT(talentInfo->TierID < MAX_PVP_TALENT_TIERS, "MAX_PVP_TALENT_TIERS must be at least %u", talentInfo->TierID + 1);
-        ASSERT(talentInfo->ColumnIndex < MAX_PVP_TALENT_COLUMNS, "MAX_PVP_TALENT_COLUMNS must be at least %u", talentInfo->ColumnIndex + 1);
-        if (!talentInfo->ClassID)
+        ASSERT(talentUnlock->Slot < (1 << MAX_PVP_TALENT_SLOTS));
+        for (int8 i = 0; i < MAX_PVP_TALENT_SLOTS; ++i)
         {
-            for (uint32 i = 1; i < MAX_CLASSES; ++i)
-                _pvpTalentsByPosition[i][talentInfo->TierID][talentInfo->ColumnIndex].push_back(talentInfo);
+            if (talentUnlock->Slot & (1 << i))
+            {
+                ASSERT(!_pvpTalentSlotUnlock[i]);
+                _pvpTalentSlotUnlock[i] = talentUnlock;
+            }
         }
-        else
-            _pvpTalentsByPosition[talentInfo->ClassID][talentInfo->TierID][talentInfo->ColumnIndex].push_back(talentInfo);
-    }
-
-    for (PvpTalentUnlockEntry const* talentUnlock : sPvpTalentUnlockStore)
-    {
-        ASSERT(talentUnlock->TierID < MAX_PVP_TALENT_TIERS, "MAX_PVP_TALENT_TIERS must be at least %u", talentUnlock->TierID + 1);
-        ASSERT(talentUnlock->ColumnIndex < MAX_PVP_TALENT_COLUMNS, "MAX_PVP_TALENT_COLUMNS must be at least %u", talentUnlock->ColumnIndex + 1);
-        _pvpTalentUnlock[talentUnlock->TierID][talentUnlock->ColumnIndex] = talentUnlock->HonorLevel;
     }
 
     for (QuestPackageItemEntry const* questPackageItem : sQuestPackageItemStore)
@@ -1010,6 +1025,9 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     for (RulesetItemUpgradeEntry const* rulesetItemUpgrade : sRulesetItemUpgradeStore)
         _rulesetItemUpgrade[rulesetItemUpgrade->ItemID] = rulesetItemUpgrade->ItemUpgradeID;
 
+    for (SkillLineAbilityEntry const* skillLineAbility : sSkillLineAbilityStore)
+        _skillLineAbilitiesBySkillupSkill[skillLineAbility->SkillupSkillLineID ? skillLineAbility->SkillupSkillLineID : skillLineAbility->SkillLine].push_back(skillLineAbility);
+
     for (SkillRaceClassInfoEntry const* entry : sSkillRaceClassInfoStore)
         if (sSkillLineStore.LookupEntry(entry->SkillID))
             _skillRaceClassInfoBySkill.insert(SkillRaceClassInfoContainer::value_type(entry->SkillID, entry));
@@ -1073,6 +1091,118 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     for (TaxiPathNodeEntry const* entry : sTaxiPathNodeStore)
         sTaxiPathNodesByPath[entry->PathID][entry->NodeIndex] = entry;
 
+    for (ToyEntry const* toy : sToyStore)
+        _toys.insert(toy->ItemID);
+
+    for (TransmogSetItemEntry const* transmogSetItem : sTransmogSetItemStore)
+    {
+        TransmogSetEntry const* set = sTransmogSetStore.LookupEntry(transmogSetItem->TransmogSetID);
+        if (!set)
+            continue;
+
+        _transmogSetsByItemModifiedAppearance[transmogSetItem->ItemModifiedAppearanceID].push_back(set);
+        _transmogSetItemsByTransmogSet[transmogSetItem->TransmogSetID].push_back(transmogSetItem);
+    }
+
+    std::unordered_multimap<int32, UiMapAssignmentEntry const*> uiMapAssignmentByUiMap;
+    for (UiMapAssignmentEntry const* uiMapAssignment : sUiMapAssignmentStore)
+    {
+        uiMapAssignmentByUiMap.emplace(uiMapAssignment->UiMapID, uiMapAssignment);
+        if (UiMapEntry const* uiMap = sUiMapStore.LookupEntry(uiMapAssignment->UiMapID))
+        {
+            ASSERT(uiMap->System < MAX_UI_MAP_SYSTEM, "MAX_TALENT_TIERS must be at least %u", uiMap->System + 1);
+            if (uiMapAssignment->MapID >= 0)
+                _uiMapAssignmentByMap[uiMap->System].emplace(uiMapAssignment->MapID, uiMapAssignment);
+            if (uiMapAssignment->AreaID)
+                _uiMapAssignmentByArea[uiMap->System].emplace(uiMapAssignment->AreaID, uiMapAssignment);
+            if (uiMapAssignment->WmoDoodadPlacementID)
+                _uiMapAssignmentByWmoDoodadPlacement[uiMap->System].emplace(uiMapAssignment->WmoDoodadPlacementID, uiMapAssignment);
+            if (uiMapAssignment->WmoGroupID)
+                _uiMapAssignmentByWmoGroup[uiMap->System].emplace(uiMapAssignment->WmoGroupID, uiMapAssignment);
+        }
+    }
+
+    std::unordered_map<std::pair<int32, uint32>, UiMapLinkEntry const*> uiMapLinks;
+    for (UiMapLinkEntry const* uiMapLink : sUiMapLinkStore)
+        uiMapLinks[std::make_pair(uiMapLink->ParentUiMapID, uint32(uiMapLink->ChildUiMapID))] = uiMapLink;
+
+    for (UiMapEntry const* uiMap : sUiMapStore)
+    {
+        UiMapBounds& bounds = _uiMapBounds[uiMap->ID];
+        memset(&bounds, 0, sizeof(bounds));
+        if (UiMapEntry const* parentUiMap = sUiMapStore.LookupEntry(uiMap->ParentUiMapID))
+        {
+            if (parentUiMap->Flags & 0x80)
+                continue;
+
+            UiMapAssignmentEntry const* uiMapAssignment = nullptr;
+            UiMapAssignmentEntry const* parentUiMapAssignment = nullptr;
+            for (auto uiMapAssignmentForMap : Trinity::Containers::MapEqualRange(uiMapAssignmentByUiMap, uiMap->ID))
+            {
+                if (uiMapAssignmentForMap.second->MapID >= 0 &&
+                    uiMapAssignmentForMap.second->Region[1].X - uiMapAssignmentForMap.second->Region[0].X > 0 &&
+                    uiMapAssignmentForMap.second->Region[1].Y - uiMapAssignmentForMap.second->Region[0].Y > 0)
+                {
+                    uiMapAssignment = uiMapAssignmentForMap.second;
+                    break;
+                }
+            }
+
+            if (!uiMapAssignment)
+                continue;
+
+            for (auto uiMapAssignmentForMap : Trinity::Containers::MapEqualRange(uiMapAssignmentByUiMap, uiMap->ParentUiMapID))
+            {
+                if (uiMapAssignmentForMap.second->MapID == uiMapAssignment->MapID &&
+                    uiMapAssignmentForMap.second->Region[1].X - uiMapAssignmentForMap.second->Region[0].X > 0 &&
+                    uiMapAssignmentForMap.second->Region[1].Y - uiMapAssignmentForMap.second->Region[0].Y > 0)
+                {
+                    parentUiMapAssignment = uiMapAssignmentForMap.second;
+                    break;
+                }
+            }
+
+            if (!parentUiMapAssignment)
+                continue;
+
+            float parentXsize = parentUiMapAssignment->Region[1].X - parentUiMapAssignment->Region[0].X;
+            float parentYsize = parentUiMapAssignment->Region[1].Y - parentUiMapAssignment->Region[0].Y;
+            float bound0scale = (uiMapAssignment->Region[1].X - parentUiMapAssignment->Region[0].X) / parentXsize;
+            float bound0 = ((1.0f - bound0scale) * parentUiMapAssignment->UiMax.Y) + (bound0scale * parentUiMapAssignment->UiMin.Y);
+            float bound2scale = (uiMapAssignment->Region[0].X - parentUiMapAssignment->Region[0].X) / parentXsize;
+            float bound2 = ((1.0f - bound2scale) * parentUiMapAssignment->UiMax.Y) + (bound2scale * parentUiMapAssignment->UiMin.Y);
+            float bound1scale = (uiMapAssignment->Region[1].Y - parentUiMapAssignment->Region[0].Y) / parentYsize;
+            float bound1 = ((1.0f - bound1scale) * parentUiMapAssignment->UiMax.X) + (bound1scale * parentUiMapAssignment->UiMin.X);
+            float bound3scale = (uiMapAssignment->Region[0].Y - parentUiMapAssignment->Region[0].Y) / parentYsize;
+            float bound3 = ((1.0f - bound3scale) * parentUiMapAssignment->UiMax.X) + (bound3scale * parentUiMapAssignment->UiMin.X);
+            if ((bound3 - bound1) > 0.0f || (bound2 - bound0) > 0.0f)
+            {
+                bounds.Bounds[0] = bound0;
+                bounds.Bounds[1] = bound1;
+                bounds.Bounds[2] = bound2;
+                bounds.Bounds[3] = bound3;
+                bounds.IsUiAssignment = true;
+            }
+        }
+
+        if (UiMapLinkEntry const* uiMapLink = Trinity::Containers::MapGetValuePtr(uiMapLinks, std::make_pair(uiMap->ParentUiMapID, uiMap->ID)))
+        {
+            bounds.IsUiAssignment = false;
+            bounds.IsUiLink = true;
+            bounds.Bounds[0] = uiMapLink->UiMin.Y;
+            bounds.Bounds[1] = uiMapLink->UiMin.X;
+            bounds.Bounds[2] = uiMapLink->UiMax.Y;
+            bounds.Bounds[3] = uiMapLink->UiMax.X;
+        }
+    }
+
+    for (UiMapXMapArtEntry const* uiMapArt : sUiMapXMapArtStore)
+        if (uiMapArt->PhaseID)
+            _uiMapPhases.insert(uiMapArt->PhaseID);
+
+    for (WMOAreaTableEntry const* entry : sWMOAreaTableStore)
+        _wmoAreaTableLookup[WMOAreaTableKey(entry->WmoID, entry->NameSetID, entry->WmoGroupID)] = entry;
+
     // Initialize global taxinodes mask
     // include existed nodes that have at least single not spell base (scripted) path
     {
@@ -1093,7 +1223,7 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
                 continue;
 
             // valid taxi network node
-            uint8  field = (uint8)((node->ID - 1) / 8);
+            uint32 field = uint32((node->ID - 1) / 8);
             uint32 submask = 1 << ((node->ID - 1) % 8);
 
             sTaxiNodesMask[field] |= submask;
@@ -1102,32 +1232,15 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
             if (node->Flags & TAXI_NODE_FLAG_ALLIANCE)
                 sAllianceTaxiNodesMask[field] |= submask;
 
-            uint32 nodeMap;
-            DeterminaAlternateMapPosition(node->ContinentID, node->Pos.X, node->Pos.Y, node->Pos.Z, &nodeMap);
-            if (nodeMap < 2)
+            int32 uiMapId = -1;
+            if (!GetUiMapPosition(node->Pos.X, node->Pos.Y, node->Pos.Z, node->ContinentID, 0, 0, 0, UI_MAP_SYSTEM_ADVENTURE, false, &uiMapId))
+                GetUiMapPosition(node->Pos.X, node->Pos.Y, node->Pos.Z, node->ContinentID, 0, 0, 0, UI_MAP_SYSTEM_TAXI, false, &uiMapId);
+
+            if (uiMapId == 985 || uiMapId == 986)
                 sOldContinentsNodesMask[field] |= submask;
         }
     }
 
-    for (ToyEntry const* toy : sToyStore)
-        _toys.insert(toy->ItemID);
-
-    for (TransmogSetItemEntry const* transmogSetItem : sTransmogSetItemStore)
-    {
-        TransmogSetEntry const* set = sTransmogSetStore.LookupEntry(transmogSetItem->TransmogSetID);
-        if (!set)
-            continue;
-
-        _transmogSetsByItemModifiedAppearance[transmogSetItem->ItemModifiedAppearanceID].push_back(set);
-        _transmogSetItemsByTransmogSet[transmogSetItem->TransmogSetID].push_back(transmogSetItem);
-    }
-
-    for (WMOAreaTableEntry const* entry : sWMOAreaTableStore)
-        _wmoAreaTableLookup[WMOAreaTableKey(entry->WmoID, entry->NameSetID, entry->WmoGroupID)] = entry;
-
-    for (WorldMapAreaEntry const* worldMapArea : sWorldMapAreaStore)
-        _worldMapAreaByAreaID[worldMapArea->AreaID] = worldMapArea;
-
     // error checks
     if (bad_db2_files.size() == _stores.size())
     {
@@ -1145,13 +1258,13 @@ void DB2Manager::LoadStores(std::string const& dataPath, uint32 defaultLocale)
     }
 
     // Check loaded DB2 files proper version
-    if (!sAreaTableStore.LookupEntry(9531) ||                // last area added in 7.3.5 (25996)
-        !sCharTitlesStore.LookupEntry(522) ||                // last char title added in 7.3.5 (25996)
-        !sGemPropertiesStore.LookupEntry(3632) ||            // last gem property added in 7.3.5 (25996)
-        !sItemStore.LookupEntry(157831) ||                   // last item added in 7.3.5 (25996)
-        !sItemExtendedCostStore.LookupEntry(6300) ||         // last item extended cost added in 7.3.5 (25996)
-        !sMapStore.LookupEntry(1903) ||                      // last map added in 7.3.5 (25996)
-        !sSpellStore.LookupEntry(263166))                    // last spell added in 7.3.5 (25996)
+    if (!sAreaTableStore.LookupEntry(10048) ||                // last area added in 8.0.1 (28153)
+        !sCharTitlesStore.LookupEntry(633) ||                // last char title added in 8.0.1 (28153)
+        !sGemPropertiesStore.LookupEntry(3745) ||            // last gem property added in 8.0.1 (28153)
+        !sItemStore.LookupEntry(164760) ||                   // last item added in 8.0.1 (28153)
+        !sItemExtendedCostStore.LookupEntry(6448) ||         // last item extended cost added in 8.0.1 (28153)
+        !sMapStore.LookupEntry(2103) ||                      // last map added in 8.0.1 (28153)
+        !sSpellNameStore.LookupEntry(281872))                // last spell added in 8.0.1 (28153)
     {
         TC_LOG_ERROR("misc", "You have _outdated_ DB2 files. Please extract correct versions from current using client.");
         exit(1);
@@ -1193,9 +1306,9 @@ void DB2Manager::LoadHotfixData()
         uint32 tableHash = fields[1].GetUInt32();
         int32 recordId = fields[2].GetInt32();
         bool deleted = fields[3].GetBool();
-        if (_stores.find(tableHash) == _stores.end())
+        if (_stores.find(tableHash) == _stores.end() && _hotfixBlob.find(std::make_pair(tableHash, recordId)) == _hotfixBlob.end())
         {
-            TC_LOG_ERROR("sql.sql", "Table `hotfix_data` references unknown DB2 store by hash 0x%X in hotfix id %d", tableHash, id);
+            TC_LOG_ERROR("sql.sql", "Table `hotfix_data` references unknown DB2 store by hash 0x%X and has no reference to `hotfix_blob` in hotfix id %d", tableHash, id);
             continue;
         }
 
@@ -1210,7 +1323,40 @@ void DB2Manager::LoadHotfixData()
             if (DB2StorageBase* store = Trinity::Containers::MapGetValuePtr(_stores, itr->first.first))
                 store->EraseRecord(itr->first.second);
 
-    TC_LOG_INFO("server.loading", ">> Loaded %u hotfix records in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
+    TC_LOG_INFO("server.loading", ">> Loaded " SZFMTD " hotfix records in %u ms", _hotfixData.size(), GetMSTimeDiffToNow(oldMSTime));
+}
+
+void DB2Manager::LoadHotfixBlob()
+{
+    uint32 oldMSTime = getMSTime();
+    _hotfixBlob.clear();
+
+    QueryResult result = HotfixDatabase.Query("SELECT TableHash, RecordId, `Blob` FROM hotfix_blob ORDER BY TableHash");
+
+    if (!result)
+    {
+        TC_LOG_INFO("server.loading", ">> Loaded 0 hotfix blob entries.");
+        return;
+    }
+
+    do
+    {
+        Field* fields = result->Fetch();
+
+        uint32 tableHash = fields[0].GetUInt32();
+        auto storeItr = _stores.find(tableHash);
+        if (storeItr != _stores.end())
+        {
+            TC_LOG_ERROR("server.loading", "Table hash 0x%X points to a loaded DB2 store %s, fill related table instead of hotfix_blob",
+                tableHash, storeItr->second->GetFileName().c_str());
+            continue;
+        }
+
+        int32 recordId = fields[1].GetInt32();
+        _hotfixBlob[std::make_pair(tableHash, recordId)] = fields[2].GetBinary();
+    } while (result->NextRow());
+
+    TC_LOG_INFO("server.loading", ">> Loaded " SZFMTD " hotfix blob records in %u ms", _hotfixBlob.size(), GetMSTimeDiffToNow(oldMSTime));
 }
 
 std::map<uint64, int32> const& DB2Manager::GetHotfixData() const
@@ -1218,6 +1364,11 @@ std::map<uint64, int32> const& DB2Manager::GetHotfixData() const
     return _hotfixData;
 }
 
+std::vector<uint8> const* DB2Manager::GetHotfixBlobData(uint32 tableHash, int32 recordId)
+{
+    return Trinity::Containers::MapGetValuePtr(_hotfixBlob, std::make_pair(tableHash, recordId));
+}
+
 void DB2Manager::InsertNewHotfix(uint32 tableHash, uint32 recordId)
 {
     _hotfixData[MAKE_PAIR64(tableHash, ++_maxHotfixId)] = recordId;
@@ -1545,6 +1696,98 @@ EmotesTextSoundEntry const* DB2Manager::GetTextSoundEmoteFor(uint32 emote, uint8
     return nullptr;
 }
 
+template<float(ExpectedStatModEntry::*field)>
+struct ExpectedStatModReducer
+{
+    float operator()(float mod, ExpectedStatModEntry const* expectedStatMod)
+    {
+        return mod * (expectedStatMod ? expectedStatMod->*field : 1.0f);
+    }
+};
+
+float DB2Manager::EvaluateExpectedStat(ExpectedStatType stat, uint32 level, int32 expansion, uint32 contentTuningId, Classes unitClass) const
+{
+    auto expectedStatItr = _expectedStatsByLevel.find(std::make_pair(level, expansion));
+    if (expectedStatItr == _expectedStatsByLevel.end())
+        expectedStatItr = _expectedStatsByLevel.find(std::make_pair(level, -2));
+
+    if (expectedStatItr == _expectedStatsByLevel.end())
+        return 1.0f;
+
+    std::array<ExpectedStatModEntry const*, 3> mods;
+    mods.fill(nullptr);
+    if (ContentTuningEntry const* contentTuning = sContentTuningStore.LookupEntry(contentTuningId))
+    {
+        mods[0] = sExpectedStatModStore.LookupEntry(contentTuning->ExpectedStatModID);
+        mods[1] = sExpectedStatModStore.LookupEntry(contentTuning->DifficultyESMID);
+    }
+
+    switch (unitClass)
+    {
+        case CLASS_WARRIOR:
+            mods[2] = sExpectedStatModStore.LookupEntry(4);
+            break;
+        case CLASS_PALADIN:
+            mods[2] = sExpectedStatModStore.LookupEntry(2);
+            break;
+        case CLASS_ROGUE:
+            mods[2] = sExpectedStatModStore.LookupEntry(3);
+            break;
+        case CLASS_MAGE:
+            mods[2] = sExpectedStatModStore.LookupEntry(1);
+            break;
+        default:
+            break;
+    }
+
+    float value = 0.0f;
+    switch (stat)
+    {
+        case ExpectedStatType::CreatureHealth:
+            value = std::accumulate(mods.begin(), mods.end(), expectedStatItr->second->CreatureHealth,
+                ExpectedStatModReducer<&ExpectedStatModEntry::CreatureHealthMod>());
+            break;
+        case ExpectedStatType::PlayerHealth:
+            value = std::accumulate(mods.begin(), mods.end(), expectedStatItr->second->PlayerHealth,
+                ExpectedStatModReducer<&ExpectedStatModEntry::PlayerHealthMod>());
+            break;
+        case ExpectedStatType::CreatureAutoAttackDps:
+            value = std::accumulate(mods.begin(), mods.end(), expectedStatItr->second->CreatureAutoAttackDps,
+                ExpectedStatModReducer<&ExpectedStatModEntry::CreatureAutoAttackDPSMod>());
+            break;
+        case ExpectedStatType::CreatureArmor:
+            value = std::accumulate(mods.begin(), mods.end(), expectedStatItr->second->CreatureArmor,
+                ExpectedStatModReducer<&ExpectedStatModEntry::CreatureArmorMod>());
+            break;
+        case ExpectedStatType::PlayerMana:
+            value = std::accumulate(mods.begin(), mods.end(), expectedStatItr->second->PlayerMana,
+                ExpectedStatModReducer<&ExpectedStatModEntry::PlayerManaMod>());
+            break;
+        case ExpectedStatType::PlayerPrimaryStat:
+            value = std::accumulate(mods.begin(), mods.end(), expectedStatItr->second->PlayerPrimaryStat,
+                ExpectedStatModReducer<&ExpectedStatModEntry::PlayerPrimaryStatMod>());
+            break;
+        case ExpectedStatType::PlayerSecondaryStat:
+            value = std::accumulate(mods.begin(), mods.end(), expectedStatItr->second->PlayerSecondaryStat,
+                ExpectedStatModReducer<&ExpectedStatModEntry::PlayerSecondaryStatMod>());
+            break;
+        case ExpectedStatType::ArmorConstant:
+            value = std::accumulate(mods.begin(), mods.end(), expectedStatItr->second->ArmorConstant,
+                ExpectedStatModReducer<&ExpectedStatModEntry::ArmorConstantMod>());
+            break;
+        case ExpectedStatType::None:
+            break;
+        case ExpectedStatType::CreatureSpellDamage:
+            value = std::accumulate(mods.begin(), mods.end(), expectedStatItr->second->CreatureSpellDamage,
+                ExpectedStatModReducer<&ExpectedStatModEntry::CreatureSpellDamageMod>());
+            break;
+        default:
+            break;
+    }
+
+    return value;
+}
+
 std::vector<uint32> const* DB2Manager::GetFactionTeamList(uint32 faction) const
 {
     auto itr = _factionTeams.find(faction);
@@ -1901,14 +2144,26 @@ ResponseCodes DB2Manager::ValidateName(std::wstring const& name, LocaleConstant
     return CHAR_NAME_SUCCESS;
 }
 
-uint8 DB2Manager::GetMaxPrestige() const
+int32 DB2Manager::GetNumTalentsAtLevel(uint32 level, Classes playerClass)
 {
-    uint8 max = 0;
-    for (PrestigeLevelInfoEntry const* prestigeLevelInfo : sPrestigeLevelInfoStore)
-        if (!prestigeLevelInfo->IsDisabled())
-            max = std::max(prestigeLevelInfo->PrestigeLevel, max);
+    NumTalentsAtLevelEntry const* numTalentsAtLevel = sNumTalentsAtLevelStore.LookupEntry(level);
+    if (!numTalentsAtLevel)
+        numTalentsAtLevel = sNumTalentsAtLevelStore.LookupEntry(sNumTalentsAtLevelStore.GetNumRows() - 1);
 
-    return max;
+    if (numTalentsAtLevel)
+    {
+        switch (playerClass)
+        {
+            case CLASS_DEATH_KNIGHT:
+                return numTalentsAtLevel->NumTalentsDeathKnight;
+            case CLASS_DEMON_HUNTER:
+                return numTalentsAtLevel->NumTalentsDemonHunter;
+            default:
+                return numTalentsAtLevel->NumTalents;
+        }
+    }
+
+    return 0;
 }
 
 PVPDifficultyEntry const* DB2Manager::GetBattlegroundBracketByLevel(uint32 mapid, uint32 level)
@@ -1941,27 +2196,34 @@ PVPDifficultyEntry const* DB2Manager::GetBattlegroundBracketById(uint32 mapid, B
     return nullptr;
 }
 
-uint32 DB2Manager::GetRewardPackIDForPvpRewardByHonorLevelAndPrestige(uint8 honorLevel, uint8 prestige) const
+uint32 DB2Manager::GetRequiredLevelForPvpTalentSlot(uint8 slot, Classes class_) const
 {
-    auto itr = _pvpRewardPack.find({ prestige, honorLevel });
-    if (itr == _pvpRewardPack.end())
-        itr = _pvpRewardPack.find({ 0, honorLevel });
-
-    if (itr == _pvpRewardPack.end())
-        return 0;
+    ASSERT(slot < MAX_PVP_TALENT_SLOTS);
+    if (_pvpTalentSlotUnlock[slot])
+    {
+        switch (class_)
+        {
+            case CLASS_DEATH_KNIGHT:
+                return _pvpTalentSlotUnlock[slot]->DeathKnightLevelRequired;
+            case CLASS_DEMON_HUNTER:
+                return _pvpTalentSlotUnlock[slot]->DemonHunterLevelRequired;
+            default:
+                break;
+        }
+        return _pvpTalentSlotUnlock[slot]->LevelRequired;
+    }
 
-    return itr->second;
+    return 0;
 }
 
-uint32 DB2Manager::GetRequiredHonorLevelForPvpTalent(PvpTalentEntry const* talentInfo) const
+int32 DB2Manager::GetPvpTalentNumSlotsAtLevel(uint32 level, Classes class_) const
 {
-    ASSERT(talentInfo);
-    return _pvpTalentUnlock[talentInfo->TierID][talentInfo->ColumnIndex];
-}
+    int32 slots = 0;
+    for (uint8 slot = 0; slot < MAX_PVP_TALENT_SLOTS; ++slot)
+        if (level >= GetRequiredLevelForPvpTalentSlot(slot, class_))
+            ++slots;
 
-std::vector<PvpTalentEntry const*> const& DB2Manager::GetPvpTalentsByPosition(uint32 class_, uint32 tier, uint32 column) const
-{
-    return _pvpTalentsByPosition[class_][tier][column];
+    return slots;
 }
 
 std::vector<QuestPackageItemEntry const*> const* DB2Manager::GetQuestPackageItems(uint32 questPackageID) const
@@ -2059,6 +2321,11 @@ uint32 DB2Manager::GetRulesetItemUpgrade(uint32 itemId) const
     return 0;
 }
 
+std::vector<SkillLineAbilityEntry const*> const* DB2Manager::GetSkillLineAbilitiesBySkill(uint32 skillId) const
+{
+    return Trinity::Containers::MapGetValuePtr(_skillLineAbilitiesBySkillupSkill, skillId);
+}
+
 SkillRaceClassInfoEntry const* DB2Manager::GetSkillRaceClassInfo(uint32 skill, uint8 race, uint8 class_)
 {
     auto bounds = _skillRaceClassInfoBySkill.equal_range(skill);
@@ -2180,99 +2447,354 @@ std::vector<TransmogSetItemEntry const*> const* DB2Manager::GetTransmogSetItems(
     return Trinity::Containers::MapGetValuePtr(_transmogSetItemsByTransmogSet, transmogSetId);
 }
 
-WMOAreaTableEntry const* DB2Manager::GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const
+struct UiMapAssignmentStatus
 {
-    auto i = _wmoAreaTableLookup.find(WMOAreaTableKey(int16(rootId), int8(adtId), groupId));
-    if (i != _wmoAreaTableLookup.end())
-        return i->second;
+    UiMapAssignmentEntry const* UiMapAssignment = nullptr;
+    // distances if inside
+    struct
+    {
+        float DistanceToRegionCenterSquared = std::numeric_limits<float>::max();
+        float DistanceToRegionBottom = std::numeric_limits<float>::max();
+    } Inside;
 
-    return nullptr;
-}
+    // distances if outside
+    struct
+    {
+        float DistanceToRegionEdgeSquared = std::numeric_limits<float>::max();
+        float DistanceToRegionTop = std::numeric_limits<float>::max();
+        float DistanceToRegionBottom = std::numeric_limits<float>::max();
+    } Outside;
+
+    int8 MapPriority = 3;
+    int8 AreaPriority = -1;
+    int8 WmoPriority = 3;
 
-uint32 DB2Manager::GetVirtualMapForMapAndZone(uint32 mapId, uint32 zoneId) const
+    bool IsInside() const
+    {
+        return Outside.DistanceToRegionEdgeSquared < std::numeric_limits<float>::epsilon() &&
+            std::abs(Outside.DistanceToRegionTop) < std::numeric_limits<float>::epsilon() &&
+            std::abs(Outside.DistanceToRegionBottom) < std::numeric_limits<float>::epsilon();
+    }
+};
+
+static bool operator<(UiMapAssignmentStatus const& left, UiMapAssignmentStatus const& right)
 {
-    if (mapId != 530 && mapId != 571 && mapId != 732)   // speed for most cases
-        return mapId;
+    bool leftInside = left.IsInside();
+    bool rightInside = right.IsInside();
+    if (leftInside != rightInside)
+        return leftInside;
+
+    if (left.UiMapAssignment && right.UiMapAssignment &&
+        left.UiMapAssignment->UiMapID == right.UiMapAssignment->UiMapID &&
+        left.UiMapAssignment->OrderIndex != right.UiMapAssignment->OrderIndex)
+        return left.UiMapAssignment->OrderIndex < right.UiMapAssignment->OrderIndex;
+
+    if (left.WmoPriority != right.WmoPriority)
+        return left.WmoPriority < right.WmoPriority;
+
+    if (left.AreaPriority != right.AreaPriority)
+        return left.AreaPriority < right.AreaPriority;
+
+    if (left.MapPriority != right.MapPriority)
+        return left.MapPriority < right.MapPriority;
+
+    if (leftInside)
+    {
+        if (left.Inside.DistanceToRegionBottom != right.Inside.DistanceToRegionBottom)
+            return left.Inside.DistanceToRegionBottom < right.Inside.DistanceToRegionBottom;
 
-    auto itr = _worldMapAreaByAreaID.find(zoneId);
-    if (itr != _worldMapAreaByAreaID.end())
-        return itr->second->DisplayMapID >= 0 ? itr->second->DisplayMapID : itr->second->MapID;
+        float leftUiSizeX = left.UiMapAssignment ? (left.UiMapAssignment->UiMax.X - left.UiMapAssignment->UiMin.X) : 0.0f;
+        float rightUiSizeX = right.UiMapAssignment ? (right.UiMapAssignment->UiMax.X - right.UiMapAssignment->UiMin.X) : 0.0f;
 
-    return mapId;
+        if (leftUiSizeX > std::numeric_limits<float>::epsilon() && rightUiSizeX > std::numeric_limits<float>::epsilon())
+        {
+            float leftScale = (left.UiMapAssignment->Region[1].X - left.UiMapAssignment->Region[0].X) / leftUiSizeX;
+            float rightScale = (right.UiMapAssignment->Region[1].X - right.UiMapAssignment->Region[0].X) / rightUiSizeX;
+            if (leftScale != rightScale)
+                return leftScale < rightScale;
+        }
+
+        if (left.Inside.DistanceToRegionCenterSquared != right.Inside.DistanceToRegionCenterSquared)
+            return left.Inside.DistanceToRegionCenterSquared < right.Inside.DistanceToRegionCenterSquared;
+    }
+    else
+    {
+        if (left.Outside.DistanceToRegionTop != right.Outside.DistanceToRegionTop)
+            return left.Outside.DistanceToRegionTop < right.Outside.DistanceToRegionTop;
+
+        if (left.Outside.DistanceToRegionBottom != right.Outside.DistanceToRegionBottom)
+            return left.Outside.DistanceToRegionBottom < right.Outside.DistanceToRegionBottom;
+
+        if (left.Outside.DistanceToRegionEdgeSquared != right.Outside.DistanceToRegionEdgeSquared)
+            return left.Outside.DistanceToRegionEdgeSquared < right.Outside.DistanceToRegionEdgeSquared;
+    }
+
+    return true;
 }
 
-void DB2Manager::Zone2MapCoordinates(uint32 areaId, float& x, float& y) const
+static bool CheckUiMapAssignmentStatus(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId,
+    UiMapAssignmentEntry const* uiMapAssignment, UiMapAssignmentStatus* status)
 {
-    auto itr = _worldMapAreaByAreaID.find(areaId);
-    if (itr == _worldMapAreaByAreaID.end())
-        return;
+    status->UiMapAssignment = uiMapAssignment;
+    // x,y not in region
+    if (x < uiMapAssignment->Region[0].X || x > uiMapAssignment->Region[1].X || y < uiMapAssignment->Region[0].Y || y > uiMapAssignment->Region[1].Y)
+    {
+        float xDiff, yDiff;
+        if (x >= uiMapAssignment->Region[0].X)
+        {
+            xDiff = 0.0f;
+            if (x > uiMapAssignment->Region[1].X)
+                xDiff = x - uiMapAssignment->Region[0].X;
+        }
+        else
+            xDiff = uiMapAssignment->Region[0].X - x;
 
-    std::swap(x, y);                                         // at client map coords swapped
-    x = x*((itr->second->LocBottom - itr->second->LocTop) / 100) + itr->second->LocTop;
-    y = y*((itr->second->LocRight - itr->second->LocLeft) / 100) + itr->second->LocLeft;        // client y coord from top to down
+        if (y >= uiMapAssignment->Region[0].Y)
+        {
+            yDiff = 0.0f;
+            if (y > uiMapAssignment->Region[1].Y)
+                yDiff = y - uiMapAssignment->Region[0].Y;
+        }
+        else
+            yDiff = uiMapAssignment->Region[0].Y - y;
+
+        status->Outside.DistanceToRegionEdgeSquared = xDiff * xDiff + yDiff * yDiff;
+    }
+    else
+    {
+        status->Inside.DistanceToRegionCenterSquared =
+            (x - (uiMapAssignment->Region[0].X + uiMapAssignment->Region[1].X) * 0.5f) * (x - (uiMapAssignment->Region[0].X + uiMapAssignment->Region[1].X) * 0.5f)
+            + (y - (uiMapAssignment->Region[0].Y + uiMapAssignment->Region[1].Y) * 0.5f) * (y - (uiMapAssignment->Region[0].Y + uiMapAssignment->Region[1].Y) * 0.5f);
+        status->Outside.DistanceToRegionEdgeSquared = 0.0f;
+    }
+
+    // z not in region
+    if (z < uiMapAssignment->Region[0].Z || z > uiMapAssignment->Region[1].Z)
+    {
+        if (z < uiMapAssignment->Region[1].Z)
+        {
+            if (z < uiMapAssignment->Region[0].Z)
+                status->Outside.DistanceToRegionBottom = std::min(uiMapAssignment->Region[0].Z - z, 10000.0f);
+        }
+        else
+            status->Outside.DistanceToRegionTop = std::min(z - uiMapAssignment->Region[1].Z, 10000.0f);
+    }
+    else
+    {
+        status->Outside.DistanceToRegionTop = 0.0f;
+        status->Outside.DistanceToRegionBottom = 0.0f;
+        status->Inside.DistanceToRegionBottom = std::min(uiMapAssignment->Region[0].Z - z, 10000.0f);
+    }
+
+    if (areaId && uiMapAssignment->AreaID)
+    {
+        int8 areaPriority = 0;
+        if (areaId)
+        {
+            while (areaId != uiMapAssignment->AreaID)
+            {
+                if (AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId))
+                {
+                    areaId = areaEntry->ParentAreaID;
+                    ++areaPriority;
+                }
+                else
+                    return false;
+            }
+        }
+        else
+            return false;
+
+        status->AreaPriority = areaPriority;
+    }
+
+    if (mapId >= 0 && uiMapAssignment->MapID >= 0)
+    {
+        if (mapId != uiMapAssignment->MapID)
+        {
+            if (MapEntry const* mapEntry = sMapStore.LookupEntry(mapId))
+            {
+                if (mapEntry->ParentMapID == uiMapAssignment->MapID)
+                    status->MapPriority = 1;
+                else if (mapEntry->CosmeticParentMapID == uiMapAssignment->MapID)
+                    status->MapPriority = 2;
+                else
+                    return false;
+            }
+            else
+                return false;
+        }
+        else
+            status->MapPriority = 0;
+    }
+
+    if (wmoGroupId || wmoDoodadPlacementId)
+    {
+        if (uiMapAssignment->WmoGroupID || uiMapAssignment->WmoDoodadPlacementID)
+        {
+            bool hasDoodadPlacement = false;
+            if (wmoDoodadPlacementId && uiMapAssignment->WmoDoodadPlacementID)
+            {
+                if (wmoDoodadPlacementId != uiMapAssignment->WmoDoodadPlacementID)
+                    return false;
+
+                hasDoodadPlacement = true;
+            }
+
+            if (wmoGroupId && uiMapAssignment->WmoGroupID)
+            {
+                if (wmoGroupId != uiMapAssignment->WmoGroupID)
+                    return false;
+
+                if (hasDoodadPlacement)
+                    status->WmoPriority = 0;
+                else
+                    status->WmoPriority = 2;
+            }
+            else if (hasDoodadPlacement)
+                status->WmoPriority = 1;
+        }
+    }
+
+    return true;
 }
 
-void DB2Manager::Map2ZoneCoordinates(uint32 areaId, float& x, float& y) const
+static UiMapAssignmentEntry const* FindNearestMapAssignment(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system)
 {
-    auto itr = _worldMapAreaByAreaID.find(areaId);
-    if (itr == _worldMapAreaByAreaID.end())
-        return;
+    UiMapAssignmentStatus nearestMapAssignment;
+    auto iterateUiMapAssignments = [&](std::unordered_multimap<int32, UiMapAssignmentEntry const*> const& assignments, int32 id)
+    {
+        for (auto assignment : Trinity::Containers::MapEqualRange(assignments, id))
+        {
+            UiMapAssignmentStatus status;
+            if (CheckUiMapAssignmentStatus(x, y, z, mapId, areaId, wmoDoodadPlacementId, wmoGroupId, assignment.second, &status))
+                if (status < nearestMapAssignment)
+                    nearestMapAssignment = status;
+        }
+    };
+
+    iterateUiMapAssignments(_uiMapAssignmentByWmoGroup[system], wmoGroupId);
+    iterateUiMapAssignments(_uiMapAssignmentByWmoDoodadPlacement[system], wmoDoodadPlacementId);
+
+    AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
+    while (areaEntry)
+    {
+        iterateUiMapAssignments(_uiMapAssignmentByArea[system], areaEntry->ID);
+        areaEntry = sAreaTableStore.LookupEntry(areaEntry->ParentAreaID);
+    }
 
-    x = (x - itr->second->LocTop) / ((itr->second->LocBottom - itr->second->LocTop) / 100);
-    y = (y - itr->second->LocLeft) / ((itr->second->LocRight - itr->second->LocLeft) / 100);    // client y coord from top to down
-    std::swap(x, y);                                         // client have map coords swapped
+    if (MapEntry const* mapEntry = sMapStore.LookupEntry(mapId))
+    {
+        iterateUiMapAssignments(_uiMapAssignmentByMap[system], mapEntry->ID);
+        if (mapEntry->ParentMapID >= 0)
+            iterateUiMapAssignments(_uiMapAssignmentByMap[system], mapEntry->ParentMapID);
+        if (mapEntry->CosmeticParentMapID >= 0)
+            iterateUiMapAssignments(_uiMapAssignmentByMap[system], mapEntry->CosmeticParentMapID);
+    }
+
+    return nearestMapAssignment.UiMapAssignment;
 }
 
-void DB2Manager::DeterminaAlternateMapPosition(uint32 mapId, float x, float y, float z, uint32* newMapId /*= nullptr*/, DBCPosition2D* newPos /*= nullptr*/)
+static DBCPosition2D CalculateGlobalUiMapPosition(int32 uiMapID, DBCPosition2D uiPosition)
 {
-    ASSERT(newMapId || newPos);
-    WorldMapTransformsEntry const* transformation = nullptr;
-    for (WorldMapTransformsEntry const* transform : sWorldMapTransformsStore)
+    UiMapEntry const* uiMap = sUiMapStore.LookupEntry(uiMapID);
+    while (uiMap)
     {
-        if (transform->MapID != mapId)
-            continue;
-        if (transform->AreaID)
-            continue;
-        if (transform->Flags & WORLD_MAP_TRANSFORMS_FLAG_DUNGEON)
-            continue;
-        if (transform->RegionMin.X > x || transform->RegionMax.X < x)
-            continue;
-        if (transform->RegionMin.Y > y || transform->RegionMax.Y < y)
-            continue;
-        if (transform->RegionMin.Z > z || transform->RegionMax.Z < z)
-            continue;
+        if (uiMap->Type <= UI_MAP_TYPE_CONTINENT)
+            break;
+
+        UiMapBounds const* bounds = Trinity::Containers::MapGetValuePtr(_uiMapBounds, uiMap->ID);
+        if (!bounds || !bounds->IsUiAssignment)
+            break;
 
-        if (!transformation || transformation->Priority < transform->Priority)
-            transformation = transform;
+        uiPosition.X = ((1.0 - uiPosition.X) * bounds->Bounds[1]) + (bounds->Bounds[3] * uiPosition.X);
+        uiPosition.Y = ((1.0 - uiPosition.Y) * bounds->Bounds[0]) + (bounds->Bounds[2] * uiPosition.Y);
+
+        uiMap = sUiMapStore.LookupEntry(uiMap->ParentUiMapID);
     }
 
-    if (!transformation)
-    {
-        if (newMapId)
-            *newMapId = mapId;
+    return uiPosition;
+}
 
-        if (newPos)
-        {
-            newPos->X = x;
-            newPos->Y = y;
-        }
-        return;
+bool DB2Manager::GetUiMapPosition(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system, bool local,
+    int32* uiMapId /*= nullptr*/, DBCPosition2D* newPos /*= nullptr*/)
+{
+    if (uiMapId)
+        *uiMapId = -1;
+
+    if (newPos)
+    {
+        newPos->X = 0.0f;
+        newPos->Y = 0.0f;
     }
 
-    if (newMapId)
-        *newMapId = transformation->NewMapID;
+    UiMapAssignmentEntry const* uiMapAssignment = FindNearestMapAssignment(x, y, z, mapId, areaId, wmoDoodadPlacementId, wmoGroupId, system);
+    if (!uiMapAssignment)
+        return false;
+
+    if (uiMapId)
+        *uiMapId = uiMapAssignment->UiMapID;
+
+    DBCPosition2D relativePosition{ 0.5f, 0.5f };
+    DBCPosition2D regionSize{ uiMapAssignment->Region[1].X - uiMapAssignment->Region[0].X, uiMapAssignment->Region[1].Y - uiMapAssignment->Region[0].Y };
+    if (regionSize.X > 0.0f)
+        relativePosition.X = (x - uiMapAssignment->Region[0].X) / regionSize.X;
+    if (regionSize.Y > 0.0f)
+        relativePosition.Y = (y - uiMapAssignment->Region[0].Y) / regionSize.Y;
+
+    DBCPosition2D uiPosition
+    {
+        // x any y are swapped
+        ((1.0f - (1.0f - relativePosition.Y)) * uiMapAssignment->UiMin.X) + ((1.0f - relativePosition.Y) * uiMapAssignment->UiMax.X),
+        ((1.0f - (1.0f - relativePosition.X)) * uiMapAssignment->UiMin.Y) + ((1.0f - relativePosition.X) * uiMapAssignment->UiMax.Y)
+    };
+
+    if (!local)
+        uiPosition = CalculateGlobalUiMapPosition(uiMapAssignment->UiMapID, uiPosition);
+
+    if (newPos)
+        *newPos = uiPosition;
 
-    if (!newPos)
+    return true;
+}
+
+void DB2Manager::Zone2MapCoordinates(uint32 areaId, float& x, float& y) const
+{
+    AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
+    if (!areaEntry)
         return;
 
-    if (std::abs(transformation->RegionScale - 1.0f) > 0.001f)
+    for (auto assignment : Trinity::Containers::MapEqualRange(_uiMapAssignmentByArea[UI_MAP_SYSTEM_WORLD], areaId))
     {
-        x = (x - transformation->RegionMin.X) * transformation->RegionScale + transformation->RegionMin.X;
-        y = (y - transformation->RegionMin.Y) * transformation->RegionScale + transformation->RegionMin.Y;
+        if (assignment.second->MapID >= 0 && assignment.second->MapID != areaEntry->ContinentID)
+            continue;
+
+        float tmpY = 1.0 - ((y - assignment.second->UiMin.Y) / (assignment.second->UiMax.Y - assignment.second->UiMin.Y));
+        float tmpX = 1.0 - ((x - assignment.second->UiMin.X) / (assignment.second->UiMax.X - assignment.second->UiMin.X));
+        y = ((1.0 - tmpY) * assignment.second->Region[0].X) + (tmpY * assignment.second->Region[1].X);
+        x = ((1.0 - tmpX) * assignment.second->Region[0].Y) + (tmpX * assignment.second->Region[1].Y);
+        break;
     }
+}
+
+void DB2Manager::Map2ZoneCoordinates(uint32 areaId, float& x, float& y) const
+{
+    DBCPosition2D zoneCoords;
+    if (!GetUiMapPosition(x, y, 0.0f, -1, areaId, 0, 0, UI_MAP_SYSTEM_WORLD, true, nullptr, &zoneCoords))
+        return;
 
-    newPos->X = x + transformation->RegionOffset.X;
-    newPos->Y = y + transformation->RegionOffset.Y;
+    x = zoneCoords.Y * 100.0f;
+    y = zoneCoords.X * 100.0f;
+}
+
+bool DB2Manager::IsUiMapPhase(uint32 phaseId) const
+{
+    return _uiMapPhases.find(phaseId) != _uiMapPhases.end();
+}
+
+WMOAreaTableEntry const* DB2Manager::GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const
+{
+    return Trinity::Containers::MapGetValuePtr(_wmoAreaTableLookup, WMOAreaTableKey(int16(rootId), int8(adtId), groupId));
 }
 
 bool ChrClassesXPowerTypesEntryComparator::Compare(ChrClassesXPowerTypesEntry const* left, ChrClassesXPowerTypesEntry const* right)
diff --git a/src/server/game/DataStores/DB2Stores.h b/src/server/game/DataStores/DB2Stores.h
index d5f0af253a0..3e61c1513ad 100644
--- a/src/server/game/DataStores/DB2Stores.h
+++ b/src/server/game/DataStores/DB2Stores.h
@@ -35,6 +35,7 @@
 class DB2HotfixGeneratorBase;
 
 TC_GAME_API extern DB2Storage<AchievementEntry>                     sAchievementStore;
+TC_GAME_API extern DB2Storage<AnimationDataEntry>                   sAnimationDataStore;
 TC_GAME_API extern DB2Storage<AnimKitEntry>                         sAnimKitStore;
 TC_GAME_API extern DB2Storage<AreaTableEntry>                       sAreaTableStore;
 TC_GAME_API extern DB2Storage<AreaTriggerEntry>                     sAreaTriggerStore;
@@ -65,6 +66,7 @@ TC_GAME_API extern DB2Storage<ChrRacesEntry>                        sChrRacesSto
 TC_GAME_API extern DB2Storage<ChrSpecializationEntry>               sChrSpecializationStore;
 TC_GAME_API extern DB2Storage<CinematicCameraEntry>                 sCinematicCameraStore;
 TC_GAME_API extern DB2Storage<CinematicSequencesEntry>              sCinematicSequencesStore;
+TC_GAME_API extern DB2Storage<ContentTuningEntry>                   sContentTuningStore;
 TC_GAME_API extern DB2Storage<ConversationLineEntry>                sConversationLineStore;
 TC_GAME_API extern DB2Storage<CreatureDisplayInfoEntry>             sCreatureDisplayInfoStore;
 TC_GAME_API extern DB2Storage<CreatureDisplayInfoExtraEntry>        sCreatureDisplayInfoExtraStore;
@@ -148,14 +150,14 @@ TC_GAME_API extern DB2Storage<PhaseEntry>                           sPhaseStore;
 TC_GAME_API extern DB2Storage<PlayerConditionEntry>                 sPlayerConditionStore;
 TC_GAME_API extern DB2Storage<PowerDisplayEntry>                    sPowerDisplayStore;
 TC_GAME_API extern DB2Storage<PvpTalentEntry>                       sPvpTalentStore;
-TC_GAME_API extern DB2Storage<PvpTalentUnlockEntry>                 sPvpTalentUnlockStore;
+TC_GAME_API extern DB2Storage<PvpTalentCategoryEntry>               sPvpTalentCategoryStore;
+TC_GAME_API extern DB2Storage<PvpTalentSlotUnlockEntry>             sPvpTalentSlotUnlockStore;
 TC_GAME_API extern DB2Storage<QuestFactionRewardEntry>              sQuestFactionRewardStore;
 TC_GAME_API extern DB2Storage<QuestMoneyRewardEntry>                sQuestMoneyRewardStore;
 TC_GAME_API extern DB2Storage<QuestSortEntry>                       sQuestSortStore;
 TC_GAME_API extern DB2Storage<QuestXPEntry>                         sQuestXPStore;
 TC_GAME_API extern DB2Storage<RandPropPointsEntry>                  sRandPropPointsStore;
 TC_GAME_API extern DB2Storage<RewardPackEntry>                      sRewardPackStore;
-TC_GAME_API extern DB2Storage<SandboxScalingEntry>                  sSandboxScalingStore;
 TC_GAME_API extern DB2Storage<ScalingStatDistributionEntry>         sScalingStatDistributionStore;
 TC_GAME_API extern DB2Storage<ScenarioEntry>                        sScenarioStore;
 TC_GAME_API extern DB2Storage<ScenarioStepEntry>                    sScenarioStepStore;
@@ -164,7 +166,6 @@ TC_GAME_API extern DB2Storage<SceneScriptPackageEntry>              sSceneScript
 TC_GAME_API extern DB2Storage<SkillLineAbilityEntry>                sSkillLineAbilityStore;
 TC_GAME_API extern DB2Storage<SkillRaceClassInfoEntry>              sSkillRaceClassInfoStore;
 TC_GAME_API extern DB2Storage<SoundKitEntry>                        sSoundKitStore;
-TC_GAME_API extern DB2Storage<SpellEntry>                           sSpellStore;
 TC_GAME_API extern DB2Storage<SpellAuraOptionsEntry>                sSpellAuraOptionsStore;
 TC_GAME_API extern DB2Storage<SpellAuraRestrictionsEntry>           sSpellAuraRestrictionsStore;
 TC_GAME_API extern DB2Storage<SpellCastTimesEntry>                  sSpellCastTimesStore;
@@ -183,6 +184,7 @@ TC_GAME_API extern DB2Storage<SpellItemEnchantmentConditionEntry>   sSpellItemEn
 TC_GAME_API extern DB2Storage<SpellLearnSpellEntry>                 sSpellLearnSpellStore;
 TC_GAME_API extern DB2Storage<SpellLevelsEntry>                     sSpellLevelsStore;
 TC_GAME_API extern DB2Storage<SpellMiscEntry>                       sSpellMiscStore;
+TC_GAME_API extern DB2Storage<SpellNameEntry>                       sSpellNameStore;
 TC_GAME_API extern DB2Storage<SpellPowerEntry>                      sSpellPowerStore;
 TC_GAME_API extern DB2Storage<SpellProcsPerMinuteEntry>             sSpellProcsPerMinuteStore;
 TC_GAME_API extern DB2Storage<SpellRadiusEntry>                     sSpellRadiusStore;
@@ -208,7 +210,6 @@ TC_GAME_API extern DB2Storage<UnitPowerBarEntry>                    sUnitPowerBa
 TC_GAME_API extern DB2Storage<VehicleEntry>                         sVehicleStore;
 TC_GAME_API extern DB2Storage<VehicleSeatEntry>                     sVehicleSeatStore;
 TC_GAME_API extern DB2Storage<WorldEffectEntry>                     sWorldEffectStore;
-TC_GAME_API extern DB2Storage<WorldMapAreaEntry>                    sWorldMapAreaStore;
 TC_GAME_API extern DB2Storage<WorldMapOverlayEntry>                 sWorldMapOverlayStore;
 TC_GAME_API extern DB2Storage<WorldSafeLocsEntry>                   sWorldSafeLocsStore;
 
@@ -257,7 +258,9 @@ public:
     DB2StorageBase const* GetStorage(uint32 type) const;
 
     void LoadHotfixData();
+    void LoadHotfixBlob();
     std::map<uint64, int32> const& GetHotfixData() const;
+    std::vector<uint8> const* GetHotfixBlobData(uint32 tableHash, int32 recordId);
 
     std::vector<uint32> GetAreasForGroup(uint32 areaGroupId) const;
     static bool IsInArea(uint32 objectAreaId, uint32 areaId);
@@ -277,6 +280,7 @@ public:
     static char const* GetCreatureFamilyPetName(uint32 petfamily, uint32 locale);
     float GetCurveValueAt(uint32 curveId, float x) const;
     EmotesTextSoundEntry const* GetTextSoundEmoteFor(uint32 emote, uint8 race, uint8 gender, uint8 class_) const;
+    float EvaluateExpectedStat(ExpectedStatType stat, uint32 level, int32 expansion, uint32 contentTuningId, Classes unitClass) const;
     std::vector<uint32> const* GetFactionTeamList(uint32 faction) const;
     HeirloomEntry const* GetHeirloomByItemId(uint32 itemId) const;
     std::vector<uint32> const* GetGlyphBindableSpells(uint32 glyphPropertiesId) const;
@@ -300,28 +304,28 @@ public:
     MapDifficultyEntry const* GetDefaultMapDifficulty(uint32 mapId, Difficulty* difficulty = nullptr) const;
     MapDifficultyEntry const* GetMapDifficultyData(uint32 mapId, Difficulty difficulty) const;
     MapDifficultyEntry const* GetDownscaledMapDifficultyData(uint32 mapId, Difficulty &difficulty) const;
-    std::string GetNameGenEntry(uint8 race, uint8 gender) const;
     MountEntry const* GetMount(uint32 spellId) const;
     MountEntry const* GetMountById(uint32 id) const;
     MountTypeXCapabilitySet const* GetMountCapabilities(uint32 mountType) const;
     MountXDisplayContainer const* GetMountDisplays(uint32 mountId) const;
+    std::string GetNameGenEntry(uint8 race, uint8 gender) const;
     ResponseCodes ValidateName(std::wstring const& name, LocaleConstant locale) const;
+    static int32 GetNumTalentsAtLevel(uint32 level, Classes playerClass);
     std::vector<uint32> const* GetPhasesForGroup(uint32 group) const;
     PowerTypeEntry const* GetPowerTypeEntry(Powers power) const;
     PowerTypeEntry const* GetPowerTypeByName(std::string const& name) const;
     uint8 GetPvpItemLevelBonus(uint32 itemId) const;
-    uint8 GetMaxPrestige() const;
     static PVPDifficultyEntry const* GetBattlegroundBracketByLevel(uint32 mapid, uint32 level);
     static PVPDifficultyEntry const* GetBattlegroundBracketById(uint32 mapid, BattlegroundBracketId id);
-    uint32 GetRewardPackIDForPvpRewardByHonorLevelAndPrestige(uint8 honorLevel, uint8 prestige) const;
-    uint32 GetRequiredHonorLevelForPvpTalent(PvpTalentEntry const* talentInfo) const;
-    std::vector<PvpTalentEntry const*> const& GetPvpTalentsByPosition(uint32 class_, uint32 tier, uint32 column) const;
+    uint32 GetRequiredLevelForPvpTalentSlot(uint8 slot, Classes class_) const;
+    int32 GetPvpTalentNumSlotsAtLevel(uint32 level, Classes class_) const;
     std::vector<QuestPackageItemEntry const*> const* GetQuestPackageItems(uint32 questPackageID) const;
     std::vector<QuestPackageItemEntry const*> const* GetQuestPackageItemsFallback(uint32 questPackageID) const;
     uint32 GetQuestUniqueBitFlag(uint32 questId);
     std::vector<RewardPackXCurrencyTypeEntry const*> const* GetRewardPackCurrencyTypesByRewardID(uint32 rewardPackID) const;
     std::vector<RewardPackXItemEntry const*> const* GetRewardPackItemsByRewardID(uint32 rewardPackID) const;
     uint32 GetRulesetItemUpgrade(uint32 itemId) const;
+    std::vector<SkillLineAbilityEntry const*> const* GetSkillLineAbilitiesBySkill(uint32 skillId) const;
     SkillRaceClassInfoEntry const* GetSkillRaceClassInfo(uint32 skill, uint8 race, uint8 class_);
     std::vector<SpecializationSpellsEntry const*> const* GetSpecializationSpells(uint32 specId) const;
     static bool IsValidSpellFamiliyName(SpellFamilyNames family);
@@ -332,11 +336,12 @@ public:
     bool IsToyItem(uint32 toy) const;
     std::vector<TransmogSetEntry const*> const* GetTransmogSetsForItemModifiedAppearance(uint32 itemModifiedAppearanceId) const;
     std::vector<TransmogSetItemEntry const*> const* GetTransmogSetItems(uint32 transmogSetId) const;
-    WMOAreaTableEntry const* GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const;
-    uint32 GetVirtualMapForMapAndZone(uint32 mapId, uint32 zoneId) const;
+    static bool GetUiMapPosition(float x, float y, float z, int32 mapId, int32 areaId, int32 wmoDoodadPlacementId, int32 wmoGroupId, UiMapSystem system, bool local,
+        int32* uiMapId = nullptr, DBCPosition2D* newPos = nullptr);
     void Zone2MapCoordinates(uint32 areaId, float& x, float& y) const;
     void Map2ZoneCoordinates(uint32 areaId, float& x, float& y) const;
-    static void DeterminaAlternateMapPosition(uint32 mapId, float x, float y, float z, uint32* newMapId = nullptr, DBCPosition2D* newPos = nullptr);
+    bool IsUiMapPhase(uint32 phaseId) const;
+    WMOAreaTableEntry const* GetWMOAreaTable(int32 rootId, int32 adtId, int32 groupId) const;
 
 private:
     friend class DB2HotfixGeneratorBase;
diff --git a/src/server/game/DataStores/DB2Structure.h b/src/server/game/DataStores/DB2Structure.h
index e5f46417a81..0c38d0fb213 100644
--- a/src/server/game/DataStores/DB2Structure.h
+++ b/src/server/game/DataStores/DB2Structure.h
@@ -28,21 +28,30 @@ struct LocalizedString;
 
 struct AchievementEntry
 {
-    LocalizedString* Title;
     LocalizedString* Description;
+    LocalizedString* Title;
     LocalizedString* Reward;
-    int32 Flags;
+    uint32 ID;
     int16 InstanceID;                                               // -1 = none
+    int8 Faction;                                                   // -1 = all, 0 = horde, 1 = alliance
     int16 Supercedes;                                               // its Achievement parent (can`t start while parent uncomplete, use its Criteria if don`t have own, use its progress on begin)
     int16 Category;
-    int16 UiOrder;
-    int16 SharesCriteria;                                           // referenced achievement (counting of all completed criterias)
-    int8 Faction;                                                   // -1 = all, 0 = horde, 1 = alliance
-    int8 Points;
     int8 MinimumCriteria;                                           // need this count of completed criterias (own or referenced achievement criterias)
-    uint32 ID;
+    int8 Points;
+    int32 Flags;
+    int16 UiOrder;
     int32 IconFileID;
     uint32 CriteriaTree;
+    int16 SharesCriteria;                                           // referenced achievement (counting of all completed criterias)
+};
+
+struct AnimationDataEntry
+{
+    uint32 ID;
+    uint16 Fallback;
+    uint8 BehaviorTier;
+    int32 BehaviorID;
+    int32 Flags[2];
 };
 
 struct AnimKitEntry
@@ -65,27 +74,27 @@ struct AreaTableEntry
     uint32 ID;
     char const* ZoneName;
     LocalizedString* AreaName;
-    int32 Flags[2];
-    float AmbientMultiplier;
     uint16 ContinentID;
     uint16 ParentAreaID;
     int16 AreaBit;
+    uint8 SoundProviderPref;
+    uint8 SoundProviderPrefUnderwater;
     uint16 AmbienceID;
+    uint16 UwAmbience;
     uint16 ZoneMusic;
-    uint16 IntroSound;
-    uint16 LiquidTypeID[4];
     uint16 UwZoneMusic;
-    uint16 UwAmbience;
-    int16 PvpCombatWorldStateID;
-    uint8 SoundProviderPref;
-    uint8 SoundProviderPrefUnderwater;
     int8 ExplorationLevel;
+    uint16 IntroSound;
+    uint32 UwIntroSound;
     uint8 FactionGroupMask;
+    float AmbientMultiplier;
     uint8 MountFlags;
+    int16 PvpCombatWorldStateID;
     uint8 WildBattlePetLevelMin;
     uint8 WildBattlePetLevelMax;
     uint8 WindSettingsID;
-    uint32 UwIntroSound;
+    int32 Flags[2];
+    uint16 LiquidTypeID[4];
 
     // helpers
     bool IsSanctuary() const
@@ -99,20 +108,20 @@ struct AreaTableEntry
 struct AreaTriggerEntry
 {
     DBCPosition3D Pos;
+    uint32 ID;
+    int16 ContinentID;
+    int8 PhaseUseFlags;
+    int16 PhaseID;
+    int16 PhaseGroupID;
     float Radius;
     float BoxLength;
     float BoxWidth;
     float BoxHeight;
     float BoxYaw;
-    int16 ContinentID;
-    int16 PhaseID;
-    int16 PhaseGroupID;
+    int8 ShapeType;
     int16 ShapeID;
     int16 AreaTriggerActionSetID;
-    int8 PhaseUseFlags;
-    int8 ShapeType;
     int8 Flags;
-    uint32 ID;
 };
 
 struct ArmorLocationEntry
@@ -127,15 +136,15 @@ struct ArmorLocationEntry
 
 struct ArtifactEntry
 {
-    uint32 ID;
     LocalizedString* Name;
+    uint32 ID;
+    uint16 UiTextureKitID;
+    int32 UiNameColor;
     int32 UiBarOverlayColor;
     int32 UiBarBackgroundColor;
-    int32 UiNameColor;
-    uint16 UiTextureKitID;
     uint16 ChrSpecializationID;
-    uint8 ArtifactCategoryID;
     uint8 Flags;
+    uint8 ArtifactCategoryID;
     uint32 UiModelSceneID;
     uint32 SpellVisualKitID;
 };
@@ -143,32 +152,32 @@ struct ArtifactEntry
 struct ArtifactAppearanceEntry
 {
     LocalizedString* Name;
-    int32 UiSwatchColor;
-    float UiModelSaturation;
-    float UiModelOpacity;
-    uint32 OverrideShapeshiftDisplayID;
+    uint32 ID;
     uint16 ArtifactAppearanceSetID;
-    uint16 UiCameraID;
     uint8 DisplayIndex;
+    uint32 UnlockPlayerConditionID;
     uint8 ItemAppearanceModifierID;
-    uint8 Flags;
+    int32 UiSwatchColor;
+    float UiModelSaturation;
+    float UiModelOpacity;
     uint8 OverrideShapeshiftFormID;
-    uint32 ID;
-    uint32 UnlockPlayerConditionID;
+    uint32 OverrideShapeshiftDisplayID;
     uint32 UiItemAppearanceID;
     uint32 UiAltItemAppearanceID;
+    uint8 Flags;
+    uint16 UiCameraID;
 };
 
 struct ArtifactAppearanceSetEntry
 {
     LocalizedString* Name;
     LocalizedString* Description;
+    uint32 ID;
+    uint8 DisplayIndex;
     uint16 UiCameraID;
     uint16 AltHandUICameraID;
-    uint8 DisplayIndex;
     int8 ForgeAttachmentOverride;
     uint8 Flags;
-    uint32 ID;
     uint8 ArtifactID;
 };
 
@@ -181,13 +190,13 @@ struct ArtifactCategoryEntry
 
 struct ArtifactPowerEntry
 {
-    DBCPosition2D Pos;
+    DBCPosition2D DisplayPos;
+    uint32 ID;
     uint8 ArtifactID;
-    uint8 Flags;
     uint8 MaxPurchasableRank;
-    uint8 Tier;
-    uint32 ID;
     int32 Label;
+    uint8 Flags;
+    uint8 Tier;
 };
 
 struct ArtifactPowerLinkEntry
@@ -206,10 +215,10 @@ struct ArtifactPowerPickerEntry
 struct ArtifactPowerRankEntry
 {
     uint32 ID;
+    uint8 RankIndex;
     int32 SpellID;
-    float AuraPointsOverride;
     uint16 ItemBonusListID;
-    uint8 RankIndex;
+    float AuraPointsOverride;
     uint16 ArtifactPowerID;
 };
 
@@ -232,9 +241,9 @@ struct ArtifactTierEntry
 struct ArtifactUnlockEntry
 {
     uint32 ID;
-    uint16 ItemBonusListID;
-    uint8 PowerRank;
     uint32 PowerID;
+    uint8 PowerRank;
+    uint16 ItemBonusListID;
     uint32 PlayerConditionID;
     uint8 ArtifactID;
 };
@@ -266,12 +275,12 @@ struct BarberShopStyleEntry
 {
     LocalizedString* DisplayName;
     LocalizedString* Description;
-    float CostModifier;
+    uint32 ID;
     uint8 Type;                                                     // value 0 -> hair, value 2 -> facialhair
+    float CostModifier;
     uint8 Race;
     uint8 Sex;
     uint8 Data;                                                     // real ID to hair/facial hair
-    uint32 ID;
 };
 
 struct BattlePetBreedQualityEntry
@@ -284,22 +293,22 @@ struct BattlePetBreedQualityEntry
 struct BattlePetBreedStateEntry
 {
     uint32 ID;
-    uint16 Value;
     uint8 BattlePetStateID;
+    uint16 Value;
     uint8 BattlePetBreedID;
 };
 
 struct BattlePetSpeciesEntry
 {
-    LocalizedString* SourceText;
     LocalizedString* Description;
+    LocalizedString* SourceText;
+    uint32 ID;
     int32 CreatureID;
-    int32 IconFileDataID;
     int32 SummonSpellID;
-    uint16 Flags;
+    int32 IconFileDataID;
     uint8 PetTypeEnum;
+    uint16 Flags;
     int8 SourceTypeEnum;
-    uint32 ID;
     int32 CardUIModelSceneID;
     int32 LoadoutUIModelSceneID;
 };
@@ -307,8 +316,8 @@ struct BattlePetSpeciesEntry
 struct BattlePetSpeciesStateEntry
 {
     uint32 ID;
-    int32 Value;
     uint8 BattlePetStateID;
+    int32 Value;
     uint16 BattlePetSpeciesID;
 };
 
@@ -319,45 +328,46 @@ struct BattlemasterListEntry
     LocalizedString* GameType;
     LocalizedString* ShortDescription;
     LocalizedString* LongDescription;
-    int32 IconFileDataID;
-    int16 MapID[16];
-    int16 HolidayWorldState;
-    int16 RequiredPlayerConditionID;
     int8 InstanceType;
-    int8 GroupsAllowed;
-    int8 MaxGroupSize;
     int8 MinLevel;
     int8 MaxLevel;
     int8 RatedPlayers;
     int8 MinPlayers;
     int8 MaxPlayers;
+    int8 GroupsAllowed;
+    int8 MaxGroupSize;
+    int16 HolidayWorldState;
     int8 Flags;
+    int32 IconFileDataID;
+    int16 RequiredPlayerConditionID;
+    int16 MapID[16];
 };
 
 #define MAX_BROADCAST_TEXT_EMOTES 3
 
 struct BroadcastTextEntry
 {
-    uint32 ID;
     LocalizedString* Text;
     LocalizedString* Text1;
-    uint16 EmoteID[MAX_BROADCAST_TEXT_EMOTES];
-    uint16 EmoteDelay[MAX_BROADCAST_TEXT_EMOTES];
-    uint16 EmotesID;
+    uint32 ID;
     uint8 LanguageID;
-    uint8 Flags;
     int32 ConditionID;
+    uint16 EmotesID;
+    uint8 Flags;
+    uint32 ChatBubbleDurationMs;
     uint32 SoundEntriesID[2];
+    uint16 EmoteID[MAX_BROADCAST_TEXT_EMOTES];
+    uint16 EmoteDelay[MAX_BROADCAST_TEXT_EMOTES];
 };
 
 struct Cfg_RegionsEntry
 {
     uint32 ID;
     char const* Tag;
-    uint32 Raidorigin;                                              // Date of first raid reset, all other resets are calculated as this date plus interval
-    uint32 ChallengeOrigin;
     uint16 RegionID;
+    uint32 Raidorigin;                                              // Date of first raid reset, all other resets are calculated as this date plus interval
     uint8 RegionGroupMask;
+    uint32 ChallengeOrigin;
 };
 
 struct CharacterFacialHairStylesEntry
@@ -372,21 +382,21 @@ struct CharacterFacialHairStylesEntry
 struct CharBaseSectionEntry
 {
     uint32 ID;
+    uint8 LayoutResType;
     uint8 VariationEnum;
     uint8 ResolutionVariationEnum;
-    uint8 LayoutResType;
 };
 
 struct CharSectionsEntry
 {
     uint32 ID;
-    int32 MaterialResourcesID[3];
-    int16 Flags;
     int8 RaceID;
     int8 SexID;
     int8 BaseSection;
     int8 VariationIndex;
     int8 ColorIndex;
+    int16 Flags;
+    int32 MaterialResourcesID[3];
 };
 
 #define MAX_OUTFIT_ITEMS 24
@@ -394,12 +404,12 @@ struct CharSectionsEntry
 struct CharStartOutfitEntry
 {
     uint32 ID;
-    int32 ItemID[MAX_OUTFIT_ITEMS];
-    uint32 PetDisplayID;                                            // Pet Model ID for starting pet
     uint8 ClassID;
     uint8 SexID;
     uint8 OutfitID;
+    uint32 PetDisplayID;                                            // Pet Model ID for starting pet
     uint8 PetFamilyID;                                              // Pet Family Entry for starting pet
+    int32 ItemID[MAX_OUTFIT_ITEMS];
     uint8 RaceID;
 };
 
@@ -423,32 +433,32 @@ struct ChatChannelsEntry
 
 struct ChrClassesEntry
 {
-    char const* PetNameToken;
     LocalizedString* Name;
-    LocalizedString* NameFemale;
-    LocalizedString* NameMale;
     char const* Filename;
+    LocalizedString* NameMale;
+    LocalizedString* NameFemale;
+    char const* PetNameToken;
+    uint32 ID;
     uint32 CreateScreenFileDataID;
     uint32 SelectScreenFileDataID;
-    uint32 LowResScreenFileDataID;
     uint32 IconFileDataID;
+    uint32 LowResScreenFileDataID;
     int32 StartingLevel;
     uint16 Flags;
     uint16 CinematicSequenceID;
     uint16 DefaultSpec;
+    uint8 PrimaryStatPriority;
     uint8 DisplayPower;
-    uint8 SpellClassSet;
-    uint8 AttackPowerPerStrength;
-    uint8 AttackPowerPerAgility;
     uint8 RangedAttackPowerPerAgility;
-    uint8 PrimaryStatPriority;
-    uint32 ID;
+    uint8 AttackPowerPerAgility;
+    uint8 AttackPowerPerStrength;
+    uint8 SpellClassSet;
 };
 
 struct ChrClassesXPowerTypesEntry
 {
     uint32 ID;
-    uint8 PowerType;
+    int8 PowerType;
     uint8 ClassID;
 };
 
@@ -460,38 +470,46 @@ struct ChrRacesEntry
     LocalizedString* NameFemale;
     LocalizedString* NameLowercase;
     LocalizedString* NameFemaleLowercase;
+    uint32 ID;
     int32 Flags;
     uint32 MaleDisplayId;
     uint32 FemaleDisplayId;
+    uint32 HighResMaleDisplayId;
+    uint32 HighResFemaleDisplayId;
     int32 CreateScreenFileDataID;
     int32 SelectScreenFileDataID;
     float MaleCustomizeOffset[3];
     float FemaleCustomizeOffset[3];
     int32 LowResScreenFileDataID;
+    uint32 AlteredFormStartVisualKitID[3];
+    uint32 AlteredFormFinishVisualKitID[3];
+    int32 HeritageArmorAchievementID;
     int32 StartingLevel;
     int32 UiDisplayOrder;
+    int32 FemaleSkeletonFileDataID;
+    int32 MaleSkeletonFileDataID;
+    int32 HelmVisFallbackRaceID;
     int16 FactionID;
+    int16 CinematicSequenceID;
     int16 ResSicknessSpellID;
     int16 SplashSoundID;
-    int16 CinematicSequenceID;
     int8 BaseLanguage;
     int8 CreatureType;
     int8 Alliance;
     int8 RaceRelated;
     int8 UnalteredVisualRaceID;
     int8 CharComponentTextureLayoutID;
+    int8 CharComponentTexLayoutHiResID;
     int8 DefaultClassID;
     int8 NeutralRaceID;
-    int8 DisplayRaceID;
-    int8 CharComponentTexLayoutHiResID;
-    uint32 ID;
-    uint32 HighResMaleDisplayId;
-    uint32 HighResFemaleDisplayId;
-    int32 HeritageArmorAchievementID;
-    int32 MaleSkeletonFileDataID;
-    int32 FemaleSkeletonFileDataID;
-    uint32 AlteredFormStartVisualKitID[3];
-    uint32 AlteredFormFinishVisualKitID[3];
+    int8 MaleModelFallbackRaceID;
+    int8 MaleModelFallbackSex;
+    int8 FemaleModelFallbackRaceID;
+    int8 FemaleModelFallbackSex;
+    int8 MaleTextureFallbackRaceID;
+    int8 MaleTextureFallbackSex;
+    int8 FemaleTextureFallbackRaceID;
+    int8 FemaleTextureFallbackSex;
 };
 
 #define MAX_MASTERY_SPELLS 2
@@ -501,16 +519,16 @@ struct ChrSpecializationEntry
     LocalizedString* Name;
     LocalizedString* FemaleName;
     LocalizedString* Description;
-    int32 MasterySpellID[MAX_MASTERY_SPELLS];
+    uint32 ID;
     int8 ClassID;
     int8 OrderIndex;
     int8 PetTalentType;
     int8 Role;
-    int8 PrimaryStatPriority;
-    uint32 ID;
-    int32 SpellIconFileID;
     uint32 Flags;
+    int32 SpellIconFileID;
+    int8 PrimaryStatPriority;
     int32 AnimReplacements;
+    int32 MasterySpellID[MAX_MASTERY_SPELLS];
 
     bool IsPetSpecialization() const
     {
@@ -521,9 +539,9 @@ struct ChrSpecializationEntry
 struct CinematicCameraEntry
 {
     uint32 ID;
-    uint32 SoundID;                                         // Sound ID       (voiceover for cinematic)
     DBCPosition3D Origin;                                   // Position in map used for basis for M2 co-ordinates
-    float OriginFacing;                                     // Orientation in map used for basis for M2 co-
+    uint32 SoundID;                                         // Sound ID       (voiceover for cinematic)
+    float OriginFacing;                                     // Orientation in map used for basis for M2 co
     uint32 FileDataID;                                      // Model
 };
 
@@ -534,6 +552,16 @@ struct CinematicSequencesEntry
     uint16 Camera[8];
 };
 
+struct ContentTuningEntry
+{
+    uint32 ID;
+    int32 MinLevel;
+    int32 MaxLevel;
+    int32 Flags;
+    int32 ExpectedStatModID;
+    int32 DifficultyESMID;
+};
+
 struct ConversationLineEntry
 {
     uint32 ID;
@@ -550,35 +578,35 @@ struct ConversationLineEntry
 struct CreatureDisplayInfoEntry
 {
     uint32 ID;
-    float CreatureModelScale;
     uint16 ModelID;
-    uint16 NPCSoundID;
+    uint16 SoundID;
     int8 SizeClass;
-    uint8 Flags;
-    int8 Gender;
-    int32 ExtendedDisplayInfoID;
-    int32 PortraitTextureFileDataID;
+    float CreatureModelScale;
     uint8 CreatureModelAlpha;
-    uint16 SoundID;
-    float PlayerOverrideScale;
-    int32 PortraitCreatureDisplayInfoID;
     uint8 BloodID;
+    int32 ExtendedDisplayInfoID;
+    uint16 NPCSoundID;
     uint16 ParticleColorID;
-    uint32 CreatureGeosetData;
+    int32 PortraitCreatureDisplayInfoID;
+    int32 PortraitTextureFileDataID;
     uint16 ObjectEffectPackageID;
     uint16 AnimReplacementSetID;
-    int8 UnarmedWeaponType;
+    uint8 Flags;
     int32 StateSpellVisualKitID;
+    float PlayerOverrideScale;
     float PetInstanceScale;                                         // scale of not own player pets inside dungeons/raids/scenarios
+    int8 UnarmedWeaponType;
     int32 MountPoofSpellVisualKitID;
+    int32 DissolveEffectID;
+    int8 Gender;
+    int32 DissolveOutEffectID;
+    int8 CreatureModelMinLod;
     int32 TextureVariationFileDataID[3];
 };
 
 struct CreatureDisplayInfoExtraEntry
 {
     uint32 ID;
-    int32 BakeMaterialResourcesID;
-    int32 HDBakeMaterialResourcesID;
     int8 DisplayRaceID;
     int8 DisplaySexID;
     int8 DisplayClassID;
@@ -587,8 +615,10 @@ struct CreatureDisplayInfoExtraEntry
     int8 HairStyleID;
     int8 HairColorID;
     int8 FacialHairID;
-    uint8 CustomDisplayOption[3];
     int8 Flags;
+    int32 BakeMaterialResourcesID;
+    int32 HDBakeMaterialResourcesID;
+    uint8 CustomDisplayOption[3];
 };
 
 struct CreatureFamilyEntry
@@ -596,46 +626,46 @@ struct CreatureFamilyEntry
     uint32 ID;
     LocalizedString* Name;
     float MinScale;
-    float MaxScale;
-    int32 IconFileID;
-    int16 SkillLine[2];
-    int16 PetFoodMask;
     int8 MinScaleLevel;
+    float MaxScale;
     int8 MaxScaleLevel;
+    int16 PetFoodMask;
     int8 PetTalentType;
+    int32 IconFileID;
+    int16 SkillLine[2];
 };
 
 struct CreatureModelDataEntry
 {
     uint32 ID;
-    float ModelScale;
+    float GeoBox[6];
+    uint32 Flags;
+    uint32 FileDataID;
+    uint32 BloodID;
+    uint32 FootprintTextureID;
     float FootprintTextureLength;
     float FootprintTextureWidth;
     float FootprintParticleScale;
+    uint32 FoleyMaterialID;
+    uint32 FootstepCameraEffectID;
+    uint32 DeathThudCameraEffectID;
+    uint32 SoundID;
+    uint32 SizeClass;
     float CollisionWidth;
     float CollisionHeight;
-    float MountHeight;
-    float GeoBox[6];
     float WorldEffectScale;
+    uint32 CreatureGeosetDataID;
+    float HoverHeight;
     float AttachedEffectScale;
+    float ModelScale;
     float MissileCollisionRadius;
     float MissileCollisionPush;
     float MissileCollisionRaise;
+    float MountHeight;
     float OverrideLootEffectScale;
     float OverrideNameScale;
     float OverrideSelectionRadius;
     float TamedPetBaseScale;
-    float HoverHeight;
-    uint32 Flags;
-    uint32 FileDataID;
-    uint32 SizeClass;
-    uint32 BloodID;
-    uint32 FootprintTextureID;
-    uint32 FoleyMaterialID;
-    uint32 FootstepCameraEffectID;
-    uint32 DeathThudCameraEffectID;
-    uint32 SoundID;
-    uint32 CreatureGeosetDataID;
 };
 
 struct CreatureTypeEntry
@@ -648,144 +678,150 @@ struct CreatureTypeEntry
 struct CriteriaEntry
 {
     uint32 ID;
+    int16 Type;
     union AssetNameAlias
     {
-        uint32 ID;
+        int32 ID;
         // CRITERIA_TYPE_KILL_CREATURE          = 0
         // CRITERIA_TYPE_KILLED_BY_CREATURE     = 20
-        uint32 CreatureID;
+        int32 CreatureID;
 
         // CRITERIA_TYPE_WIN_BG                 = 1
         // CRITERIA_TYPE_COMPLETE_BATTLEGROUND  = 15
         // CRITERIA_TYPE_DEATH_AT_MAP           = 16
         // CRITERIA_TYPE_WIN_ARENA              = 32
         // CRITERIA_TYPE_PLAY_ARENA             = 33
-        uint32 MapID;
+        int32 MapID;
 
         // CRITERIA_TYPE_REACH_SKILL_LEVEL      = 7
         // CRITERIA_TYPE_LEARN_SKILL_LEVEL      = 40
         // CRITERIA_TYPE_LEARN_SKILLLINE_SPELLS = 75
         // CRITERIA_TYPE_LEARN_SKILL_LINE       = 112
-        uint32 SkillID;
+        int32 SkillID;
 
         // CRITERIA_TYPE_COMPLETE_ACHIEVEMENT   = 8
-        uint32 AchievementID;
+        int32 AchievementID;
 
         // CRITERIA_TYPE_COMPLETE_QUESTS_IN_ZONE = 11
-        uint32 ZoneID;
+        int32 ZoneID;
 
         // CRITERIA_TYPE_CURRENCY = 12
-        uint32 CurrencyID;
+        int32 CurrencyID;
 
         // CRITERIA_TYPE_DEATH_IN_DUNGEON       = 18
         // CRITERIA_TYPE_COMPLETE_RAID          = 19
-        uint32 GroupSize;
+        int32 GroupSize;
 
         // CRITERIA_TYPE_DEATHS_FROM            = 26
-        uint32 DamageType;
+        int32 DamageType;
 
         // CRITERIA_TYPE_COMPLETE_QUEST         = 27
-        uint32 QuestID;
+        int32 QuestID;
 
         // CRITERIA_TYPE_BE_SPELL_TARGET        = 28
         // CRITERIA_TYPE_BE_SPELL_TARGET2       = 69
         // CRITERIA_TYPE_CAST_SPELL             = 29
         // CRITERIA_TYPE_CAST_SPELL2            = 110
         // CRITERIA_TYPE_LEARN_SPELL            = 34
-        uint32 SpellID;
+        int32 SpellID;
 
         // CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE
-        uint32 ObjectiveId;
+        int32 ObjectiveId;
 
         // CRITERIA_TYPE_HONORABLE_KILL_AT_AREA = 31
         // CRITERIA_TYPE_ENTER_AREA             = 163
         // CRITERIA_TYPE_LEAVE_AREA             = 164
-        uint32 AreaID;
+        int32 AreaID;
 
         // CRITERIA_TYPE_OWN_ITEM               = 36
         // CRITERIA_TYPE_USE_ITEM               = 41
         // CRITERIA_TYPE_LOOT_ITEM              = 42
         // CRITERIA_TYPE_EQUIP_ITEM             = 57
         // CRITERIA_TYPE_OWN_TOY                = 185
-        uint32 ItemID;
+        int32 ItemID;
 
         // CRITERIA_TYPE_HIGHEST_TEAM_RATING    = 38
         // CRITERIA_TYPE_REACH_TEAM_RATING      = 39
         // CRITERIA_TYPE_HIGHEST_PERSONAL_RATING = 39
-        uint32 TeamType;
+        int32 TeamType;
 
         // CRITERIA_TYPE_EXPLORE_AREA           = 43
-        uint32 WorldMapOverlayID;
+        int32 WorldMapOverlayID;
 
         // CRITERIA_TYPE_GAIN_REPUTATION        = 46
         // CRITERIA_TYPE_GAIN_PARAGON_REPUTATION = 206
-        uint32 FactionID;
+        int32 FactionID;
 
         // CRITERIA_TYPE_EQUIP_EPIC_ITEM        = 49
-        uint32 ItemSlot;
+        int32 ItemSlot;
 
         // CRITERIA_TYPE_ROLL_NEED_ON_LOOT      = 50
         // CRITERIA_TYPE_ROLL_GREED_ON_LOOT      = 51
-        uint32 RollValue;
+        int32 RollValue;
 
         // CRITERIA_TYPE_HK_CLASS               = 52
-        uint32 ClassID;
+        int32 ClassID;
 
         // CRITERIA_TYPE_HK_RACE                = 53
-        uint32 RaceID;
+        int32 RaceID;
 
         // CRITERIA_TYPE_DO_EMOTE               = 54
-        uint32 EmoteID;
+        int32 EmoteID;
 
         // CRITERIA_TYPE_USE_GAMEOBJECT         = 68
         // CRITERIA_TYPE_FISH_IN_GAMEOBJECT     = 72
-        uint32 GameObjectID;
+        int32 GameObjectID;
 
         // CRITERIA_TYPE_HIGHEST_POWER          = 96
-        uint32 PowerType;
+        int32 PowerType;
 
         // CRITERIA_TYPE_HIGHEST_STAT           = 97
-        uint32 StatType;
+        int32 StatType;
 
         // CRITERIA_TYPE_HIGHEST_SPELLPOWER     = 98
-        uint32 SpellSchool;
+        int32 SpellSchool;
 
         // CRITERIA_TYPE_LOOT_TYPE              = 109
-        uint32 LootType;
+        int32 LootType;
 
         // CRITERIA_TYPE_COMPLETE_DUNGEON_ENCOUNTER = 165
-        uint32 DungeonEncounterID;
+        int32 DungeonEncounterID;
 
         // CRITERIA_TYPE_CONSTRUCT_GARRISON_BUILDING = 169
-        uint32 GarrBuildingID;
+        int32 GarrBuildingID;
 
         // CRITERIA_TYPE_UPGRADE_GARRISON       = 170
-        uint32 GarrisonLevel;
+        int32 GarrisonLevel;
 
         // CRITERIA_TYPE_COMPLETE_GARRISON_MISSION = 174
-        uint32 GarrMissionID;
+        int32 GarrMissionID;
 
         // CRITERIA_TYPE_COMPLETE_GARRISON_SHIPMENT = 182
-        uint32 CharShipmentContainerID;
+        int32 CharShipmentContainerID;
 
         // CRITERIA_TYPE_APPEARANCE_UNLOCKED_BY_SLOT
-        uint32 EquipmentSlot;
+        int32 EquipmentSlot;
 
         // CRITERIA_TYPE_TRANSMOG_SET_UNLOCKED = 205
-        uint32 TransmogSetGroupID;
+        int32 TransmogSetGroupID;
 
         // CRITERIA_TYPE_RELIC_TALENT_UNLOCKED = 211
-        uint32 ArtifactPowerID;
+        int32 ArtifactPowerID;
+
+        // CRITERIA_TYPE_REACH_ACCOUNT_HONOR_LEVEL = 213
+        int32 AccountHonorLevel;
+
+        // CRITERIA_TREE_HEART_OF_AZEROTH_LEVEL_REACHED = 215
+        int32 HeartOfAzerothLevel;
     } Asset;
-    int32 StartAsset;
-    int32 FailAsset;
     uint32 ModifierTreeId;
-    uint16 StartTimer;
-    int16 EligibilityWorldStateID;
-    uint8 Type;
     uint8 StartEvent;
+    int32 StartAsset;
+    uint16 StartTimer;
     uint8 FailEvent;
+    int32 FailAsset;
     uint8 Flags;
+    int16 EligibilityWorldStateID;
     int8 EligibilityWorldStateValue;
 };
 
@@ -793,12 +829,12 @@ struct CriteriaTreeEntry
 {
     uint32 ID;
     LocalizedString* Description;
-    int32 Amount;
-    int16 Flags;
+    uint32 Parent;
+    uint32 Amount;
     int8 Operator;
     uint32 CriteriaID;
-    uint32 Parent;
     int32 OrderIndex;
+    int16 Flags;
 };
 
 struct CurrencyTypesEntry
@@ -806,14 +842,15 @@ struct CurrencyTypesEntry
     uint32 ID;
     LocalizedString* Name;
     LocalizedString* Description;
-    uint32 MaxQty;
-    uint32 MaxEarnablePerWeek;
-    uint32 Flags;
     uint8 CategoryID;
-    uint8 SpellCategory;
-    uint8 Quality;
     int32 InventoryIconFileID;
     uint32 SpellWeight;
+    uint8 SpellCategory;
+    uint32 MaxQty;
+    uint32 MaxEarnablePerWeek;
+    uint32 Flags;
+    int8 Quality;
+    int32 FactionID;
 };
 
 struct CurveEntry
@@ -834,58 +871,58 @@ struct CurvePointEntry
 struct DestructibleModelDataEntry
 {
     uint32 ID;
-    uint16 State0Wmo;
-    uint16 State1Wmo;
-    uint16 State2Wmo;
-    uint16 State3Wmo;
-    uint16 HealEffectSpeed;
     int8 State0ImpactEffectDoodadSet;
     uint8 State0AmbientDoodadSet;
-    int8 State0NameSet;
+    uint16 State1Wmo;
     int8 State1DestructionDoodadSet;
     int8 State1ImpactEffectDoodadSet;
     uint8 State1AmbientDoodadSet;
-    int8 State1NameSet;
+    uint16 State2Wmo;
     int8 State2DestructionDoodadSet;
     int8 State2ImpactEffectDoodadSet;
     uint8 State2AmbientDoodadSet;
-    int8 State2NameSet;
+    uint16 State3Wmo;
     uint8 State3InitDoodadSet;
     uint8 State3AmbientDoodadSet;
-    int8 State3NameSet;
     uint8 EjectDirection;
     uint8 DoNotHighlight;
+    uint16 State0Wmo;
     uint8 HealEffect;
+    uint16 HealEffectSpeed;
+    int8 State0NameSet;
+    int8 State1NameSet;
+    int8 State2NameSet;
+    int8 State3NameSet;
 };
 
 struct DifficultyEntry
 {
     uint32 ID;
     LocalizedString* Name;
-    uint16 GroupSizeHealthCurveID;
-    uint16 GroupSizeDmgCurveID;
-    uint16 GroupSizeSpellPointsCurveID;
-    uint8 FallbackDifficultyID;
     uint8 InstanceType;
+    uint8 OrderIndex;
+    int8 OldEnumValue;
+    uint8 FallbackDifficultyID;
     uint8 MinPlayers;
     uint8 MaxPlayers;
-    int8 OldEnumValue;
     uint8 Flags;
-    uint8 ToggleDifficultyID;
     uint8 ItemContext;
-    uint8 OrderIndex;
+    uint8 ToggleDifficultyID;
+    uint16 GroupSizeHealthCurveID;
+    uint16 GroupSizeDmgCurveID;
+    uint16 GroupSizeSpellPointsCurveID;
 };
 
 struct DungeonEncounterEntry
 {
     LocalizedString* Name;
-    int32 CreatureDisplayID;
+    uint32 ID;
     int16 MapID;
     int8 DifficultyID;
+    int32 OrderIndex;
     int8 Bit;
+    int32 CreatureDisplayID;
     uint8 Flags;
-    uint32 ID;
-    int32 OrderIndex;
     int32 SpellIconFileID;
 };
 
@@ -907,13 +944,13 @@ struct EmotesEntry
     uint32 ID;
     int64 RaceMask;
     char const* EmoteSlashCommand;
+    int32 AnimID;
     uint32 EmoteFlags;
-    uint32 SpellVisualKitID;
-    int16 AnimID;
     uint8 EmoteSpecProc;
-    int32 ClassMask;
     uint32 EmoteSpecProcParam;
     uint32 EventSoundID;
+    uint32 SpellVisualKitID;
+    int32 ClassMask;
 };
 
 struct EmotesTextEntry
@@ -927,30 +964,60 @@ struct EmotesTextSoundEntry
 {
     uint32 ID;
     uint8 RaceID;
-    uint8 SexID;
     uint8 ClassID;
+    uint8 SexID;
     uint32 SoundID;
     uint16 EmotesTextID;
 };
 
+struct ExpectedStatEntry
+{
+    uint32 ID;
+    int32 ExpansionID;
+    float CreatureHealth;
+    float PlayerHealth;
+    float CreatureAutoAttackDps;
+    float CreatureArmor;
+    float PlayerMana;
+    float PlayerPrimaryStat;
+    float PlayerSecondaryStat;
+    float ArmorConstant;
+    float CreatureSpellDamage;
+    int32 Lvl;
+};
+
+struct ExpectedStatModEntry
+{
+    uint32 ID;
+    float CreatureHealthMod;
+    float PlayerHealthMod;
+    float CreatureAutoAttackDPSMod;
+    float CreatureArmorMod;
+    float PlayerManaMod;
+    float PlayerPrimaryStatMod;
+    float PlayerSecondaryStatMod;
+    float ArmorConstantMod;
+    float CreatureSpellDamageMod;
+};
+
 struct FactionEntry
 {
     int64 ReputationRaceMask[4];
     LocalizedString* Name;
     LocalizedString* Description;
     uint32 ID;
-    int32 ReputationBase[4];
-    float ParentFactionMod[2];                        // Faction outputs rep * ParentFactionModOut as spillover reputation
-    int32 ReputationMax[4];
     int16 ReputationIndex;
-    int16 ReputationClassMask[4];
-    uint16 ReputationFlags[4];
     uint16 ParentFactionID;
-    uint16 ParagonFactionID;
-    uint8 ParentFactionCap[2];                        // The highest rank the faction will profit from incoming spillover
     uint8 Expansion;
-    uint8 Flags;
     uint8 FriendshipRepID;
+    uint8 Flags;
+    uint16 ParagonFactionID;
+    int16 ReputationClassMask[4];
+    uint16 ReputationFlags[4];
+    int32 ReputationBase[4];
+    int32 ReputationMax[4];
+    float ParentFactionMod[2];                        // Faction outputs rep * ParentFactionModOut as spillover reputation
+    uint8 ParentFactionCap[2];                        // The highest rank the faction will profit from incoming spillover
 
     // helpers
     bool CanHaveReputation() const
@@ -966,11 +1033,11 @@ struct FactionTemplateEntry
     uint32 ID;
     uint16 Faction;
     uint16 Flags;
-    uint16 Enemies[MAX_FACTION_RELATIONS];
-    uint16 Friend[MAX_FACTION_RELATIONS];
     uint8 FactionGroup;
     uint8 FriendGroup;
     uint8 EnemyGroup;
+    uint16 Enemies[MAX_FACTION_RELATIONS];
+    uint16 Friend[MAX_FACTION_RELATIONS];
 
     //-------------------------------------------------------  end structure
 
@@ -1020,12 +1087,12 @@ struct FactionTemplateEntry
 struct GameObjectDisplayInfoEntry
 {
     uint32 ID;
-    int32 FileDataID;
     DBCPosition3D GeoBoxMin;
     DBCPosition3D GeoBoxMax;
+    int32 FileDataID;
+    int16 ObjectEffectPackageID;
     float OverrideLootEffectScale;
     float OverrideNameScale;
-    int16 ObjectEffectPackageID;
 };
 
 struct GameObjectsEntry
@@ -1033,65 +1100,65 @@ struct GameObjectsEntry
     LocalizedString* Name;
     DBCPosition3D Pos;
     float Rot[4];
-    float Scale;
-    int32 PropValue[8];
+    uint32 ID;
     uint16 OwnerID;
     uint16 DisplayID;
+    float Scale;
+    uint8 TypeID;
+    uint8 PhaseUseFlags;
     uint16 PhaseID;
     uint16 PhaseGroupID;
-    uint8 PhaseUseFlags;
-    uint8 TypeID;
-    uint32 ID;
+    int32 PropValue[8];
 };
 
 struct GarrAbilityEntry
 {
     LocalizedString* Name;
     LocalizedString* Description;
-    int32 IconFileDataID;
-    uint16 Flags;
-    uint16 FactionChangeGarrAbilityID;
+    uint32 ID;
     uint8 GarrAbilityCategoryID;
     uint8 GarrFollowerTypeID;
-    uint32 ID;
+    int32 IconFileDataID;
+    uint16 FactionChangeGarrAbilityID;
+    uint16 Flags;
 };
 
 struct GarrBuildingEntry
 {
     uint32 ID;
-    LocalizedString* AllianceName;
     LocalizedString* HordeName;
+    LocalizedString* AllianceName;
     LocalizedString* Description;
     LocalizedString* Tooltip;
+    uint8 GarrTypeID;
+    uint8 BuildingType;
     int32 HordeGameObjectID;
     int32 AllianceGameObjectID;
-    int32 IconFileDataID;
+    uint8 GarrSiteID;
+    uint8 UpgradeLevel;
+    int32 BuildSeconds;
     uint16 CurrencyTypeID;
+    int32 CurrencyQty;
     uint16 HordeUiTextureKitID;
     uint16 AllianceUiTextureKitID;
+    int32 IconFileDataID;
     uint16 AllianceSceneScriptPackageID;
     uint16 HordeSceneScriptPackageID;
+    int32 MaxAssignments;
+    uint8 ShipmentCapacity;
     uint16 GarrAbilityID;
     uint16 BonusGarrAbilityID;
     uint16 GoldCost;
-    uint8 GarrSiteID;
-    uint8 BuildingType;
-    uint8 UpgradeLevel;
     uint8 Flags;
-    uint8 ShipmentCapacity;
-    uint8 GarrTypeID;
-    int32 BuildSeconds;
-    int32 CurrencyQty;
-    int32 MaxAssignments;
 };
 
 struct GarrBuildingPlotInstEntry
 {
     DBCPosition2D MapOffset;
-    uint16 UiTextureAtlasMemberID;
-    uint16 GarrSiteLevelPlotInstID;
-    uint8 GarrBuildingID;
     uint32 ID;
+    uint8 GarrBuildingID;
+    uint16 GarrSiteLevelPlotInstID;
+    uint16 UiTextureAtlasMemberID;
 };
 
 struct GarrClassSpecEntry
@@ -1099,11 +1166,11 @@ struct GarrClassSpecEntry
     LocalizedString* ClassSpec;
     LocalizedString* ClassSpecMale;
     LocalizedString* ClassSpecFemale;
+    uint32 ID;
     uint16 UiTextureAtlasMemberID;
     uint16 GarrFollItemSetID;
     uint8 FollowerClassLimit;
     uint8 Flags;
-    uint32 ID;
 };
 
 struct GarrFollowerEntry
@@ -1111,54 +1178,55 @@ struct GarrFollowerEntry
     LocalizedString* HordeSourceText;
     LocalizedString* AllianceSourceText;
     LocalizedString* TitleName;
+    uint32 ID;
+    uint8 GarrTypeID;
+    uint8 GarrFollowerTypeID;
     int32 HordeCreatureID;
     int32 AllianceCreatureID;
-    int32 HordeIconFileDataID;
-    int32 AllianceIconFileDataID;
-    uint32 HordeSlottingBroadcastTextID;
-    uint32 AllySlottingBroadcastTextID;
-    uint16 HordeGarrFollItemSetID;
-    uint16 AllianceGarrFollItemSetID;
-    uint16 ItemLevelWeapon;
-    uint16 ItemLevelArmor;
-    uint16 HordeUITextureKitID;
-    uint16 AllianceUITextureKitID;
-    uint8 GarrFollowerTypeID;
     uint8 HordeGarrFollRaceID;
     uint8 AllianceGarrFollRaceID;
-    uint8 Quality;
     uint8 HordeGarrClassSpecID;
     uint8 AllianceGarrClassSpecID;
+    uint8 Quality;
     uint8 FollowerLevel;
-    uint8 Gender;
-    uint8 Flags;
+    uint16 ItemLevelWeapon;
+    uint16 ItemLevelArmor;
     int8 HordeSourceTypeEnum;
     int8 AllianceSourceTypeEnum;
-    uint8 GarrTypeID;
+    int32 HordeIconFileDataID;
+    int32 AllianceIconFileDataID;
+    uint16 HordeGarrFollItemSetID;
+    uint16 AllianceGarrFollItemSetID;
+    uint16 HordeUITextureKitID;
+    uint16 AllianceUITextureKitID;
     uint8 Vitality;
-    uint8 ChrClassID;
     uint8 HordeFlavorGarrStringID;
     uint8 AllianceFlavorGarrStringID;
-    uint32 ID;
+    uint32 HordeSlottingBroadcastTextID;
+    uint32 AllySlottingBroadcastTextID;
+    uint8 ChrClassID;
+    uint8 Flags;
+    uint8 Gender;
 };
 
 struct GarrFollowerXAbilityEntry
 {
     uint32 ID;
-    uint16 GarrAbilityID;
+    uint8 OrderIndex;
     uint8 FactionIndex;
+    uint16 GarrAbilityID;
     uint16 GarrFollowerID;
 };
 
 struct GarrPlotEntry
 {
     uint32 ID;
-    LocalizedString* Name;
-    int32 AllianceConstructObjID;
-    int32 HordeConstructObjID;
-    uint8 UiCategoryID;
+    char const* Name;
     uint8 PlotType;
+    int32 HordeConstructObjID;
+    int32 AllianceConstructObjID;
     uint8 Flags;
+    uint8 UiCategoryID;
     uint32 UpgradeRequirement[2];
 };
 
@@ -1180,14 +1248,14 @@ struct GarrSiteLevelEntry
 {
     uint32 ID;
     DBCPosition2D TownHallUiPos;
+    uint32 GarrSiteID;
+    uint8 GarrLevel;
     uint16 MapID;
-    uint16 UiTextureKitID;
     uint16 UpgradeMovieID;
+    uint16 UiTextureKitID;
+    uint8 MaxBuildingLevel;
     uint16 UpgradeCost;
     uint16 UpgradeGoldCost;
-    uint8 GarrLevel;
-    uint8 GarrSiteID;
-    uint8 MaxBuildingLevel;
 };
 
 struct GarrSiteLevelPlotInstEntry
@@ -1202,8 +1270,8 @@ struct GarrSiteLevelPlotInstEntry
 struct GemPropertiesEntry
 {
     uint32 ID;
-    uint32 Type;
     uint16 EnchantId;
+    int32 Type;
     uint16 MinItemLevel;
 };
 
@@ -1234,24 +1302,24 @@ struct GuildColorBackgroundEntry
 {
     uint32 ID;
     uint8 Red;
-    uint8 Green;
     uint8 Blue;
+    uint8 Green;
 };
 
 struct GuildColorBorderEntry
 {
     uint32 ID;
     uint8 Red;
-    uint8 Green;
     uint8 Blue;
+    uint8 Green;
 };
 
 struct GuildColorEmblemEntry
 {
     uint32 ID;
     uint8 Red;
-    uint8 Green;
     uint8 Blue;
+    uint8 Green;
 };
 
 struct GuildPerkSpellsEntry
@@ -1263,15 +1331,15 @@ struct GuildPerkSpellsEntry
 struct HeirloomEntry
 {
     LocalizedString* SourceText;
+    uint32 ID;
     int32 ItemID;
-    int32 LegacyItemID;
     int32 LegacyUpgradedItemID;
     int32 StaticUpgradedItemID;
+    int8 SourceTypeEnum;
+    uint8 Flags;
+    int32 LegacyItemID;
     int32 UpgradeItemID[3];
     uint16 UpgradeItemBonusListID[3];
-    uint8 Flags;
-    int8 SourceTypeEnum;
-    uint32 ID;
 };
 
 #define MAX_HOLIDAY_DURATIONS 10
@@ -1281,16 +1349,16 @@ struct HeirloomEntry
 struct HolidaysEntry
 {
     uint32 ID;
-    uint32 Date[MAX_HOLIDAY_DATES];                                 // dates in unix time starting at January, 1, 2000
-    uint16 Duration[MAX_HOLIDAY_DURATIONS];
     uint16 Region;
     uint8 Looping;
-    uint8 CalendarFlags[MAX_HOLIDAY_FLAGS];
+    uint32 HolidayNameID;
+    uint32 HolidayDescriptionID;
     uint8 Priority;
     int8 CalendarFilterType;
     uint8 Flags;
-    uint32 HolidayNameID;
-    uint32 HolidayDescriptionID;
+    uint16 Duration[MAX_HOLIDAY_DURATIONS];
+    uint32 Date[MAX_HOLIDAY_DATES];                                 // dates in unix time starting at January, 1, 2000
+    uint8 CalendarFlags[MAX_HOLIDAY_DURATIONS];
     int32 TextureFileDataID[3];
 };
 
@@ -1324,30 +1392,29 @@ struct ImportPriceWeaponEntry
 struct ItemEntry
 {
     uint32 ID;
-    int32 IconFileDataID;
     uint8 ClassID;
     uint8 SubclassID;
-    int8 SoundOverrideSubclassID;
     uint8 Material;
-    uint8 InventoryType;
+    int8 InventoryType;
     uint8 SheatheType;
+    int8 SoundOverrideSubclassID;
+    int32 IconFileDataID;
     uint8 ItemGroupSoundsID;
 };
 
 struct ItemAppearanceEntry
 {
     uint32 ID;
+    uint8 DisplayType;
     int32 ItemDisplayInfoID;
     int32 DefaultIconFileDataID;
     int32 UiOrder;
-    uint8 DisplayType;
 };
 
 struct ItemArmorQualityEntry
 {
     uint32 ID;
     float Qualitymod[7];
-    int16 ItemLevel;
 };
 
 struct ItemArmorShieldEntry
@@ -1360,11 +1427,11 @@ struct ItemArmorShieldEntry
 struct ItemArmorTotalEntry
 {
     uint32 ID;
+    int16 ItemLevel;
     float Cloth;
     float Leather;
     float Mail;
     float Plate;
-    int16 ItemLevel;
 };
 
 struct ItemBagFamilyEntry
@@ -1391,10 +1458,10 @@ struct ItemBonusListLevelDeltaEntry
 struct ItemBonusTreeNodeEntry
 {
     uint32 ID;
+    uint8 ItemContext;
     uint16 ChildItemBonusTreeID;
     uint16 ChildItemBonusListID;
     uint16 ChildItemLevelSelectorID;
-    uint8 ItemContext;
     uint16 ParentItemBonusTreeID;
 };
 
@@ -1410,8 +1477,8 @@ struct ItemClassEntry
 {
     uint32 ID;
     LocalizedString* ClassName;
-    float PriceModifier;
     int8 ClassID;
+    float PriceModifier;
     uint8 Flags;
 };
 
@@ -1424,46 +1491,46 @@ struct ItemCurrencyCostEntry
 struct ItemDamageAmmoEntry
 {
     uint32 ID;
-    float Quality[7];
     uint16 ItemLevel;
+    float Quality[7];
 };
 
 struct ItemDamageOneHandEntry
 {
     uint32 ID;
-    float Quality[7];
     uint16 ItemLevel;
+    float Quality[7];
 };
 
 struct ItemDamageOneHandCasterEntry
 {
     uint32 ID;
-    float Quality[7];
     uint16 ItemLevel;
+    float Quality[7];
 };
 
 struct ItemDamageTwoHandEntry
 {
     uint32 ID;
-    float Quality[7];
     uint16 ItemLevel;
+    float Quality[7];
 };
 
 struct ItemDamageTwoHandCasterEntry
 {
     uint32 ID;
-    float Quality[7];
     uint16 ItemLevel;
+    float Quality[7];
 };
 
 struct ItemDisenchantLootEntry
 {
     uint32 ID;
+    int8 Subclass;
+    uint8 Quality;
     uint16 MinLevel;
     uint16 MaxLevel;
     uint16 SkillRequired;
-    int8 Subclass;
-    uint8 Quality;
     int8 ExpansionID;
     uint8 Class;
 };
@@ -1471,14 +1538,14 @@ struct ItemDisenchantLootEntry
 struct ItemEffectEntry
 {
     uint32 ID;
-    int32 SpellID;
+    uint8 LegacySlotIndex;
+    int8 TriggerType;
+    int16 Charges;
     int32 CoolDownMSec;
     int32 CategoryCoolDownMSec;
-    int16 Charges;
     uint16 SpellCategoryID;
+    int32 SpellID;
     uint16 ChrSpecializationID;
-    uint8 LegacySlotIndex;
-    int8 TriggerType;
     int32 ParentItemID;
 };
 
@@ -1488,16 +1555,16 @@ struct ItemEffectEntry
 struct ItemExtendedCostEntry
 {
     uint32 ID;
+    uint16 RequiredArenaRating;
+    int8 ArenaBracket;                                             // arena slot restrictions (min slot value)
+    uint8 Flags;
+    uint8 MinFactionID;
+    uint8 MinReputation;
+    uint8 RequiredAchievement;                                      // required personal arena rating
     int32 ItemID[MAX_ITEM_EXT_COST_ITEMS];                          // required item id
-    uint32 CurrencyCount[MAX_ITEM_EXT_COST_CURRENCIES];             // required curency count
     uint16 ItemCount[MAX_ITEM_EXT_COST_ITEMS];                      // required count of 1st item
-    uint16 RequiredArenaRating;                                     // required personal arena rating
     uint16 CurrencyID[MAX_ITEM_EXT_COST_CURRENCIES];                // required curency id
-    uint8 ArenaBracket;                                             // arena slot restrictions (min slot value)
-    uint8 MinFactionID;
-    uint8 MinReputation;
-    uint8 Flags;
-    uint8 RequiredAchievement;
+    uint32 CurrencyCount[MAX_ITEM_EXT_COST_CURRENCIES];              // required curency count
 };
 
 struct ItemLevelSelectorEntry
@@ -1540,8 +1607,8 @@ struct ItemLimitCategoryConditionEntry
 
 struct ItemModifiedAppearanceEntry
 {
-    int32 ItemID;
     uint32 ID;
+    int32 ItemID;
     uint8 ItemAppearanceModifierID;
     uint16 ItemAppearanceID;
     uint8 OrderIndex;
@@ -1551,9 +1618,9 @@ struct ItemModifiedAppearanceEntry
 struct ItemPriceBaseEntry
 {
     uint32 ID;
+    uint16 ItemLevel;
     float Armor;
     float Weapon;
-    uint16 ItemLevel;
 };
 
 #define MAX_ITEM_RANDOM_PROPERTIES 5
@@ -1578,17 +1645,17 @@ struct ItemSearchNameEntry
     int64 AllowableRace;
     LocalizedString* Display;
     uint32 ID;
-    int32 Flags[3];
-    uint16 ItemLevel;
     uint8 OverallQualityID;
     uint8 ExpansionID;
-    int8 RequiredLevel;
     uint16 MinFactionID;
     uint8 MinReputation;
     int32 AllowableClass;
+    int8 RequiredLevel;
     uint16 RequiredSkill;
     uint16 RequiredSkillRank;
     uint32 RequiredAbility;
+    uint16 ItemLevel;
+    int32 Flags[4];
 };
 
 #define MAX_ITEM_SET_ITEMS 17
@@ -1597,17 +1664,17 @@ struct ItemSetEntry
 {
     uint32 ID;
     LocalizedString* Name;
-    uint32 ItemID[MAX_ITEM_SET_ITEMS];
-    uint16 RequiredSkillRank;
-    uint32 RequiredSkill;
     uint32 SetFlags;
+    uint32 RequiredSkill;
+    uint16 RequiredSkillRank;
+    uint32 ItemID[MAX_ITEM_SET_ITEMS];
 };
 
 struct ItemSetSpellEntry
 {
     uint32 ID;
-    uint32 SpellID;
     uint16 ChrSpecID;
+    uint32 SpellID;
     uint8 Threshold;
     uint16 ItemSetID;
 };
@@ -1616,80 +1683,80 @@ struct ItemSparseEntry
 {
     uint32 ID;
     int64 AllowableRace;
-    LocalizedString* Display;
-    LocalizedString* Display1;
-    LocalizedString* Display2;
-    LocalizedString* Display3;
     LocalizedString* Description;
-    int32 Flags[MAX_ITEM_PROTO_FLAGS];
-    float PriceRandomValue;
-    float PriceVariance;
-    uint32 VendorStackCount;
-    uint32 BuyPrice;
-    uint32 SellPrice;
-    uint32 RequiredAbility;
-    int32 MaxCount;
-    int32 Stackable;
-    int32 StatPercentEditor[MAX_ITEM_PROTO_STATS];
-    float StatPercentageOfSocket[MAX_ITEM_PROTO_STATS];
-    float ItemRange;
-    uint32 BagFamily;
-    float QualityModifier;
-    uint32 DurationInInventory;
+    LocalizedString* Display3;
+    LocalizedString* Display2;
+    LocalizedString* Display1;
+    LocalizedString* Display;
     float DmgVariance;
-    int16 AllowableClass;
-    uint16 ItemLevel;
-    uint16 RequiredSkill;
-    uint16 RequiredSkillRank;
-    uint16 MinFactionID;
-    int16 ItemStatValue[MAX_ITEM_PROTO_STATS];
-    uint16 ScalingStatDistributionID;
-    uint16 ItemDelay;
-    uint16 PageID;
-    uint16 StartQuestID;
-    uint16 LockID;
-    uint16 RandomSelect;
-    uint16 ItemRandomSuffixGroupID;
-    uint16 ItemSet;
-    uint16 ZoneBound;
-    uint16 InstanceBound;
-    uint16 TotemCategoryID;
-    uint16 SocketMatchEnchantmentId;
-    uint16 GemProperties;
-    uint16 LimitCategory;
-    uint16 RequiredHoliday;
-    uint16 RequiredTransmogHoliday;
+    uint32 DurationInInventory;
+    float QualityModifier;
+    uint32 BagFamily;
+    float ItemRange;
+    float StatPercentageOfSocket[MAX_ITEM_PROTO_STATS];
+    int32 StatPercentEditor[MAX_ITEM_PROTO_STATS];
+    int32 Stackable;
+    int32 MaxCount;
+    uint32 RequiredAbility;
+    uint32 SellPrice;
+    uint32 BuyPrice;
+    uint32 VendorStackCount;
+    float PriceVariance;
+    float PriceRandomValue;
+    int32 Flags[MAX_ITEM_PROTO_FLAGS];
+    int32 FactionRelated;
     uint16 ItemNameDescriptionID;
-    uint8 OverallQualityID;
-    uint8 InventoryType;
-    int8 RequiredLevel;
-    uint8 RequiredPVPRank;
-    uint8 RequiredPVPMedal;
-    uint8 MinReputation;
-    uint8 ContainerSlots;
-    int8 StatModifierBonusStat[MAX_ITEM_PROTO_STATS];
-    uint8 DamageDamageType;
-    uint8 Bonding;
-    uint8 LanguageID;
-    uint8 PageMaterialID;
-    uint8 Material;
-    uint8 SheatheType;
-    uint8 SocketType[MAX_ITEM_PROTO_SOCKETS];
-    uint8 SpellWeightCategory;
-    uint8 SpellWeight;
-    uint8 ArtifactID;
+    uint16 RequiredTransmogHoliday;
+    uint16 RequiredHoliday;
+    uint16 LimitCategory;
+    uint16 GemProperties;
+    uint16 SocketMatchEnchantmentId;
+    uint16 TotemCategoryID;
+    uint16 InstanceBound;
+    uint16 ZoneBound;
+    uint16 ItemSet;
+    uint16 ItemRandomSuffixGroupID;
+    uint16 RandomSelect;
+    uint16 LockID;
+    uint16 StartQuestID;
+    uint16 PageID;
+    uint16 ItemDelay;
+    uint16 ScalingStatDistributionID;
+    uint16 MinFactionID;
+    uint16 RequiredSkillRank;
+    uint16 RequiredSkill;
+    uint16 ItemLevel;
+    int16 AllowableClass;
     uint8 ExpansionID;
+    uint8 ArtifactID;
+    uint8 SpellWeight;
+    uint8 SpellWeightCategory;
+    uint8 SocketType[MAX_ITEM_PROTO_SOCKETS];
+    uint8 SheatheType;
+    uint8 Material;
+    uint8 PageMaterialID;
+    uint8 LanguageID;
+    uint8 Bonding;
+    uint8 DamageDamageType;
+    int8 StatModifierBonusStat[MAX_ITEM_PROTO_STATS];
+    uint8 ContainerSlots;
+    uint8 MinReputation;
+    uint8 RequiredPVPMedal;
+    uint8 RequiredPVPRank;
+    int8 RequiredLevel;
+    uint8 InventoryType;
+    uint8 OverallQualityID;
 };
 
 struct ItemSpecEntry
 {
     uint32 ID;
-    uint16 SpecializationID;
     uint8 MinLevel;
     uint8 MaxLevel;
     uint8 ItemType;
     uint8 PrimaryStat;
     uint8 SecondaryStat;
+    uint16 SpecializationID;
 };
 
 struct ItemSpecOverrideEntry
@@ -1702,11 +1769,11 @@ struct ItemSpecOverrideEntry
 struct ItemUpgradeEntry
 {
     uint32 ID;
-    uint32 CurrencyAmount;
-    uint16 PrerequisiteID;
-    uint16 CurrencyType;
     uint8 ItemUpgradePathID;
     uint8 ItemLevelIncrement;
+    uint16 PrerequisiteID;
+    uint16 CurrencyType;
+    uint32 CurrencyAmount;
 };
 
 struct ItemXBonusTreeEntry
@@ -1729,37 +1796,37 @@ struct LFGDungeonsEntry
     uint32 ID;
     LocalizedString* Name;
     LocalizedString* Description;
-    int32 Flags;
-    float MinGear;
-    uint16 MaxLevel;
-    uint16 TargetLevelMax;
-    int16 MapID;
-    uint16 RandomID;
-    uint16 ScenarioID;
-    uint16 FinalEncounterID;
-    uint16 BonusReputationAmount;
-    uint16 MentorItemLevel;
-    uint16 RequiredPlayerConditionId;
     uint8 MinLevel;
-    uint8 TargetLevel;
-    uint8 TargetLevelMin;
-    uint8 DifficultyID;
+    uint16 MaxLevel;
     uint8 TypeID;
+    uint8 Subtype;
     int8 Faction;
+    int32 IconTextureFileID;
+    int32 RewardsBgTextureFileID;
+    int32 PopupBgTextureFileID;
     uint8 ExpansionLevel;
-    uint8 OrderIndex;
+    int16 MapID;
+    uint8 DifficultyID;
+    float MinGear;
     uint8 GroupID;
+    uint8 OrderIndex;
+    uint32 RequiredPlayerConditionId;
+    uint8 TargetLevel;
+    uint8 TargetLevelMin;
+    uint16 TargetLevelMax;
+    uint16 RandomID;
+    uint16 ScenarioID;
+    uint16 FinalEncounterID;
     uint8 CountTank;
     uint8 CountHealer;
     uint8 CountDamage;
     uint8 MinCountTank;
     uint8 MinCountHealer;
     uint8 MinCountDamage;
-    uint8 Subtype;
+    uint16 BonusReputationAmount;
+    uint16 MentorItemLevel;
     uint8 MentorCharLevel;
-    int32 IconTextureFileID;
-    int32 RewardsBgTextureFileID;
-    int32 PopupBgTextureFileID;
+    int32 Flags[2];
 
     // Helpers
     uint32 Entry() const { return ID + (TypeID << 24); }
@@ -1780,23 +1847,25 @@ struct LiquidTypeEntry
     uint32 ID;
     char const* Name;
     char const* Texture[6];
+    uint16 Flags;
+    uint8 SoundBank;                                                // used to be "type", maybe needs fixing (works well for now)
+    uint32 SoundID;
     uint32 SpellID;
     float MaxDarkenDepth;
     float FogDarkenIntensity;
     float AmbDarkenIntensity;
     float DirDarkenIntensity;
-    float ParticleScale;
-    int32 Color[2];
-    float Float[18];
-    uint32 Int[4];
-    uint16 Flags;
     uint16 LightID;
-    uint8 SoundBank;                                                // used to be "type", maybe needs fixing (works well for now)
+    float ParticleScale;
     uint8 ParticleMovement;
     uint8 ParticleTexSlots;
     uint8 MaterialID;
+    int32 MinimapStaticCol;
     uint8 FrameCountTexture[6];
-    uint32 SoundID;
+    int32 Color[2];
+    float Float[18];
+    uint32 Int[4];
+    float Coefficient[4];
 };
 
 #define MAX_LOCK_CASE 8
@@ -1825,21 +1894,22 @@ struct MapEntry
     LocalizedString* MapDescription1;                               // Alliance
     LocalizedString* PvpShortDescription;
     LocalizedString* PvpLongDescription;
-    int32 Flags[2];
-    float MinimapIconScale;
     DBCPosition2D Corpse;                                           // entrance coordinates in ghost mode  (in most cases = normal entrance)
+    uint8 MapType;
+    int8 InstanceType;
+    uint8 ExpansionID;
     uint16 AreaTableID;
     int16 LoadingScreenID;
-    int16 CorpseMapID;                                              // map_id of entrance map in ghost mode (continent always and in most cases = normal entrance)
     int16 TimeOfDayOverride;
     int16 ParentMapID;
     int16 CosmeticParentMapID;
-    int16 WindSettingsID;
-    uint8 InstanceType;
-    uint8 MapType;
-    uint8 ExpansionID;
-    uint8 MaxPlayers;
     uint8 TimeOffset;
+    float MinimapIconScale;
+    int16 CorpseMapID;                                              // map_id of entrance map in ghost mode (continent always and in most cases = normal entrance)
+    uint8 MaxPlayers;
+    int16 WindSettingsID;
+    int32 ZmpFileDataID;
+    int32 Flags[2];
 
     // Helpers
     uint8 Expansion() const { return ExpansionID; }
@@ -1877,13 +1947,14 @@ struct MapDifficultyEntry
 {
     uint32 ID;
     LocalizedString* Message;                               // m_message_lang (text showed when transfer to map failed)
+    uint32 ItemContextPickerID;
+    int32 ContentTuningID;
     uint8 DifficultyID;
+    uint8 LockID;
     uint8 ResetInterval;
     uint8 MaxPlayers;
-    uint8 LockID;
-    uint8 Flags;
     uint8 ItemContext;
-    uint32 ItemContextPickerID;
+    uint8 Flags;
     uint16 MapID;
 
     uint32 GetRaidDuration() const
@@ -1899,27 +1970,27 @@ struct MapDifficultyEntry
 struct ModifierTreeEntry
 {
     uint32 ID;
-    int32 Asset;
-    int32 SecondaryAsset;
     uint32 Parent;
-    uint8 Type;
-    int8 TertiaryAsset;
     int8 Operator;
     int8 Amount;
+    uint8 Type;
+    int32 Asset;
+    int32 SecondaryAsset;
+    int8 TertiaryAsset;
 };
 
 struct MountEntry
 {
     LocalizedString* Name;
-    LocalizedString* Description;
     LocalizedString* SourceText;
-    int32 SourceSpellID;
-    float MountFlyRideHeight;
+    LocalizedString* Description;
+    uint32 ID;
     uint16 MountTypeID;
     uint16 Flags;
     int8 SourceTypeEnum;
-    uint32 ID;
+    int32 SourceSpellID;
     uint32 PlayerConditionID;
+    float MountFlyRideHeight;
     int32 UiModelSceneID;
 
     bool IsSelfMount() const { return (Flags & MOUNT_FLAG_SELF_MOUNT) != 0; }
@@ -1927,14 +1998,14 @@ struct MountEntry
 
 struct MountCapabilityEntry
 {
-    int32 ReqSpellKnownID;
-    int32 ModSpellAuraID;
+    uint32 ID;
+    uint8 Flags;
     uint16 ReqRidingSkill;
     uint16 ReqAreaID;
-    int16 ReqMapID;
-    uint8 Flags;
-    uint32 ID;
     uint32 ReqSpellAuraID;
+    int32 ReqSpellKnownID;
+    int32 ModSpellAuraID;
+    int16 ReqMapID;
 };
 
 struct MountTypeXCapabilityEntry
@@ -1956,10 +2027,10 @@ struct MountXDisplayEntry
 struct MovieEntry
 {
     uint32 ID;
-    uint32 AudioFileDataID;
-    uint32 SubtitleFileDataID;
     uint8 Volume;
     uint8 KeyID;
+    uint32 AudioFileDataID;
+    uint32 SubtitleFileDataID;
 };
 
 struct NameGenEntry
@@ -1990,6 +2061,14 @@ struct NamesReservedLocaleEntry
     uint8 LocaleMask;
 };
 
+struct NumTalentsAtLevelEntry
+{
+    uint32 ID;
+    int32 NumTalents;
+    int32 NumTalentsDeathKnight;
+    int32 NumTalentsDemonHunter;
+};
+
 #define MAX_OVERRIDE_SPELL 10
 
 struct OverrideSpellDataEntry
@@ -2018,12 +2097,9 @@ struct PlayerConditionEntry
     int64 RaceMask;
     LocalizedString* FailureDescription;
     uint32 ID;
-    uint8 Flags;
     uint16 MinLevel;
     uint16 MaxLevel;
     int32 ClassMask;
-    int8 Gender;
-    int8 NativeGender;
     uint32 SkillLogic;
     uint8 LanguageID;
     uint8 MinLanguage;
@@ -2032,8 +2108,6 @@ struct PlayerConditionEntry
     uint8 MaxReputation;
     uint32 ReputationLogic;
     int8 CurrentPvpFaction;
-    uint8 MinPVPRank;
-    uint8 MaxPVPRank;
     uint8 PvpMedal;
     uint32 PrevQuestLogic;
     uint32 CurrQuestLogic;
@@ -2047,31 +2121,36 @@ struct PlayerConditionEntry
     uint8 PartyStatus;
     uint8 LifetimeMaxPVPRank;
     uint32 AchievementLogic;
-    uint32 LfgLogic;
+    int8 Gender;
+    int8 NativeGender;
     uint32 AreaLogic;
+    uint32 LfgLogic;
     uint32 CurrencyLogic;
     uint16 QuestKillID;
     uint32 QuestKillLogic;
     int8 MinExpansionLevel;
     int8 MaxExpansionLevel;
-    int8 MinExpansionTier;
-    int8 MaxExpansionTier;
-    uint8 MinGuildLevel;
-    uint8 MaxGuildLevel;
-    uint8 PhaseUseFlags;
-    uint16 PhaseID;
-    uint32 PhaseGroupID;
     int32 MinAvgItemLevel;
     int32 MaxAvgItemLevel;
     uint16 MinAvgEquippedItemLevel;
     uint16 MaxAvgEquippedItemLevel;
+    uint8 PhaseUseFlags;
+    uint16 PhaseID;
+    uint32 PhaseGroupID;
+    uint8 Flags;
     int8 ChrSpecializationIndex;
     int8 ChrSpecializationRole;
+    uint32 ModifierTreeID;
     int8 PowerType;
     uint8 PowerTypeComp;
     uint8 PowerTypeValue;
-    uint32 ModifierTreeID;
     int32 WeaponSubclassMask;
+    uint8 MaxGuildLevel;
+    uint8 MinGuildLevel;
+    int8 MaxExpansionTier;
+    int8 MinExpansionTier;
+    uint8 MinPVPRank;
+    uint8 MaxPVPRank;
     uint16 SkillID[4];
     uint16 MinSkill[4];
     uint16 MaxSkill[4];
@@ -2088,10 +2167,10 @@ struct PlayerConditionEntry
     int32 AuraSpellID[4];
     uint8 AuraStacks[4];
     uint16 Achievement[4];
+    uint16 AreaID[4];
     uint8 LfgStatus[4];
     uint8 LfgCompare[4];
     uint32 LfgValue[4];
-    uint16 AreaID[4];
     uint32 CurrencyID[4];
     uint32 CurrencyCount[4];
     uint32 QuestKillMonster[6];
@@ -2113,25 +2192,26 @@ struct PowerTypeEntry
     uint32 ID;
     char const* NameGlobalStringTag;
     char const* CostGlobalStringTag;
-    float RegenPeace;
-    float RegenCombat;
-    int16 MaxBasePower;
-    int16 RegenInterruptTimeMS;
-    int16 Flags;
     int8 PowerTypeEnum;
     int8 MinPower;
+    int16 MaxBasePower;
     int8 CenterPower;
     int8 DefaultPower;
     int8 DisplayModifier;
+    int16 RegenInterruptTimeMS;
+    float RegenPeace;
+    float RegenCombat;
+    int16 Flags;
 };
 
 struct PrestigeLevelInfoEntry
 {
     uint32 ID;
     LocalizedString* Name;
+    int32 PrestigeLevel;
     int32 BadgeTextureFileDataID;
-    uint8 PrestigeLevel;
     uint8 Flags;
+    int32 AwardedAchievementID;
 
     bool IsDisabled() const { return (Flags & PRESTIGE_FLAG_DISABLED) != 0; }
 };
@@ -2155,35 +2235,32 @@ struct PVPItemEntry
     uint8 ItemLevelDelta;
 };
 
-struct PvpRewardEntry
-{
-    uint32 ID;
-    int32 HonorLevel;
-    int32 PrestigeLevel;
-    int32 RewardPackID;
-};
-
 struct PvpTalentEntry
 {
-    uint32 ID;
     LocalizedString* Description;
+    uint32 ID;
+    int32 SpecID;
     int32 SpellID;
     int32 OverridesSpellID;
-    int32 ActionBarSpellID;
-    int32 TierID;
-    int32 ColumnIndex;
     int32 Flags;
-    int32 ClassID;
-    int32 SpecID;
-    int32 Role;
+    int32 ActionBarSpellID;
+    int32 PvpTalentCategoryID;
+    int32 LevelRequired;
+};
+
+struct PvpTalentCategoryEntry
+{
+    uint32 ID;
+    uint8 TalentSlotMask;
 };
 
-struct PvpTalentUnlockEntry
+struct PvpTalentSlotUnlockEntry
 {
     uint32 ID;
-    int32 TierID;
-    int32 ColumnIndex;
-    int32 HonorLevel;
+    int8 Slot;
+    int32 LevelRequired;
+    int32 DeathKnightLevelRequired;
+    int32 DemonHunterLevelRequired;
 };
 
 struct QuestFactionRewardEntry
@@ -2201,10 +2278,10 @@ struct QuestMoneyRewardEntry
 struct QuestPackageItemEntry
 {
     uint32 ID;
-    int32 ItemID;
     uint16 PackageID;
-    uint8 DisplayType;
+    int32 ItemID;
     uint32 ItemQuantity;
+    uint8 DisplayType;
 };
 
 struct QuestSortEntry
@@ -2229,6 +2306,7 @@ struct QuestXPEntry
 struct RandPropPointsEntry
 {
     uint32 ID;
+    int32 DamageReplaceStat;
     uint32 Epic[5];
     uint32 Superior[5];
     uint32 Good[5];
@@ -2237,11 +2315,11 @@ struct RandPropPointsEntry
 struct RewardPackEntry
 {
     uint32 ID;
+    int32 CharTitleID;
     uint32 Money;
-    float ArtifactXPMultiplier;
     int8 ArtifactXPDifficulty;
+    float ArtifactXPMultiplier;
     uint8 ArtifactXPCategoryID;
-    int32 CharTitleID;
     uint32 TreasurePickerID;
 };
 
@@ -2268,14 +2346,6 @@ struct RulesetItemUpgradeEntry
     uint16 ItemUpgradeID;
 };
 
-struct SandboxScalingEntry
-{
-    uint32 ID;
-    int32 MinLevel;
-    int32 MaxLevel;
-    int32 Flags;
-};
-
 struct ScalingStatDistributionEntry
 {
     uint32 ID;
@@ -2289,8 +2359,9 @@ struct ScenarioEntry
     uint32 ID;
     LocalizedString* Name;
     uint16 AreaTableID;
-    uint8 Flags;
     uint8 Type;
+    uint8 Flags;
+    uint32 UiTextureKitID;
 };
 
 struct ScenarioStepEntry
@@ -2299,12 +2370,14 @@ struct ScenarioStepEntry
     LocalizedString* Description;
     LocalizedString* Title;
     uint16 ScenarioID;
-    uint16 Supersedes;                                              // Used in conjunction with Proving Grounds scenarios, when sequencing steps (Not using step order?)
+    uint32 Criteriatreeid;
     uint16 RewardQuestID;
+    int32 RelatedStep;                                              // Bonus step can only be completed if scenario is in the step specified in this field
+    uint16 Supersedes;                                              // Used in conjunction with Proving Grounds scenarios, when sequencing steps (Not using step order?)
     uint8 OrderIndex;
     uint8 Flags;
-    uint32 Criteriatreeid;
-    int32 RelatedStep;                                              // Bonus step can only be completed if scenario is in the step specified in this field
+    uint32 VisibilityPlayerConditionID;
+    uint16 WidgetSetID;
 
     // helpers
     bool IsBonusObjective() const
@@ -2342,33 +2415,38 @@ struct SceneScriptTextEntry
 
 struct SkillLineEntry
 {
-    uint32 ID;
     LocalizedString* DisplayName;
-    LocalizedString* Description;
     LocalizedString* AlternateVerb;
-    uint16 Flags;
+    LocalizedString* Description;
+    LocalizedString* HordeDisplayName;
+    char const* OverrideSourceInfoDisplayName;
+    uint32 ID;
     int8 CategoryID;
-    int8 CanLink;
     int32 SpellIconFileID;
+    int8 CanLink;
     uint32 ParentSkillLineID;
+    int32 ParentTierIndex;
+    uint16 Flags;
+    int32 SpellBookSpellID;
 };
 
 struct SkillLineAbilityEntry
 {
     int64 RaceMask;
     uint32 ID;
+    int16 SkillLine;
     int32 Spell;
+    int16 MinSkillLineRank;
+    int32 ClassMask;
     int32 SupercedesSpell;
-    int16 SkillLine;
+    int8 AcquireMethod;
     int16 TrivialSkillLineRankHigh;
     int16 TrivialSkillLineRankLow;
+    int8 Flags;
+    int8 NumSkillUps;
     int16 UniqueBit;
     int16 TradeSkillCategoryID;
-    int8 NumSkillUps;
-    int32 ClassMask;
-    int16 MinSkillLineRank;
-    int8 AcquireMethod;
-    int8 Flags;
+    int16 SkillupSkillLineID;
 };
 
 struct SkillRaceClassInfoEntry
@@ -2376,28 +2454,28 @@ struct SkillRaceClassInfoEntry
     uint32 ID;
     int64 RaceMask;
     int16 SkillID;
+    int32 ClassMask;
     uint16 Flags;
-    int16 SkillTierID;
     int8 Availability;
     int8 MinLevel;
-    int32 ClassMask;
+    int16 SkillTierID;
 };
 
 struct SoundKitEntry
 {
     uint32 ID;
+    uint8 SoundType;
     float VolumeFloat;
+    uint16 Flags;
     float MinDistance;
     float DistanceCutoff;
-    uint16 Flags;
-    uint16 SoundEntriesAdvancedID;
-    uint8 SoundType;
-    uint8 DialogType;
     uint8 EAXDef;
+    uint32 SoundKitAdvancedID;
     float VolumeVariationPlus;
     float VolumeVariationMinus;
     float PitchVariationPlus;
     float PitchVariationMinus;
+    int8 DialogType;
     float PitchAdjust;
     uint16 BusOverwriteID;
     uint8 MaxInstances;
@@ -2406,47 +2484,38 @@ struct SoundKitEntry
 struct SpecializationSpellsEntry
 {
     LocalizedString* Description;
+    uint32 ID;
+    uint16 SpecID;
     int32 SpellID;
     int32 OverridesSpellID;
-    uint16 SpecID;
     uint8 DisplayOrder;
-    uint32 ID;
-};
-
-struct SpellEntry
-{
-    uint32 ID;
-    LocalizedString* Name;
-    LocalizedString* NameSubtext;
-    LocalizedString* Description;
-    LocalizedString* AuraDescription;
 };
 
 struct SpellAuraOptionsEntry
 {
     uint32 ID;
-    int32 ProcCharges;
-    int32 ProcTypeMask;
-    int32 ProcCategoryRecovery;
-    uint16 CumulativeAura;
-    uint16 SpellProcsPerMinuteID;
     uint8 DifficultyID;
+    uint16 CumulativeAura;
+    int32 ProcCategoryRecovery;
     uint8 ProcChance;
+    int32 ProcCharges;
+    uint16 SpellProcsPerMinuteID;
+    int32 ProcTypeMask[2];
     int32 SpellID;
 };
 
 struct SpellAuraRestrictionsEntry
 {
     uint32 ID;
-    int32 CasterAuraSpell;
-    int32 TargetAuraSpell;
-    int32 ExcludeCasterAuraSpell;
-    int32 ExcludeTargetAuraSpell;
     uint8 DifficultyID;
     uint8 CasterAuraState;
     uint8 TargetAuraState;
     uint8 ExcludeCasterAuraState;
     uint8 ExcludeTargetAuraState;
+    int32 CasterAuraSpell;
+    int32 TargetAuraSpell;
+    int32 ExcludeCasterAuraSpell;
+    int32 ExcludeTargetAuraSpell;
     int32 SpellID;
 };
 
@@ -2454,33 +2523,33 @@ struct SpellCastTimesEntry
 {
     uint32 ID;
     int32 Base;
-    int32 Minimum;
     int16 PerLevel;
+    int32 Minimum;
 };
 
 struct SpellCastingRequirementsEntry
 {
     uint32 ID;
     int32 SpellID;
-    uint16 MinFactionID;
-    uint16 RequiredAreasID;
-    uint16 RequiresSpellFocus;
     uint8 FacingCasterFlags;
+    uint16 MinFactionID;
     int8 MinReputation;
+    uint16 RequiredAreasID;
     uint8 RequiredAuraVision;
+    uint16 RequiresSpellFocus;
 };
 
 struct SpellCategoriesEntry
 {
     uint32 ID;
-    int16 Category;
-    int16 StartRecoveryCategory;
-    int16 ChargeCategory;
     uint8 DifficultyID;
+    int16 Category;
     int8 DefenseType;
     int8 DispelType;
     int8 Mechanic;
     int8 PreventionType;
+    int16 StartRecoveryCategory;
+    int16 ChargeCategory;
     int32 SpellID;
 };
 
@@ -2488,10 +2557,10 @@ struct SpellCategoryEntry
 {
     uint32 ID;
     LocalizedString* Name;
-    int32 ChargeRecoveryTime;
     int8 Flags;
     uint8 UsesPerWeek;
     int8 MaxCharges;
+    int32 ChargeRecoveryTime;
     int32 TypeMask;
 };
 
@@ -2499,18 +2568,18 @@ struct SpellClassOptionsEntry
 {
     uint32 ID;
     int32 SpellID;
-    flag128 SpellClassMask;
-    uint8 SpellClassSet;
     uint32 ModalNextSpell;
+    uint8 SpellClassSet;
+    flag128 SpellClassMask;
 };
 
 struct SpellCooldownsEntry
 {
     uint32 ID;
+    uint8 DifficultyID;
     int32 CategoryRecoveryTime;
     int32 RecoveryTime;
     int32 StartRecoveryTime;
-    uint8 DifficultyID;
     int32 SpellID;
 };
 
@@ -2518,41 +2587,40 @@ struct SpellDurationEntry
 {
     uint32 ID;
     int32 Duration;
-    int32 MaxDuration;
     uint32 DurationPerLevel;
+    int32 MaxDuration;
 };
 
 struct SpellEffectEntry
 {
     uint32 ID;
-    uint32 Effect;
-    int32 EffectBasePoints;
-    int32 EffectIndex;
-    int32 EffectAura;
     int32 DifficultyID;
+    int32 EffectIndex;
+    uint32 Effect;
     float EffectAmplitude;
+    int32 EffectAttributes;
+    int16 EffectAura;
     int32 EffectAuraPeriod;
     float EffectBonusCoefficient;
     float EffectChainAmplitude;
     int32 EffectChainTargets;
-    int32 EffectDieSides;
     int32 EffectItemType;
     int32 EffectMechanic;
     float EffectPointsPerResource;
+    float EffectPosFacing;
     float EffectRealPointsPerLevel;
     int32 EffectTriggerSpell;
-    float EffectPosFacing;
-    int32 EffectAttributes;
     float BonusCoefficientFromAP;
     float PvpMultiplier;
     float Coefficient;
     float Variance;
     float ResourceCoefficient;
     float GroupSizeBasePointsCoefficient;
-    flag128 EffectSpellClassMask;
+    float EffectBasePoints;
     int32 EffectMiscValue[2];
     uint32 EffectRadiusIndex[2];
-    uint32 ImplicitTarget[2];
+    flag128 EffectSpellClassMask;
+    int16 ImplicitTarget[2];
     int32 SpellID;
 };
 
@@ -2560,9 +2628,9 @@ struct SpellEquippedItemsEntry
 {
     uint32 ID;
     int32 SpellID;
+    int8 EquippedItemClass;
     int32 EquippedItemInvTypes;
     int32 EquippedItemSubclass;
-    int8 EquippedItemClass;
 };
 
 struct SpellFocusObjectEntry
@@ -2587,10 +2655,12 @@ struct SpellItemEnchantmentEntry
 {
     uint32 ID;
     LocalizedString* Name;
+    LocalizedString* HordeName;
     uint32 EffectArg[MAX_ITEM_ENCHANTMENT_EFFECTS];
     float EffectScalingPoints[MAX_ITEM_ENCHANTMENT_EFFECTS];
     uint32 TransmogCost;
     uint32 IconFileDataID;
+    uint32 TransmogPlayerConditionID;
     int16 EffectPointsMin[MAX_ITEM_ENCHANTMENT_EFFECTS];
     uint16 ItemVisual;
     uint16 Flags;
@@ -2599,19 +2669,18 @@ struct SpellItemEnchantmentEntry
     uint16 ItemLevel;
     uint8 Charges;
     uint8 Effect[MAX_ITEM_ENCHANTMENT_EFFECTS];
+    int8 ScalingClass;
+    int8 ScalingClassRestricted;
     uint8 ConditionID;
     uint8 MinLevel;
     uint8 MaxLevel;
-    int8 ScalingClass;
-    int8 ScalingClassRestricted;
-    uint32 TransmogPlayerConditionID;
 };
 
 struct SpellItemEnchantmentConditionEntry
 {
     uint32 ID;
-    uint32 LtOperand[5];
     uint8 LtOperandType[5];
+    uint32 LtOperand[5];
     uint8 Operator[5];
     uint8 RtOperandType[5];
     uint8 RtOperand[5];
@@ -2629,10 +2698,10 @@ struct SpellLearnSpellEntry
 struct SpellLevelsEntry
 {
     uint32 ID;
+    uint8 DifficultyID;
     int16 BaseLevel;
     int16 MaxLevel;
     int16 SpellLevel;
-    uint8 DifficultyID;
     uint8 MaxPassiveAuraLevel;
     int32 SpellID;
 };
@@ -2640,43 +2709,50 @@ struct SpellLevelsEntry
 struct SpellMiscEntry
 {
     uint32 ID;
+    uint8 DifficultyID;
     uint16 CastingTimeIndex;
     uint16 DurationIndex;
     uint16 RangeIndex;
     uint8 SchoolMask;
-    int32 SpellIconFileDataID;
     float Speed;
-    int32 ActiveIconFileDataID;
     float LaunchDelay;
-    uint8 DifficultyID;
+    float MinDuration;
+    int32 SpellIconFileDataID;
+    int32 ActiveIconFileDataID;
     int32 Attributes[14];
     int32 SpellID;
 };
 
+struct SpellNameEntry
+{
+    uint32 ID;                      // SpellID
+    LocalizedString* Name;
+};
+
 struct SpellPowerEntry
 {
-    int32 ManaCost;
-    float PowerCostPct;
-    float PowerPctPerSecond;
-    int32 RequiredAuraSpellID;
-    float PowerCostMaxPct;
-    uint8 OrderIndex;
-    int8 PowerType;
     uint32 ID;
+    uint8 OrderIndex;
+    int32 ManaCost;
     int32 ManaCostPerLevel;
     int32 ManaPerSecond;
-    uint32 OptionalCost;                                            // Spell uses [ManaCost, ManaCost+ManaCostAdditional] power - affects tooltip parsing as multiplier on SpellEffectEntry::EffectPointsPerResource
-                                                                    //   only SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL, SPELL_EFFECT_WEAPON_PERCENT_DAMAGE, SPELL_EFFECT_WEAPON_DAMAGE, SPELL_EFFECT_NORMALIZED_WEAPON_DMG
     uint32 PowerDisplayID;
     int32 AltPowerBarID;
+    float PowerCostPct;
+    float PowerCostMaxPct;
+    float PowerPctPerSecond;
+    int8 PowerType;
+    int32 RequiredAuraSpellID;
+    uint32 OptionalCost;                                            // Spell uses [ManaCost, ManaCost+ManaCostAdditional] power - affects tooltip parsing as multiplier on SpellEffectEntry::EffectPointsPerResource
+                                                                   //   only SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL, SPELL_EFFECT_WEAPON_PERCENT_DAMAGE, SPELL_EFFECT_WEAPON_DAMAGE, SPELL_EFFECT_NORMALIZED_WEAPON_DMG
     int32 SpellID;
 };
 
 struct SpellPowerDifficultyEntry
 {
+    uint32 ID;
     uint8 DifficultyID;
     uint8 OrderIndex;
-    uint32 ID;
 };
 
 struct SpellProcsPerMinuteEntry
@@ -2689,9 +2765,9 @@ struct SpellProcsPerMinuteEntry
 struct SpellProcsPerMinuteModEntry
 {
     uint32 ID;
-    float Coeff;
-    int16 Param;
     uint8 Type;
+    int16 Param;
+    float Coeff;
     uint16 SpellProcsPerMinuteID;
 };
 
@@ -2709,9 +2785,9 @@ struct SpellRangeEntry
     uint32 ID;
     LocalizedString* DisplayName;
     LocalizedString* DisplayNameShort;
+    uint8 Flags;
     float RangeMin[2];
     float RangeMax[2];
-    uint8 Flags;
 };
 
 #define MAX_SPELL_REAGENTS 8
@@ -2728,19 +2804,19 @@ struct SpellScalingEntry
 {
     uint32 ID;
     int32 SpellID;
-    int16 ScalesFromItemLevel;
     int32 Class;
     uint32 MinScalingLevel;
     uint32 MaxScalingLevel;
+    int16 ScalesFromItemLevel;
 };
 
 struct SpellShapeshiftEntry
 {
     uint32 ID;
     int32 SpellID;
+    int8 StanceBarOrder;
     int32 ShapeshiftExclude[2];
     int32 ShapeshiftMask[2];
-    int8 StanceBarOrder;
 };
 
 #define MAX_SHAPESHIFT_SPELLS 8
@@ -2749,13 +2825,13 @@ struct SpellShapeshiftFormEntry
 {
     uint32 ID;
     LocalizedString* Name;
-    float DamageVariance;
+    int8 CreatureType;
     int32 Flags;
+    int32 AttackIconFileID;
+    int8 BonusActionBar;
     int16 CombatRoundTime;
+    float DamageVariance;
     uint16 MountTypeID;
-    int8 CreatureType;
-    int8 BonusActionBar;
-    int32 AttackIconFileID;
     uint32 CreatureDisplayID[4];
     uint32 PresetSpellID[MAX_SHAPESHIFT_SPELLS];
 };
@@ -2763,13 +2839,13 @@ struct SpellShapeshiftFormEntry
 struct SpellTargetRestrictionsEntry
 {
     uint32 ID;
-    float ConeDegrees;
-    float Width;
-    int32 Targets;
-    int16 TargetCreatureType;
     uint8 DifficultyID;
+    float ConeDegrees;
     uint8 MaxTargets;
     uint32 MaxTargetLevel;
+    int16 TargetCreatureType;
+    int32 Targets;
+    float Width;
     int32 SpellID;
 };
 
@@ -2779,35 +2855,35 @@ struct SpellTotemsEntry
 {
     uint32 ID;
     int32 SpellID;
-    int32 Totem[MAX_SPELL_TOTEMS];
     uint16 RequiredTotemCategoryID[MAX_SPELL_TOTEMS];
+    int32 Totem[MAX_SPELL_TOTEMS];
 };
 
 struct SpellXSpellVisualEntry
 {
-    uint32 SpellVisualID;
     uint32 ID;
+    uint8 DifficultyID;
+    uint32 SpellVisualID;
     float Probability;
-    uint16 CasterPlayerConditionID;
-    uint16 CasterUnitConditionID;
-    uint16 ViewerPlayerConditionID;
-    uint16 ViewerUnitConditionID;
-    int32 SpellIconFileID;
-    int32 ActiveIconFileID;
     uint8 Flags;
-    uint8 DifficultyID;
     uint8 Priority;
+    int32 SpellIconFileID;
+    int32 ActiveIconFileID;
+    uint16 ViewerUnitConditionID;
+    uint32 ViewerPlayerConditionID;
+    uint16 CasterUnitConditionID;
+    uint32 CasterPlayerConditionID;
     int32 SpellID;
 };
 
 struct SummonPropertiesEntry
 {
     uint32 ID;
-    int32 Flags;
     int32 Control;
     int32 Faction;
     int32 Title;
     int32 Slot;
+    int32 Flags;
 };
 
 #define TACTKEY_SIZE 16
@@ -2822,48 +2898,49 @@ struct TalentEntry
 {
     uint32 ID;
     LocalizedString* Description;
-    uint32 SpellID;
-    uint32 OverridesSpellID;
-    uint16 SpecID;
     uint8 TierID;
-    uint8 ColumnIndex;
     uint8 Flags;
-    uint8 CategoryMask[2];
+    uint8 ColumnIndex;
     uint8 ClassID;
+    uint16 SpecID;
+    uint32 SpellID;
+    uint32 OverridesSpellID;
+    uint8 CategoryMask[2];
 };
 
 struct TaxiNodesEntry
 {
-    uint32 ID;
     LocalizedString* Name;
     DBCPosition3D Pos;
-    int32 MountCreatureID[2];
     DBCPosition2D MapOffset;
-    float Facing;
     DBCPosition2D FlightMapOffset;
+    uint32 ID;
     uint16 ContinentID;
     uint16 ConditionID;
     uint16 CharacterBitNumber;
     uint8 Flags;
     int32 UiTextureKitID;
+    float Facing;
     uint32 SpecialIconConditionID;
+    uint32 VisibilityConditionID;
+    int32 MountCreatureID[2];
 };
 
 struct TaxiPathEntry
 {
+    uint32 ID;
     uint16 FromTaxiNode;
     uint16 ToTaxiNode;
-    uint32 ID;
     uint32 Cost;
 };
 
 struct TaxiPathNodeEntry
 {
     DBCPosition3D Loc;
+    uint32 ID;
     uint16 PathID;
+    int32 NodeIndex;
     uint16 ContinentID;
-    uint8 NodeIndex;
-    uint32 ID;
     uint8 Flags;
     uint32 Delay;
     uint16 ArrivalEventID;
@@ -2874,17 +2951,17 @@ struct TotemCategoryEntry
 {
     uint32 ID;
     LocalizedString* Name;
-    int32 TotemCategoryMask;
     uint8 TotemCategoryType;
+    int32 TotemCategoryMask;
 };
 
 struct ToyEntry
 {
     LocalizedString* SourceText;
+    uint32 ID;
     int32 ItemID;
     uint8 Flags;
     int8 SourceTypeEnum;
-    uint32 ID;
 };
 
 struct TransmogHolidayEntry
@@ -2896,15 +2973,15 @@ struct TransmogHolidayEntry
 struct TransmogSetEntry
 {
     LocalizedString* Name;
-    uint16 ParentTransmogSetID;
-    int16 UiOrder;
-    uint8 ExpansionID;
     uint32 ID;
-    int32 Flags;
-    uint32 TrackingQuestID;
     int32 ClassMask;
-    int32 ItemNameDescriptionID;
+    uint32 TrackingQuestID;
+    int32 Flags;
     uint32 TransmogSetGroupID;
+    int32 ItemNameDescriptionID;
+    uint16 ParentTransmogSetID;
+    uint8 ExpansionID;
+    int16 UiOrder;
 };
 
 struct TransmogSetGroupEntry
@@ -2924,20 +3001,69 @@ struct TransmogSetItemEntry
 struct TransportAnimationEntry
 {
     uint32 ID;
-    uint32 TimeIndex;
     DBCPosition3D Pos;
     uint8 SequenceID;
+    uint32 TimeIndex;
     int32 TransportID;
 };
 
 struct TransportRotationEntry
 {
     uint32 ID;
-    uint32 TimeIndex;
     float Rot[4];
+    uint32 TimeIndex;
     int32 GameObjectsID;
 };
 
+struct UiMapEntry
+{
+    LocalizedString* Name;
+    uint32 ID;
+    int32 ParentUiMapID;
+    int32 Flags;
+    int32 System;
+    int32 Type;
+    uint32 LevelRangeMin;
+    uint32 LevelRangeMax;
+    int32 BountySetID;
+    uint32 BountyDisplayLocation;
+    int32 VisibilityPlayerConditionID;
+    int8 HelpTextPosition;
+    int32 BkgAtlasID;
+};
+
+struct UiMapAssignmentEntry
+{
+    DBCPosition2D UiMin;
+    DBCPosition2D UiMax;
+    DBCPosition3D Region[2];
+    uint32 ID;
+    int32 UiMapID;
+    int32 OrderIndex;
+    int32 MapID;
+    int32 AreaID;
+    int32 WmoDoodadPlacementID;
+    int32 WmoGroupID;
+};
+
+struct UiMapLinkEntry
+{
+    DBCPosition2D UiMin;
+    DBCPosition2D UiMax;
+    uint32 ID;
+    int32 ParentUiMapID;
+    int32 OrderIndex;
+    int32 ChildUiMapID;
+};
+
+struct UiMapXMapArtEntry
+{
+    uint32 ID;
+    int32 PhaseID;
+    int32 UiMapArtID;
+    int32 UiMapID;
+};
+
 struct UnitPowerBarEntry
 {
     uint32 ID;
@@ -2945,18 +3071,18 @@ struct UnitPowerBarEntry
     LocalizedString* Cost;
     LocalizedString* OutOfError;
     LocalizedString* ToolTip;
+    uint32 MinPower;
+    uint32 MaxPower;
+    uint16 StartPower;
+    uint8 CenterPower;
     float RegenerationPeace;
     float RegenerationCombat;
-    int32 FileDataID[6];
-    int32 Color[6];
+    uint8 BarType;
+    uint16 Flags;
     float StartInset;
     float EndInset;
-    uint16 StartPower;
-    uint16 Flags;
-    uint8 CenterPower;
-    uint8 BarType;
-    uint32 MinPower;
-    uint32 MaxPower;
+    int32 FileDataID[6];
+    int32 Color[6];
 };
 
 #define MAX_VEHICLE_SEATS 8
@@ -2965,6 +3091,7 @@ struct VehicleEntry
 {
     uint32 ID;
     int32 Flags;
+    uint8 FlagsB;
     float TurnSpeed;
     float PitchSpeed;
     float PitchMin;
@@ -2976,21 +3103,22 @@ struct VehicleEntry
     float FacingLimitRight;
     float FacingLimitLeft;
     float CameraYawOffset;
-    uint16 SeatID[MAX_VEHICLE_SEATS];
-    uint16 VehicleUIIndicatorID;
-    uint16 PowerDisplayID[3];
-    uint8 FlagsB;
     uint8 UiLocomotionType;
+    uint16 VehicleUIIndicatorID;
     int32 MissileTargetingID;
+    uint16 SeatID[8];
+    uint16 PowerDisplayID[3];
 };
 
 struct VehicleSeatEntry
 {
     uint32 ID;
+    DBCPosition3D AttachmentOffset;
+    DBCPosition3D CameraOffset;
     int32 Flags;
     int32 FlagsB;
     int32 FlagsC;
-    DBCPosition3D AttachmentOffset;
+    int8 AttachmentID;
     float EnterPreDelay;
     float EnterSpeed;
     float EnterGravity;
@@ -2998,6 +3126,12 @@ struct VehicleSeatEntry
     float EnterMaxDuration;
     float EnterMinArcHeight;
     float EnterMaxArcHeight;
+    int32 EnterAnimStart;
+    int32 EnterAnimLoop;
+    int32 RideAnimStart;
+    int32 RideAnimLoop;
+    int32 RideUpperAnimStart;
+    int32 RideUpperAnimLoop;
     float ExitPreDelay;
     float ExitSpeed;
     float ExitGravity;
@@ -3005,34 +3139,34 @@ struct VehicleSeatEntry
     float ExitMaxDuration;
     float ExitMinArcHeight;
     float ExitMaxArcHeight;
+    int32 ExitAnimStart;
+    int32 ExitAnimLoop;
+    int32 ExitAnimEnd;
+    int16 VehicleEnterAnim;
+    int8 VehicleEnterAnimBone;
+    int16 VehicleExitAnim;
+    int8 VehicleExitAnimBone;
+    int16 VehicleRideAnimLoop;
+    int8 VehicleRideAnimLoopBone;
+    int8 PassengerAttachmentID;
     float PassengerYaw;
     float PassengerPitch;
     float PassengerRoll;
     float VehicleEnterAnimDelay;
     float VehicleExitAnimDelay;
+    int8 VehicleAbilityDisplay;
+    uint32 EnterUISoundID;
+    uint32 ExitUISoundID;
+    int32 UiSkinFileDataID;
     float CameraEnteringDelay;
     float CameraEnteringDuration;
     float CameraExitingDelay;
     float CameraExitingDuration;
-    DBCPosition3D CameraOffset;
     float CameraPosChaseRate;
     float CameraFacingChaseRate;
     float CameraEnteringZoom;
     float CameraSeatZoomMin;
     float CameraSeatZoomMax;
-    int32 UiSkinFileDataID;
-    int16 EnterAnimStart;
-    int16 EnterAnimLoop;
-    int16 RideAnimStart;
-    int16 RideAnimLoop;
-    int16 RideUpperAnimStart;
-    int16 RideUpperAnimLoop;
-    int16 ExitAnimStart;
-    int16 ExitAnimLoop;
-    int16 ExitAnimEnd;
-    int16 VehicleEnterAnim;
-    int16 VehicleExitAnim;
-    int16 VehicleRideAnimLoop;
     int16 EnterAnimKitID;
     int16 RideAnimKitID;
     int16 ExitAnimKitID;
@@ -3040,14 +3174,6 @@ struct VehicleSeatEntry
     int16 VehicleRideAnimKitID;
     int16 VehicleExitAnimKitID;
     int16 CameraModeID;
-    int8 AttachmentID;
-    int8 PassengerAttachmentID;
-    int8 VehicleEnterAnimBone;
-    int8 VehicleExitAnimBone;
-    int8 VehicleRideAnimLoopBone;
-    int8 VehicleAbilityDisplay;
-    uint32 EnterUISoundID;
-    uint32 ExitUISoundID;
 
     bool CanEnterOrExit() const
     {
@@ -3068,97 +3194,59 @@ struct VehicleSeatEntry
 struct WMOAreaTableEntry
 {
     LocalizedString* AreaName;
+    uint32 ID;
+    uint16 WmoID;                                                   //  used in root WMO
+    uint8 NameSetID;                                                //  used in adt file
     int32 WmoGroupID;                                               //  used in group WMO
+    uint8 SoundProviderPref;
+    uint8 SoundProviderPrefUnderwater;
     uint16 AmbienceID;
+    uint16 UwAmbience;
     uint16 ZoneMusic;
+    uint32 UwZoneMusic;
     uint16 IntroSound;
-    uint16 AreaTableID;
     uint16 UwIntroSound;
-    uint16 UwAmbience;
-    uint8 NameSetID;                                                //  used in adt file
-    uint8 SoundProviderPref;
-    uint8 SoundProviderPrefUnderwater;
+    uint16 AreaTableID;
     uint8 Flags;
-    uint32 ID;
-    uint32 UwZoneMusic;
-    uint16 WmoID;                                                   //  used in root WMO
 };
 
 struct WorldEffectEntry
 {
     uint32 ID;
-    int32 TargetAsset;
-    uint16 CombatConditionID;
-    uint8 TargetType;
-    uint8 WhenToDisplay;
     uint32 QuestFeedbackEffectID;
+    uint8 WhenToDisplay;
+    uint8 TargetType;
+    int32 TargetAsset;
     uint32 PlayerConditionID;
-};
-
-struct WorldMapAreaEntry
-{
-    char const* AreaName;
-    float LocLeft;
-    float LocRight;
-    float LocTop;
-    float LocBottom;
-    uint32 Flags;
-    int16 MapID;
-    uint16 AreaID;
-    int16 DisplayMapID;
-    uint16 DefaultDungeonFloor;
-    uint16 ParentWorldMapID;
-    uint8 LevelRangeMin;
-    uint8 LevelRangeMax;
-    uint8 BountySetID;
-    uint8 BountyDisplayLocation;
-    uint32 ID;
-    uint32 VisibilityPlayerConditionID;
+    uint16 CombatConditionID;
 };
 
 #define MAX_WORLD_MAP_OVERLAY_AREA_IDX 4
 
 struct WorldMapOverlayEntry
 {
-    char const* TextureName;
     uint32 ID;
+    uint32 UiMapArtID;
     uint16 TextureWidth;
     uint16 TextureHeight;
-    uint32 MapAreaID;                                               // idx in WorldMapArea.dbc
     int32 OffsetX;
     int32 OffsetY;
     int32 HitRectTop;
-    int32 HitRectLeft;
     int32 HitRectBottom;
+    int32 HitRectLeft;
     int32 HitRectRight;
     uint32 PlayerConditionID;
     uint32 Flags;
     uint32 AreaID[MAX_WORLD_MAP_OVERLAY_AREA_IDX];
 };
 
-struct WorldMapTransformsEntry
-{
-    uint32 ID;
-    DBCPosition3D RegionMin;
-    DBCPosition3D RegionMax;
-    DBCPosition2D RegionOffset;
-    float RegionScale;
-    uint16 MapID;
-    uint16 AreaID;
-    uint16 NewMapID;
-    uint16 NewDungeonMapID;
-    uint16 NewAreaID;
-    uint8 Flags;
-    int32 Priority;
-};
-
 struct WorldSafeLocsEntry
 {
     uint32 ID;
     LocalizedString* AreaName;
     DBCPosition3D Loc;
-    float Facing;
     uint16 MapID;
+    float Facing;
 };
 
 #pragma pack(pop)
diff --git a/src/server/game/DataStores/DBCEnums.h b/src/server/game/DataStores/DBCEnums.h
index 6b269dbe406..2655e0e0a12 100644
--- a/src/server/game/DataStores/DBCEnums.h
+++ b/src/server/game/DataStores/DBCEnums.h
@@ -44,11 +44,11 @@ enum LevelLimit
     // Client expected level limitation, like as used in DBC item max levels for "until max player level"
     // use as default max player level, must be fit max level for used client
     // also see MAX_LEVEL and STRONG_MAX_LEVEL define
-    DEFAULT_MAX_LEVEL = 110,
+    DEFAULT_MAX_LEVEL = 120,
 
     // client supported max level for player/pets/etc. Avoid overflow or client stability affected.
     // also see GT_MAX_LEVEL define
-    MAX_LEVEL = 110,
+    MAX_LEVEL = 120,
 
     // Server side limitation. Base at used code requirements.
     // also see MAX_LEVEL and GT_MAX_LEVEL define
@@ -58,7 +58,7 @@ enum LevelLimit
 enum BattlegroundBracketId                                  // bracketId for level ranges
 {
     BG_BRACKET_ID_FIRST          = 0,
-    BG_BRACKET_ID_LAST           = 11,
+    BG_BRACKET_ID_LAST           = 12,
 
     // must be max value in PvPDificulty slot + 1
     MAX_BATTLEGROUND_BRACKETS
@@ -166,7 +166,7 @@ enum ArtifactPowerFlag : uint8
 
 #define MAX_ARTIFACT_TIER 1
 
-#define BATTLE_PET_SPECIES_MAX_ID 2164
+#define BATTLE_PET_SPECIES_MAX_ID 2480
 
 enum ChrSpecializationFlag
 {
@@ -502,10 +502,13 @@ enum CriteriaTypes : uint8
     CRITERIA_TYPE_TRANSMOG_SET_UNLOCKED                 = 205,
     CRITERIA_TYPE_GAIN_PARAGON_REPUTATION               = 206,
     CRITERIA_TYPE_EARN_HONOR_XP                         = 207,
-    CRITERIA_TYPE_RELIC_TALENT_UNLOCKED                 = 211
+    CRITERIA_TYPE_RELIC_TALENT_UNLOCKED                 = 211,
+    CRITERIA_TYPE_REACH_ACCOUNT_HONOR_LEVEL             = 213,
+    CRITERIA_TREE_HEART_OF_AZEROTH_ARTIFACT_POWER_EARNED= 214,
+    CRITERIA_TREE_HEART_OF_AZEROTH_LEVEL_REACHED        = 215
 };
 
-#define CRITERIA_TYPE_TOTAL 213
+#define CRITERIA_TYPE_TOTAL 216
 
 enum CriteriaTreeFlags : uint16
 {
@@ -608,6 +611,11 @@ enum Difficulty : uint8
     DIFFICULTY_WORLD_PVP_SCENARIO_2 = 32,
     DIFFICULTY_TIMEWALKING_RAID     = 33,
     DIFFICULTY_PVP                  = 34,
+    DIFFICULTY_NORMAL_ISLAND        = 38,
+    DIFFICULTY_HEROIC_ISLAND        = 39,
+    DIFFICULTY_MYTHIC_ISLAND        = 40,
+    DIFFICULTY_PVP_ISLAND           = 45,
+    DIFFICULTY_NORMAL_WARFRONT      = 147,
 
     MAX_DIFFICULTY
 };
@@ -643,6 +651,20 @@ enum SpawnMask
     SPAWNMASK_RAID_ALL          = (SPAWNMASK_RAID_NORMAL_ALL | SPAWNMASK_RAID_HEROIC_ALL)
 };
 
+enum class ExpectedStatType : uint8
+{
+    CreatureHealth          = 0,
+    PlayerHealth            = 1,
+    CreatureAutoAttackDps   = 2,
+    CreatureArmor           = 3,
+    PlayerMana              = 4,
+    PlayerPrimaryStat       = 5,
+    PlayerSecondaryStat     = 6,
+    ArmorConstant           = 7,
+    None                    = 8,
+    CreatureSpellDamage     = 9
+};
+
 enum FactionTemplateFlags
 {
     FACTION_TEMPLATE_ENEMY_SPAR             = 0x00000020,   // guessed, sparring with enemies?
@@ -745,6 +767,68 @@ enum ItemBonusType
     ITEM_BONUS_OVERRIDE_REQUIRED_LEVEL          = 18
 };
 
+enum class ItemContext : uint8
+{
+    NONE                    = 0,
+    Dungeon_Normal          = 1,
+    Dungeon_Heroic          = 2,
+    Raid_Normal             = 3,
+    Raid_Raid_Finder        = 4,
+    Raid_Heroic             = 5,
+    Raid_Mythic             = 6,
+    PVP_Unranked_1          = 7,
+    PVP_Ranked_1            = 8,
+    Scenario_Normal         = 9,
+    Scenario_Heroic         = 10,
+    Quest_Reward            = 11,
+    Store                   = 12,
+    Trade_Skill             = 13,
+    Vendor                  = 14,
+    Black_Market            = 15,
+    Challenge_Mode_1        = 16,
+    Dungeon_Lvl_Up_1        = 17,
+    Dungeon_Lvl_Up_2        = 18,
+    Dungeon_Lvl_Up_3        = 19,
+    Dungeon_Lvl_Up_4        = 20,
+    Force_to_NONE           = 21,
+    TimeWalker              = 22,
+    Dungeon_Mythic          = 23,
+    Pvp_Honor_Reward        = 24,
+    World_Quest_1           = 25,
+    World_Quest_2           = 26,
+    World_Quest_3           = 27,
+    World_Quest_4           = 28,
+    World_Quest_5           = 29,
+    World_Quest_6           = 30,
+    Mission_Reward_1        = 31,
+    Mission_Reward_2        = 32,
+    Challenge_Mode_2        = 33,
+    Challenge_Mode_3        = 34,
+    Challenge_Mode_Jackpot  = 35,
+    World_Quest_7           = 36,
+    World_Quest_8           = 37,
+    PVP_Ranked_2            = 38,
+    PVP_Ranked_3            = 39,
+    PVP_Ranked_4            = 40,
+    PVP_Unranked_2          = 41,
+    World_Quest_9           = 42,
+    World_Quest_10          = 43,
+    PVP_Ranked_5            = 44,
+    PVP_Ranked_6            = 45,
+    PVP_Ranked_7            = 46,
+    PVP_Unranked_3          = 47,
+    PVP_Unranked_4          = 48,
+    PVP_Unranked_5          = 49,
+    PVP_Unranked_6          = 50,
+    PVP_Unranked_7          = 51,
+    PVP_Ranked_8            = 52,
+    World_Quest_11          = 53,
+    World_Quest_12          = 54,
+    World_Quest_13          = 55,
+    PVP_Ranked_Jackpot      = 56,
+    Tournament_Realm        = 57,
+};
+
 enum ItemLimitCategoryMode
 {
     ITEM_LIMIT_CATEGORY_MODE_HAVE       = 0,                      // limit applied to amount items in inventory/bank
@@ -917,7 +1001,7 @@ enum SpellShapeshiftFormFlags
     SHAPESHIFT_FORM_PREVENT_EMOTE_SOUNDS        = 0x1000
 };
 
-#define TaxiMaskSize 258
+#define TaxiMaskSize 286
 typedef std::array<uint8, TaxiMaskSize> TaxiMask;
 
 enum TotemCategoryType
@@ -989,8 +1073,7 @@ enum SummonPropFlags
 
 #define MAX_TALENT_TIERS 7
 #define MAX_TALENT_COLUMNS 3
-#define MAX_PVP_TALENT_TIERS 6
-#define MAX_PVP_TALENT_COLUMNS 3
+#define MAX_PVP_TALENT_SLOTS 4
 
 enum TaxiNodeFlags
 {
@@ -1005,6 +1088,25 @@ enum TaxiPathNodeFlags
     TAXI_PATH_NODE_FLAG_STOP        = 0x2
 };
 
+enum UiMapSystem : int8
+{
+    UI_MAP_SYSTEM_WORLD     = 0,
+    UI_MAP_SYSTEM_TAXI      = 1,
+    UI_MAP_SYSTEM_ADVENTURE = 2,
+    MAX_UI_MAP_SYSTEM       = 3
+};
+
+enum UiMapType : int8
+{
+    UI_MAP_TYPE_COSMIC      = 0,
+    UI_MAP_TYPE_WORLD       = 1,
+    UI_MAP_TYPE_CONTINENT   = 2,
+    UI_MAP_TYPE_ZONE        = 3,
+    UI_MAP_TYPE_DUNGEON     = 4,
+    UI_MAP_TYPE_MICRO       = 5,
+    UI_MAP_TYPE_ORPHAN      = 6,
+};
+
 enum VehicleSeatFlags
 {
     VEHICLE_SEAT_FLAG_HAS_LOWER_ANIM_FOR_ENTER                         = 0x00000001,
diff --git a/src/server/game/DataStores/GameTables.cpp b/src/server/game/DataStores/GameTables.cpp
index 0dd01aa3930..c4232087a7c 100644
--- a/src/server/game/DataStores/GameTables.cpp
+++ b/src/server/game/DataStores/GameTables.cpp
@@ -29,7 +29,6 @@ GameTable<GtBarberShopCostBaseEntry>            sBarberShopCostBaseGameTable;
 GameTable<GtBaseMPEntry>                        sBaseMPGameTable;
 GameTable<GtCombatRatingsEntry>                 sCombatRatingsGameTable;
 GameTable<GtCombatRatingsMultByILvl>            sCombatRatingsMultByILvlGameTable;
-GameTable<GtHonorLevelEntry>                    sHonorLevelGameTable;
 GameTable<GtHpPerStaEntry>                      sHpPerStaGameTable;
 GameTable<GtItemSocketCostPerLevelEntry>        sItemSocketCostPerLevelGameTable;
 GameTable<GtNpcDamageByClassEntry>              sNpcDamageByClassGameTable[MAX_EXPANSIONS];
@@ -118,7 +117,6 @@ void LoadGameTables(std::string const& dataPath)
     LOAD_GT(sCombatRatingsGameTable, "CombatRatings.txt");
     LOAD_GT(sCombatRatingsMultByILvlGameTable, "CombatRatingsMultByILvl.txt");
     LOAD_GT(sItemSocketCostPerLevelGameTable, "ItemSocketCostPerLevel.txt");
-    LOAD_GT(sHonorLevelGameTable, "HonorLevel.txt");
     LOAD_GT(sHpPerStaGameTable, "HpPerSta.txt");
     LOAD_GT(sNpcDamageByClassGameTable[0], "NpcDamageByClass.txt");
     LOAD_GT(sNpcDamageByClassGameTable[1], "NpcDamageByClassExp1.txt");
@@ -127,6 +125,7 @@ void LoadGameTables(std::string const& dataPath)
     LOAD_GT(sNpcDamageByClassGameTable[4], "NpcDamageByClassExp4.txt");
     LOAD_GT(sNpcDamageByClassGameTable[5], "NpcDamageByClassExp5.txt");
     LOAD_GT(sNpcDamageByClassGameTable[6], "NpcDamageByClassExp6.txt");
+    LOAD_GT(sNpcDamageByClassGameTable[7], "NpcDamageByClassExp7.txt");
     LOAD_GT(sNpcManaCostScalerGameTable, "NPCManaCostScaler.txt");
     LOAD_GT(sNpcTotalHpGameTable[0], "NpcTotalHp.txt");
     LOAD_GT(sNpcTotalHpGameTable[1], "NpcTotalHpExp1.txt");
@@ -135,6 +134,7 @@ void LoadGameTables(std::string const& dataPath)
     LOAD_GT(sNpcTotalHpGameTable[4], "NpcTotalHpExp4.txt");
     LOAD_GT(sNpcTotalHpGameTable[5], "NpcTotalHpExp5.txt");
     LOAD_GT(sNpcTotalHpGameTable[6], "NpcTotalHpExp6.txt");
+    LOAD_GT(sNpcTotalHpGameTable[7], "NpcTotalHpExp7.txt");
     LOAD_GT(sSpellScalingGameTable, "SpellScaling.txt");
     LOAD_GT(sXpGameTable, "xp.txt");
 
diff --git a/src/server/game/DataStores/GameTables.h b/src/server/game/DataStores/GameTables.h
index d265f2657a9..28365a7ff1c 100644
--- a/src/server/game/DataStores/GameTables.h
+++ b/src/server/game/DataStores/GameTables.h
@@ -103,12 +103,6 @@ struct GtCombatRatingsMultByILvl
     float JewelryMultiplier = 0.0f;
 };
 
-uint8 constexpr PRESTIGE_COLUMN_COUNT = 33;
-struct GtHonorLevelEntry
-{
-    float Prestige[PRESTIGE_COLUMN_COUNT] = { };
-};
-
 struct GtHpPerStaEntry
 {
     float Health = 0.0f;
@@ -176,6 +170,7 @@ struct GtSpellScalingEntry
     float Gem2 = 0.0f;
     float Gem3 = 0.0f;
     float Health = 0.0f;
+    float DamageReplaceStat = 0.0f;
 };
 
 struct GtXpEntry
@@ -214,7 +209,6 @@ TC_GAME_API extern GameTable<GtBarberShopCostBaseEntry>             sBarberShopC
 TC_GAME_API extern GameTable<GtBaseMPEntry>                         sBaseMPGameTable;
 TC_GAME_API extern GameTable<GtCombatRatingsEntry>                  sCombatRatingsGameTable;
 TC_GAME_API extern GameTable<GtCombatRatingsMultByILvl>             sCombatRatingsMultByILvlGameTable;
-TC_GAME_API extern GameTable<GtHonorLevelEntry>                     sHonorLevelGameTable;
 TC_GAME_API extern GameTable<GtHpPerStaEntry>                       sHpPerStaGameTable;
 TC_GAME_API extern GameTable<GtItemSocketCostPerLevelEntry>         sItemSocketCostPerLevelGameTable;
 TC_GAME_API extern GameTable<GtNpcDamageByClassEntry>               sNpcDamageByClassGameTable[MAX_EXPANSIONS];
@@ -290,6 +284,7 @@ inline float GetSpellScalingColumnForClass(GtSpellScalingEntry const* row, int32
         case CLASS_DEMON_HUNTER:
             return row->DemonHunter;
         case -1:
+        case -7:
             return row->Item;
         case -2:
             return row->Consumable;
@@ -301,6 +296,8 @@ inline float GetSpellScalingColumnForClass(GtSpellScalingEntry const* row, int32
             return row->Gem3;
         case -6:
             return row->Health;
+        case -8:
+            return row->DamageReplaceStat;
         default:
             break;
     }
diff --git a/src/server/game/DungeonFinding/LFGMgr.cpp b/src/server/game/DungeonFinding/LFGMgr.cpp
index 48ea6f04f0c..3ac3cc1f9f5 100644
--- a/src/server/game/DungeonFinding/LFGMgr.cpp
+++ b/src/server/game/DungeonFinding/LFGMgr.cpp
@@ -51,7 +51,7 @@ requiredItemLevel(0)
 LFGDungeonData::LFGDungeonData(LFGDungeonsEntry const* dbc) : id(dbc->ID), name(dbc->Name->Str[sWorld->GetDefaultDbcLocale()]), map(dbc->MapID),
 type(uint8(dbc->TypeID)), expansion(uint8(dbc->ExpansionLevel)), group(uint8(dbc->GroupID)),
 minlevel(uint8(dbc->MinLevel)), maxlevel(uint8(dbc->MaxLevel)), difficulty(Difficulty(dbc->DifficultyID)),
-seasonal((dbc->Flags & LFG_FLAG_SEASONAL) != 0), x(0.0f), y(0.0f), z(0.0f), o(0.0f),
+seasonal((dbc->Flags[0] & LFG_FLAG_SEASONAL) != 0), x(0.0f), y(0.0f), z(0.0f), o(0.0f),
 requiredItemLevel(0)
 {
 }
diff --git a/src/server/game/Entities/AreaTrigger/AreaTrigger.cpp b/src/server/game/Entities/AreaTrigger/AreaTrigger.cpp
index b03bdab76ce..4e4e70e1b0a 100644
--- a/src/server/game/Entities/AreaTrigger/AreaTrigger.cpp
+++ b/src/server/game/Entities/AreaTrigger/AreaTrigger.cpp
@@ -46,7 +46,8 @@ AreaTrigger::AreaTrigger() : WorldObject(false), MapObject(), _aurEff(nullptr),
     m_objectType |= TYPEMASK_AREATRIGGER;
     m_objectTypeId = TYPEID_AREATRIGGER;
 
-    m_updateFlag = UPDATEFLAG_STATIONARY_POSITION | UPDATEFLAG_AREATRIGGER;
+    m_updateFlag.Stationary = true;
+    m_updateFlag.AreaTrigger = true;
 
     m_valuesCount = AREATRIGGER_END;
     _dynamicValuesCount = AREATRIGGER_DYNAMIC_END;
@@ -142,7 +143,7 @@ bool AreaTrigger::Create(uint32 spellMiscId, Unit* caster, Unit* target, SpellIn
     {
         AreaTriggerCircularMovementInfo cmi = GetMiscTemplate()->CircularMovementInfo;
         if (target && GetTemplate()->HasFlag(AREATRIGGER_FLAG_HAS_ATTACHED))
-            cmi.TargetGUID = target->GetGUID();
+            cmi.PathTarget = target->GetGUID();
         else
             cmi.Center = pos;
 
@@ -637,12 +638,12 @@ void AreaTrigger::InitSplines(std::vector<G3D::Vector3> splinePoints, uint32 tim
     {
         if (_reachedDestination)
         {
-            WorldPackets::AreaTrigger::AreaTriggerReShape reshape;
+            WorldPackets::AreaTrigger::AreaTriggerRePath reshape;
             reshape.TriggerGUID = GetGUID();
             SendMessageToSet(reshape.Write(), true);
         }
 
-        WorldPackets::AreaTrigger::AreaTriggerReShape reshape;
+        WorldPackets::AreaTrigger::AreaTriggerRePath reshape;
         reshape.TriggerGUID = GetGUID();
         reshape.AreaTriggerSpline = boost::in_place();
         reshape.AreaTriggerSpline->ElapsedTimeForMovement = GetElapsedTimeForMovement();
@@ -664,7 +665,7 @@ bool AreaTrigger::HasSplines() const
 void AreaTrigger::InitCircularMovement(AreaTriggerCircularMovementInfo const& cmi, uint32 timeToTarget)
 {
     // Circular movement requires either a center position or an attached unit
-    ASSERT(cmi.Center.is_initialized() || cmi.TargetGUID.is_initialized());
+    ASSERT(cmi.Center.is_initialized() || cmi.PathTarget.is_initialized());
 
     // should be sent in object create packets only
     m_uint32Values[AREATRIGGER_TIME_TO_TARGET] = timeToTarget;
@@ -676,7 +677,7 @@ void AreaTrigger::InitCircularMovement(AreaTriggerCircularMovementInfo const& cm
 
     if (IsInWorld())
     {
-        WorldPackets::AreaTrigger::AreaTriggerReShape reshape;
+        WorldPackets::AreaTrigger::AreaTriggerRePath reshape;
         reshape.TriggerGUID = GetGUID();
         reshape.AreaTriggerCircularMovement = _circularMovementInfo;
 
@@ -691,11 +692,11 @@ bool AreaTrigger::HasCircularMovement() const
 
 Position const* AreaTrigger::GetCircularMovementCenterPosition() const
 {
-    if (_circularMovementInfo.is_initialized())
+    if (!_circularMovementInfo.is_initialized())
         return nullptr;
 
-    if (_circularMovementInfo->TargetGUID.is_initialized())
-        if (WorldObject* center = ObjectAccessor::GetWorldObject(*this, *_circularMovementInfo->TargetGUID))
+    if (_circularMovementInfo->PathTarget.is_initialized())
+        if (WorldObject* center = ObjectAccessor::GetWorldObject(*this, *_circularMovementInfo->PathTarget))
             return center;
 
     if (_circularMovementInfo->Center.is_initialized())
diff --git a/src/server/game/Entities/AreaTrigger/AreaTriggerTemplate.cpp b/src/server/game/Entities/AreaTrigger/AreaTriggerTemplate.cpp
index 633988b17b0..431c4cc7d57 100644
--- a/src/server/game/Entities/AreaTrigger/AreaTriggerTemplate.cpp
+++ b/src/server/game/Entities/AreaTrigger/AreaTriggerTemplate.cpp
@@ -96,6 +96,9 @@ AreaTriggerMiscTemplate::AreaTriggerMiscTemplate()
     MorphCurveId = 0;
     FacingCurveId = 0;
 
+    AnimId = 0;
+    AnimKitId = 0;
+
     DecalPropertiesId = 0;
 
     TimeToTarget = 0;
diff --git a/src/server/game/Entities/AreaTrigger/AreaTriggerTemplate.h b/src/server/game/Entities/AreaTrigger/AreaTriggerTemplate.h
index 35be0f40f7f..2371c65cf09 100644
--- a/src/server/game/Entities/AreaTrigger/AreaTriggerTemplate.h
+++ b/src/server/game/Entities/AreaTrigger/AreaTriggerTemplate.h
@@ -36,10 +36,11 @@ enum AreaTriggerFlags
     AREATRIGGER_FLAG_HAS_FOLLOWS_TERRAIN        = 0x00010, // NYI
     AREATRIGGER_FLAG_UNK1                       = 0x00020,
     AREATRIGGER_FLAG_HAS_TARGET_ROLL_PITCH_YAW  = 0x00040, // NYI
-    AREATRIGGER_FLAG_UNK2                       = 0x00080,
+    AREATRIGGER_FLAG_HAS_ANIM_ID                = 0x00080,
     AREATRIGGER_FLAG_UNK3                       = 0x00100,
-    AREATRIGGER_FLAG_UNK4                       = 0x00200,
-    AREATRIGGER_FLAG_HAS_CIRCULAR_MOVEMENT      = 0x00400
+    AREATRIGGER_FLAG_HAS_ANIM_KIT_ID            = 0x00200,
+    AREATRIGGER_FLAG_HAS_CIRCULAR_MOVEMENT      = 0x00400,
+    AREATRIGGER_FLAG_UNK5                       = 0x00800,
 };
 
 enum AreaTriggerTypes
@@ -96,7 +97,7 @@ struct AreaTriggerScaleInfo
 
 struct AreaTriggerCircularMovementInfo
 {
-    Optional<ObjectGuid> TargetGUID;
+    Optional<ObjectGuid> PathTarget;
     Optional<TaggedPosition<Position::XYZ>> Center;
     bool CounterClockwise = false;
     bool CanLoop = false;
@@ -190,6 +191,9 @@ public:
     uint32 MorphCurveId;
     uint32 FacingCurveId;
 
+    int32 AnimId;
+    int32 AnimKitId;
+
     uint32 DecalPropertiesId;
 
     uint32 TimeToTarget;
diff --git a/src/server/game/Entities/Conversation/Conversation.cpp b/src/server/game/Entities/Conversation/Conversation.cpp
index 13339f3169f..0445f8ff6bc 100644
--- a/src/server/game/Entities/Conversation/Conversation.cpp
+++ b/src/server/game/Entities/Conversation/Conversation.cpp
@@ -30,7 +30,8 @@ Conversation::Conversation() : WorldObject(false), _duration(0)
     m_objectType |= TYPEMASK_CONVERSATION;
     m_objectTypeId = TYPEID_CONVERSATION;
 
-    m_updateFlag = UPDATEFLAG_STATIONARY_POSITION;
+    m_updateFlag.Stationary = true;
+    m_updateFlag.Conversation = true;
 
     m_valuesCount = CONVERSATION_END;
     _dynamicValuesCount = CONVERSATION_DYNAMIC_END;
@@ -123,13 +124,15 @@ bool Conversation::Create(ObjectGuid::LowType lowGuid, uint32 conversationEntry,
 
     SetUInt32Value(CONVERSATION_LAST_LINE_END_TIME, conversationTemplate->LastLineEndTime);
     _duration = conversationTemplate->LastLineEndTime;
+    _textureKitId = conversationTemplate->TextureKitId;
 
     for (uint16 actorIndex = 0; actorIndex < conversationTemplate->Actors.size(); ++actorIndex)
     {
         if (ConversationActorTemplate const* actor = conversationTemplate->Actors[actorIndex])
         {
             ConversationDynamicFieldActor actorField;
-            actorField.ActorTemplate = *actor;
+            actorField.ActorTemplate.CreatureId = actor->CreatureId;
+            actorField.ActorTemplate.CreatureModelId = actor->CreatureModelId;
             actorField.Type = ConversationDynamicFieldActor::ActorType::CreatureActor;
             SetDynamicStructuredValue(CONVERSATION_DYNAMIC_FIELD_ACTORS, actorIndex, &actorField);
         }
diff --git a/src/server/game/Entities/Conversation/Conversation.h b/src/server/game/Entities/Conversation/Conversation.h
index 860264b1de8..ddc44ddfea9 100644
--- a/src/server/game/Entities/Conversation/Conversation.h
+++ b/src/server/game/Entities/Conversation/Conversation.h
@@ -47,8 +47,11 @@ struct ConversationDynamicFieldActor
     union
     {
         ObjectGuid ActorGuid;
-
-        ConversationActorTemplate ActorTemplate;
+        struct
+        {
+            uint32 CreatureId;
+            uint32 CreatureModelId;
+        } ActorTemplate;
 
         struct
         {
@@ -75,6 +78,7 @@ class TC_GAME_API Conversation : public WorldObject, public GridObject<Conversat
         void Update(uint32 diff) override;
         void Remove();
         int32 GetDuration() const { return _duration; }
+        uint32 GetTextureKitId() const { return _textureKitId; }
 
         static Conversation* CreateConversation(uint32 conversationEntry, Unit* creator, Position const& pos, GuidUnorderedSet&& participants, SpellInfo const* spellInfo = nullptr);
         bool Create(ObjectGuid::LowType lowGuid, uint32 conversationEntry, Map* map, Unit* creator, Position const& pos, GuidUnorderedSet&& participants, SpellInfo const* spellInfo = nullptr);
@@ -95,6 +99,7 @@ class TC_GAME_API Conversation : public WorldObject, public GridObject<Conversat
         Position _stationaryPosition;
         ObjectGuid _creatorGuid;
         uint32 _duration;
+        uint32 _textureKitId;
         GuidUnorderedSet _participants;
 };
 
diff --git a/src/server/game/Entities/Corpse/Corpse.cpp b/src/server/game/Entities/Corpse/Corpse.cpp
index a62b2ecbbc1..a2956b61cb3 100644
--- a/src/server/game/Entities/Corpse/Corpse.cpp
+++ b/src/server/game/Entities/Corpse/Corpse.cpp
@@ -33,7 +33,7 @@ Corpse::Corpse(CorpseType type) : WorldObject(type != CORPSE_BONES), m_type(type
     m_objectType |= TYPEMASK_CORPSE;
     m_objectTypeId = TYPEID_CORPSE;
 
-    m_updateFlag = UPDATEFLAG_STATIONARY_POSITION;
+    m_updateFlag.Stationary = true;
 
     m_valuesCount = CORPSE_END;
     _dynamicValuesCount = CORPSE_DYNAMIC_END;
diff --git a/src/server/game/Entities/Creature/Creature.cpp b/src/server/game/Entities/Creature/Creature.cpp
index e0f03a7717e..fde7d49a943 100644
--- a/src/server/game/Entities/Creature/Creature.cpp
+++ b/src/server/game/Entities/Creature/Creature.cpp
@@ -77,68 +77,67 @@ VendorItem const* VendorItemData::FindItemCostPair(uint32 item_id, uint32 extend
     return nullptr;
 }
 
-uint32 CreatureTemplate::GetRandomValidModelId() const
-{
-    uint8 c = 0;
-    uint32 modelIDs[4];
-
-    if (Modelid1) modelIDs[c++] = Modelid1;
-    if (Modelid2) modelIDs[c++] = Modelid2;
-    if (Modelid3) modelIDs[c++] = Modelid3;
-    if (Modelid4) modelIDs[c++] = Modelid4;
-
-    return ((c>0) ? modelIDs[urand(0, c-1)] : 0);
-}
+CreatureModel const CreatureModel::DefaultInvisibleModel(11686, 1.0f, 1.0f);
+CreatureModel const CreatureModel::DefaultVisibleModel(17519, 1.0f, 1.0f);
 
-uint32 CreatureTemplate::GetFirstValidModelId() const
+CreatureModel const* CreatureTemplate::GetModelByIdx(uint32 idx) const
 {
-    if (Modelid1) return Modelid1;
-    if (Modelid2) return Modelid2;
-    if (Modelid3) return Modelid3;
-    if (Modelid4) return Modelid4;
-    return 0;
+    return idx < Models.size() ? &Models[idx] : nullptr;
 }
 
-uint32 CreatureTemplate::GetFirstInvisibleModel() const
+CreatureModel const* CreatureTemplate::GetRandomValidModel() const
 {
-    CreatureModelInfo const* modelInfo = sObjectMgr->GetCreatureModelInfo(Modelid1);
-    if (modelInfo && modelInfo->is_trigger)
-        return Modelid1;
+    if (!Models.size())
+        return nullptr;
 
-    modelInfo = sObjectMgr->GetCreatureModelInfo(Modelid2);
-    if (modelInfo && modelInfo->is_trigger)
-        return Modelid2;
+    // If only one element, ignore the Probability (even if 0)
+    if (Models.size() == 1)
+        return &Models[0];
 
-    modelInfo = sObjectMgr->GetCreatureModelInfo(Modelid3);
-    if (modelInfo && modelInfo->is_trigger)
-        return Modelid3;
+    auto selectedItr = Trinity::Containers::SelectRandomWeightedContainerElement(Models, [](CreatureModel const& model)
+    {
+        return model.Probability;
+    });
 
-    modelInfo = sObjectMgr->GetCreatureModelInfo(Modelid4);
-    if (modelInfo && modelInfo->is_trigger)
-        return Modelid4;
+    return &(*selectedItr);
+}
 
-    return 11686;
+CreatureModel const* CreatureTemplate::GetFirstValidModel() const
+{
+    for (CreatureModel const& model : Models)
+        if (model.CreatureDisplayID)
+            return &model;
+
+    return nullptr;
 }
 
-uint32 CreatureTemplate::GetFirstVisibleModel() const
+CreatureModel const* CreatureTemplate::GetModelWithDisplayId(uint32 displayId) const
 {
-    CreatureModelInfo const* modelInfo = sObjectMgr->GetCreatureModelInfo(Modelid1);
-    if (modelInfo && !modelInfo->is_trigger)
-        return Modelid1;
+    for (CreatureModel const& model : Models)
+        if (displayId == model.CreatureDisplayID)
+            return &model;
 
-    modelInfo = sObjectMgr->GetCreatureModelInfo(Modelid2);
-    if (modelInfo && !modelInfo->is_trigger)
-        return Modelid2;
+    return nullptr;
+}
 
-    modelInfo = sObjectMgr->GetCreatureModelInfo(Modelid3);
-    if (modelInfo && !modelInfo->is_trigger)
-        return Modelid3;
+CreatureModel const* CreatureTemplate::GetFirstInvisibleModel() const
+{
+    for (CreatureModel const& model : Models)
+        if (CreatureModelInfo const* modelInfo = sObjectMgr->GetCreatureModelInfo(model.CreatureDisplayID))
+            if (modelInfo && modelInfo->is_trigger)
+                return &model;
+
+    return &CreatureModel::DefaultInvisibleModel;
+}
 
-    modelInfo = sObjectMgr->GetCreatureModelInfo(Modelid4);
-    if (modelInfo && !modelInfo->is_trigger)
-        return Modelid4;
+CreatureModel const* CreatureTemplate::GetFirstVisibleModel() const
+{
+    for (CreatureModel const& model : Models)
+        if (CreatureModelInfo const* modelInfo = sObjectMgr->GetCreatureModelInfo(model.CreatureDisplayID))
+            if (modelInfo && !modelInfo->is_trigger)
+                return &model;
 
-    return 17519;
+    return &CreatureModel::DefaultVisibleModel;
 }
 
 bool AssistDelayEvent::Execute(uint64 /*e_time*/, uint32 /*p_time*/)
@@ -347,22 +346,22 @@ bool Creature::InitEntry(uint32 entry, CreatureData const* data /*= nullptr*/)
     SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_CLASS, uint8(cinfo->unit_class));
 
     // Cancel load if no model defined
-    if (!(cinfo->GetFirstValidModelId()))
+    if (!(cinfo->GetFirstValidModel()))
     {
         TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) has no model defined in table `creature_template`, can't load. ", entry);
         return false;
     }
 
-    uint32 displayID = ObjectMgr::ChooseDisplayId(GetCreatureTemplate(), data);
-    CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelRandomGender(&displayID);
+    CreatureModel model = *ObjectMgr::ChooseDisplayId(cinfo, data);
+    CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelRandomGender(&model, cinfo);
     if (!minfo)                                             // Cancel load if no model defined
     {
-        TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) has invalid model %u defined in table `creature_template`, can't load.", entry, displayID);
+        TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) has invalid model %u defined in table `creature_template`, can't load.", entry, model.CreatureDisplayID);
         return false;
     }
 
-    SetDisplayId(displayID);
-    SetNativeDisplayId(displayID);
+    SetDisplayId(model.CreatureDisplayID, model.DisplayScale);
+    SetNativeDisplayId(model.CreatureDisplayID, model.DisplayScale);
     SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_GENDER, minfo->gender);
 
     // Load creature equipment
@@ -388,7 +387,7 @@ bool Creature::InitEntry(uint32 entry, CreatureData const* data /*= nullptr*/)
     SetSpeedRate(MOVE_SWIM,   1.0f); // using 1.0 rate
     SetSpeedRate(MOVE_FLIGHT, 1.0f); // using 1.0 rate
 
-    // Will set UNIT_FIELD_BOUNDINGRADIUS and UNIT_FIELD_COMBATREACH
+    // Will set UNIT_FIELD_BOUNDINGRADIUS, UNIT_FIELD_COMBATREACH and UNIT_FIELD_DISPLAYSCALE
     SetObjectScale(cinfo->scale);
 
     SetFloatValue(UNIT_FIELD_HOVERHEIGHT, cinfo->HoverHeight);
@@ -434,6 +433,8 @@ bool Creature::UpdateEntry(uint32 entry, CreatureData const* data /*= nullptr*/,
 
     SetUInt32Value(OBJECT_DYNAMIC_FLAGS, dynamicFlags);
 
+    SetUInt32Value(UNIT_FIELD_STATE_ANIM_ID, sAnimationDataStore.GetNumRows());
+
     RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
 
     SetBaseAttackTime(BASE_ATTACK,   cInfo->BaseAttackTime);
@@ -894,7 +895,8 @@ bool Creature::Create(ObjectGuid::LowType guidlow, Map* map, uint32 entry, float
     if (!CreateFromProto(guidlow, entry, data, vehId))
         return false;
 
-    switch (GetCreatureTemplate()->rank)
+    cinfo = GetCreatureTemplate(); // might be different than initially requested
+    switch (cinfo->rank)
     {
         case CREATURE_ELITE_RARE:
             m_corpseDelay = sWorld->getIntConfig(CONFIG_CORPSE_DECAY_RARE);
@@ -924,12 +926,12 @@ bool Creature::Create(ObjectGuid::LowType guidlow, Map* map, uint32 entry, float
         Relocate(x, y, z, ang);
     }
 
-    uint32 displayID = GetNativeDisplayId();
-    CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelRandomGender(&displayID);
+    CreatureModel display(GetNativeDisplayId(), GetNativeDisplayScale(), 1.0f);
+    CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelRandomGender(&display, cinfo);
     if (minfo && !IsTotem())                               // Cancel load if no model defined or if totem
     {
-        SetDisplayId(displayID);
-        SetNativeDisplayId(displayID);
+        SetDisplayId(display.CreatureDisplayID, display.DisplayScale);
+        SetNativeDisplayId(display.CreatureDisplayID, display.DisplayScale);
         SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_GENDER, minfo->gender);
     }
 
@@ -942,10 +944,10 @@ bool Creature::Create(ObjectGuid::LowType guidlow, Map* map, uint32 entry, float
         m_serverSideVisibilityDetect.SetValue(SERVERSIDE_VISIBILITY_GHOST, GHOST_VISIBILITY_GHOST);
     }
 
-    if (GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_IGNORE_PATHFINDING)
+    if (cinfo->flags_extra & CREATURE_FLAG_EXTRA_IGNORE_PATHFINDING)
         AddUnitState(UNIT_STATE_IGNORE_PATHFINDING);
 
-    if (GetCreatureTemplate()->flags_extra & CREATURE_FLAG_EXTRA_IMMUNITY_KNOCKBACK)
+    if (cinfo->flags_extra & CREATURE_FLAG_EXTRA_IMMUNITY_KNOCKBACK)
     {
         ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK, true);
         ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK_DEST, true);
@@ -1129,9 +1131,9 @@ void Creature::SaveToDB(uint32 mapid, std::vector<Difficulty> const& spawnDiffic
     CreatureTemplate const* cinfo = GetCreatureTemplate();
     if (cinfo)
     {
-        if (displayId == cinfo->Modelid1 || displayId == cinfo->Modelid2 ||
-            displayId == cinfo->Modelid3 || displayId == cinfo->Modelid4)
-            displayId = 0;
+        for (CreatureModel model : cinfo->Models)
+            if (displayId && displayId == model.CreatureDisplayID)
+                displayId = 0;
 
         if (npcflag == cinfo->npcflag)
             npcflag = 0;
@@ -1844,12 +1846,12 @@ void Creature::Respawn(bool force)
 
         setDeathState(JUST_RESPAWNED);
 
-        uint32 displayID = GetNativeDisplayId();
-        CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelRandomGender(&displayID);
+        CreatureModel display(GetNativeDisplayId(), GetNativeDisplayScale(), 1.0f);
+        CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelRandomGender(&display, GetCreatureTemplate());
         if (minfo)                                             // Cancel load if no model defined
         {
-            SetDisplayId(displayID);
-            SetNativeDisplayId(displayID);
+            SetDisplayId(display.CreatureDisplayID, display.DisplayScale);
+            SetNativeDisplayId(display.CreatureDisplayID, display.DisplayScale);
             SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_GENDER, minfo->gender);
         }
 
@@ -2575,7 +2577,7 @@ uint8 Creature::GetLevelForTarget(WorldObject const* target) const
             uint8 targetLevelWithDelta = unitTarget->getLevel() + GetInt32Value(UNIT_FIELD_SCALING_LEVEL_DELTA);
 
             if (target->IsPlayer())
-                targetLevelWithDelta += target->GetUInt32Value(PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
+                targetLevelWithDelta += target->GetUInt32Value(ACTIVE_PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
 
             return RoundToInterval<uint8>(targetLevelWithDelta, GetUInt32Value(UNIT_FIELD_SCALING_LEVEL_MIN), GetUInt32Value(UNIT_FIELD_SCALING_LEVEL_MAX));
         }
@@ -2853,9 +2855,9 @@ void Creature::SetObjectScale(float scale)
     }
 }
 
-void Creature::SetDisplayId(uint32 modelId)
+void Creature::SetDisplayId(uint32 modelId, float displayScale /*= 1.f*/)
 {
-    Unit::SetDisplayId(modelId);
+    Unit::SetDisplayId(modelId, displayScale);
 
     if (CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelInfo(modelId))
     {
@@ -2864,6 +2866,12 @@ void Creature::SetDisplayId(uint32 modelId)
     }
 }
 
+void Creature::SetDisplayFromModel(uint32 modelIdx)
+{
+    if (CreatureModel const* model = GetCreatureTemplate()->GetModelByIdx(modelIdx))
+        SetDisplayId(model->CreatureDisplayID, model->DisplayScale);
+}
+
 void Creature::SetTarget(ObjectGuid const& guid)
 {
     if (IsFocusing(nullptr, true))
diff --git a/src/server/game/Entities/Creature/Creature.h b/src/server/game/Entities/Creature/Creature.h
index d87db9be2ca..b56fe8c9137 100644
--- a/src/server/game/Entities/Creature/Creature.h
+++ b/src/server/game/Entities/Creature/Creature.h
@@ -69,7 +69,8 @@ class TC_GAME_API Creature : public Unit, public GridObject<Creature>, public Ma
         void RemoveFromWorld() override;
 
         void SetObjectScale(float scale) override;
-        void SetDisplayId(uint32 modelId) override;
+        void SetDisplayId(uint32 displayId, float displayScale = 1.f) override;
+        void SetDisplayFromModel(uint32 modelIdx);
 
         void DisappearAndDie();
 
@@ -149,7 +150,6 @@ class TC_GAME_API Creature : public Unit, public GridObject<Creature>, public Ma
 
         bool UpdateStats(Stats stat) override;
         bool UpdateAllStats() override;
-        void UpdateResistances(uint32 school) override;
         void UpdateArmor() override;
         void UpdateMaxHealth() override;
         void UpdateMaxPower(Powers power) override;
diff --git a/src/server/game/Entities/Creature/CreatureData.h b/src/server/game/Entities/Creature/CreatureData.h
index d0d29d842e7..02fdcfbff16 100644
--- a/src/server/game/Entities/Creature/CreatureData.h
+++ b/src/server/game/Entities/Creature/CreatureData.h
@@ -301,16 +301,29 @@ struct CreatureLevelScaling
     int16 DeltaLevelMax;
 };
 
+struct CreatureModel
+{
+    static CreatureModel const DefaultInvisibleModel;
+    static CreatureModel const DefaultVisibleModel;
+
+    CreatureModel() :
+        CreatureDisplayID(0), DisplayScale(0.0f), Probability(0.0f) { }
+
+    CreatureModel(uint32 creatureDisplayID, float displayScale, float probability) :
+        CreatureDisplayID(creatureDisplayID), DisplayScale(displayScale), Probability(probability) { }
+
+    uint32 CreatureDisplayID;
+    float DisplayScale;
+    float Probability;
+};
+
 // from `creature_template` table
 struct TC_GAME_API CreatureTemplate
 {
     uint32  Entry;
     uint32  DifficultyEntry[MAX_CREATURE_DIFFICULTIES];
     uint32  KillCredit[MAX_KILL_CREDIT];
-    uint32  Modelid1;
-    uint32  Modelid2;
-    uint32  Modelid3;
-    uint32  Modelid4;
+    std::vector<CreatureModel> Models;
     std::string  Name;
     std::string FemaleName;
     std::string  SubName;
@@ -369,10 +382,12 @@ struct TC_GAME_API CreatureTemplate
     uint32  MechanicImmuneMask;
     uint32  flags_extra;
     uint32  ScriptID;
-    uint32  GetRandomValidModelId() const;
-    uint32  GetFirstValidModelId() const;
-    uint32  GetFirstInvisibleModel() const;
-    uint32  GetFirstVisibleModel() const;
+    CreatureModel const* GetModelByIdx(uint32 idx) const;
+    CreatureModel const* GetRandomValidModel() const;
+    CreatureModel const* GetFirstValidModel() const;
+    CreatureModel const* GetModelWithDisplayId(uint32 displayId) const;
+    CreatureModel const* GetFirstInvisibleModel() const;
+    CreatureModel const* GetFirstVisibleModel() const;
 
     // helpers
     SkillType GetRequiredLootSkill() const
diff --git a/src/server/game/Entities/Creature/GossipDef.cpp b/src/server/game/Entities/Creature/GossipDef.cpp
index 98a253fe870..9f5b461ef8d 100644
--- a/src/server/game/Entities/Creature/GossipDef.cpp
+++ b/src/server/game/Entities/Creature/GossipDef.cpp
@@ -286,6 +286,7 @@ void PlayerMenu::SendPointOfInterest(uint32 id) const
     }
 
     WorldPackets::NPC::GossipPOI packet;
+    packet.ID = pointOfInterest->ID;
     packet.Name = pointOfInterest->Name;
 
     LocaleConstant localeConstant = _session->GetSessionDbLocaleIndex();
@@ -438,6 +439,7 @@ void PlayerMenu::SendQuestGiverQuestDetails(Quest const* quest, ObjectGuid npcGU
     packet.InformUnit = _session->GetPlayer()->GetDivider();
     packet.QuestID = quest->GetQuestId();
     packet.PortraitGiver = quest->GetQuestGiverPortrait();
+    packet.PortraitGiverMount = quest->GetQuestGiverPortraitMount();
     packet.PortraitTurnIn = quest->GetQuestTurnInPortrait();
     packet.AutoLaunched = autoLaunched;
     packet.DisplayPopup = displayPopup;
@@ -512,6 +514,7 @@ void PlayerMenu::SendQuestQueryResponse(Quest const* quest) const
     packet.Info.QuestID = quest->GetQuestId();
     packet.Info.QuestType = quest->GetQuestType();
     packet.Info.QuestLevel = quest->GetQuestLevel();
+    packet.Info.QuestScalingFactionGroup = quest->GetQuestScalingFactionGroup();
     packet.Info.QuestMaxScalingLevel = quest->GetQuestMaxScalingLevel();
     packet.Info.QuestPackageID = quest->GetQuestPackageID();
     packet.Info.QuestMinLevel = quest->GetMinLevel();
@@ -543,12 +546,14 @@ void PlayerMenu::SendQuestQueryResponse(Quest const* quest) const
     packet.Info.StartItem = quest->GetSrcItemId();
     packet.Info.Flags = quest->GetFlags();
     packet.Info.FlagsEx = quest->GetFlagsEx();
+    packet.Info.FlagsEx2 = quest->GetFlagsEx2();
     packet.Info.RewardTitle = quest->GetRewTitle();
     packet.Info.RewardArenaPoints = quest->GetRewArenaPoints();
     packet.Info.RewardSkillLineID = quest->GetRewardSkillId();
     packet.Info.RewardNumSkillUps = quest->GetRewardSkillPoints();
     packet.Info.RewardFactionFlags = quest->GetRewardReputationMask();
     packet.Info.PortraitGiver = quest->GetQuestGiverPortrait();
+    packet.Info.PortraitGiverMount = quest->GetQuestGiverPortraitMount();
     packet.Info.PortraitTurnIn = quest->GetQuestTurnInPortrait();
 
     for (uint8 i = 0; i < QUEST_ITEM_DROP_COUNT; ++i)
@@ -585,7 +590,7 @@ void PlayerMenu::SendQuestQueryResponse(Quest const* quest) const
     packet.Info.POIPriority = quest->GetPOIPriority();
 
     packet.Info.AllowableRaces = quest->GetAllowableRaces();
-    packet.Info.QuestRewardID = quest->GetRewardId();
+    packet.Info.TreasurePickerID = quest->GetTreasurePickerId();
     packet.Info.Expansion = quest->GetExpansion();
 
     for (QuestObjective const& questObjective : quest->GetObjectives())
@@ -666,6 +671,7 @@ void PlayerMenu::SendQuestGiverOfferReward(Quest const* quest, ObjectGuid npcGUI
 
     packet.PortraitTurnIn = quest->GetQuestTurnInPortrait();
     packet.PortraitGiver = quest->GetQuestGiverPortrait();
+    packet.PortraitGiverMount = quest->GetQuestGiverPortraitMount();
     packet.QuestPackageID = quest->GetQuestPackageID();
 
     _session->SendPacket(packet.Write());
diff --git a/src/server/game/Entities/Creature/Trainer.cpp b/src/server/game/Entities/Creature/Trainer.cpp
index fb9f0af7f19..af59acb7496 100644
--- a/src/server/game/Entities/Creature/Trainer.cpp
+++ b/src/server/game/Entities/Creature/Trainer.cpp
@@ -24,6 +24,10 @@
 
 namespace Trainer
 {
+    bool Spell::IsCastable() const
+    {
+        return sSpellMgr->AssertSpellInfo(SpellId)->HasEffect(SPELL_EFFECT_LEARN_SPELL);
+    }
 
     Trainer::Trainer(uint32 id, Type type, std::string greeting, std::vector<Spell> spells) : _id(id), _type(type), _spells(std::move(spells))
     {
@@ -136,9 +140,30 @@ namespace Trainer
             return SpellState::Unavailable;
 
         // check ranks
-        if (uint32 previousRankSpellId = sSpellMgr->GetPrevSpellInChain(trainerSpell->LearnedSpellId))
-            if (!player->HasSpell(previousRankSpellId))
-                return SpellState::Unavailable;
+        bool hasLearnSpellEffect = false;
+        bool knowsAllLearnedSpells = true;
+        for (SpellEffectInfo const* spellEffect : sSpellMgr->AssertSpellInfo(trainerSpell->SpellId)->GetEffectsForDifficulty(DIFFICULTY_NONE))
+        {
+            if (!spellEffect || !spellEffect->IsEffect(SPELL_EFFECT_LEARN_SPELL))
+                continue;
+
+            hasLearnSpellEffect = true;
+            if (!player->HasSpell(spellEffect->TriggerSpell))
+                knowsAllLearnedSpells = false;
+
+            if (uint32 previousRankSpellId = sSpellMgr->GetPrevSpellInChain(spellEffect->TriggerSpell))
+                if (!player->HasSpell(previousRankSpellId))
+                    return SpellState::Unavailable;
+        }
+
+        if (!hasLearnSpellEffect)
+        {
+            if (uint32 previousRankSpellId = sSpellMgr->GetPrevSpellInChain(trainerSpell->SpellId))
+                if (!player->HasSpell(previousRankSpellId))
+                    return SpellState::Unavailable;
+        }
+        else if (knowsAllLearnedSpells)
+            return SpellState::Known;
 
         // check additional spell requirement
         for (auto const& requirePair : sSpellMgr->GetSpellsRequiredForSpellBounds(trainerSpell->SpellId))
diff --git a/src/server/game/Entities/Creature/Trainer.h b/src/server/game/Entities/Creature/Trainer.h
index f7e9c51dba1..20ee7deb3f5 100644
--- a/src/server/game/Entities/Creature/Trainer.h
+++ b/src/server/game/Entities/Creature/Trainer.h
@@ -59,8 +59,7 @@ namespace Trainer
         std::array<uint32, 3> ReqAbility = { };
         uint8 ReqLevel = 0;
 
-        uint32 LearnedSpellId = 0;
-        bool IsCastable() const { return LearnedSpellId != SpellId; }
+        bool IsCastable() const;
     };
 
     class Trainer
diff --git a/src/server/game/Entities/DynamicObject/DynamicObject.cpp b/src/server/game/Entities/DynamicObject/DynamicObject.cpp
index ed5e3dc043b..8ee595cb179 100644
--- a/src/server/game/Entities/DynamicObject/DynamicObject.cpp
+++ b/src/server/game/Entities/DynamicObject/DynamicObject.cpp
@@ -38,7 +38,7 @@ DynamicObject::DynamicObject(bool isWorldObject) : WorldObject(isWorldObject),
     m_objectType |= TYPEMASK_DYNAMICOBJECT;
     m_objectTypeId = TYPEID_DYNAMICOBJECT;
 
-    m_updateFlag = UPDATEFLAG_STATIONARY_POSITION;
+    m_updateFlag.Stationary = true;
 
     m_valuesCount = DYNAMICOBJECT_END;
     _dynamicValuesCount = DYNAMICOBJECT_DYNAMIC_END;
diff --git a/src/server/game/Entities/GameObject/GameObject.cpp b/src/server/game/Entities/GameObject/GameObject.cpp
index 89b59a11ab2..435ccc5c9a9 100644
--- a/src/server/game/Entities/GameObject/GameObject.cpp
+++ b/src/server/game/Entities/GameObject/GameObject.cpp
@@ -61,7 +61,8 @@ GameObject::GameObject() : WorldObject(false), MapObject(),
     m_objectType |= TYPEMASK_GAMEOBJECT;
     m_objectTypeId = TYPEID_GAMEOBJECT;
 
-    m_updateFlag = (UPDATEFLAG_STATIONARY_POSITION | UPDATEFLAG_ROTATION);
+    m_updateFlag.Stationary = true;
+    m_updateFlag.Rotation = true;
 
     m_valuesCount = GAMEOBJECT_END;
     _dynamicValuesCount = GAMEOBJECT_DYNAMIC_END;
@@ -238,7 +239,7 @@ bool GameObject::Create(uint32 entry, Map* map, Position const& pos, QuaternionD
     else
     {
         guid = ObjectGuid::Create<HighGuid::Transport>(map->GenerateLowGuid<HighGuid::Transport>());
-        m_updateFlag |= UPDATEFLAG_TRANSPORT;
+        m_updateFlag.ServerTime = true;
     }
 
     Object::_Create(guid);
@@ -271,7 +272,7 @@ bool GameObject::Create(uint32 entry, Map* map, Position const& pos, QuaternionD
 
         if (m_goTemplateAddon->WorldEffectID)
         {
-            m_updateFlag |= UPDATEFLAG_GAMEOBJECT;
+            m_updateFlag.GameObject = true;
             SetWorldEffectID(m_goTemplateAddon->WorldEffectID);
         }
     }
@@ -292,6 +293,8 @@ bool GameObject::Create(uint32 entry, Map* map, Position const& pos, QuaternionD
     SetGoState(goState);
     SetGoArtKit(artKit);
 
+    SetUInt32Value(GAMEOBJECT_STATE_ANIM_ID, sAnimationDataStore.GetNumRows());
+
     switch (goInfo->type)
     {
         case GAMEOBJECT_TYPE_FISHINGHOLE:
@@ -376,7 +379,7 @@ bool GameObject::Create(uint32 entry, Map* map, Position const& pos, QuaternionD
 
     if (gameObjectAddon && gameObjectAddon->WorldEffectID)
     {
-        m_updateFlag |= UPDATEFLAG_GAMEOBJECT;
+        m_updateFlag.GameObject = true;
         SetWorldEffectID(gameObjectAddon->WorldEffectID);
     }
 
diff --git a/src/server/game/Entities/GameObject/GameObjectData.h b/src/server/game/Entities/GameObject/GameObjectData.h
index 3e600376a97..a699be4bcf7 100644
--- a/src/server/game/Entities/GameObject/GameObjectData.h
+++ b/src/server/game/Entities/GameObject/GameObjectData.h
@@ -105,7 +105,7 @@ struct GameObjectTemplate
             uint32 usegrouplootrules;                       // 15 use group loot rules, enum { false, true, }; Default: false
             uint32 floatingTooltip;                         // 16 floatingTooltip, enum { false, true, }; Default: false
             uint32 conditionID1;                            // 17 conditionID1, References: PlayerCondition, NoValue = 0
-            int32 xpLevel;                                  // 18 xpLevel, int, Min value: -1, Max value: 123, Default value: 0
+            uint32 XPLevelRange;                            // 18 XP Level Range, References: ContentTuning, NoValue = 0
             uint32 xpDifficulty;                            // 19 xpDifficulty, enum { No Exp, Trivial, Very Small, Small, Substandard, Standard, High, Epic, Dungeon, 5, }; Default: No Exp
             uint32 lootLevel;                               // 20 lootLevel, int, Min value: 0, Max value: 123, Default value: 0
             uint32 GroupXP;                                 // 21 Group XP, enum { false, true, }; Default: false
@@ -120,6 +120,7 @@ struct GameObjectTemplate
             uint32 chestPersonalLoot;                       // 30 chest Personal Loot, References: Treasure, NoValue = 0
             uint32 turnpersonallootsecurityoff;             // 31 turn personal loot security off, enum { false, true, }; Default: false
             uint32 ChestProperties;                         // 32 Chest Properties, References: ChestProperties, NoValue = 0
+            uint32 chestPushLoot;                           // 33 chest Push Loot, References: Treasure, NoValue = 0
         } chest;
         // 4 GAMEOBJECT_TYPE_BINDER
         struct
@@ -332,6 +333,7 @@ struct GameObjectTemplate
         {
             uint32 creatureID;                              // 0 creatureID, References: Creature, NoValue = 0
             uint32 charges;                                 // 1 charges, int, Min value: 0, Max value: 65535, Default value: 1
+            uint32 Preferonlyifinlineofsight;               // 2 Prefer only if in line of sight (expensive), enum { false, true, }; Default: false
         } guardPost;
         // 22 GAMEOBJECT_TYPE_SPELLCASTER
         struct
@@ -503,7 +505,10 @@ struct GameObjectTemplate
             uint32 startOpen;                               // 1 startOpen, enum { false, true, }; Default: false
             uint32 autoClose;                               // 2 autoClose (ms), int, Min value: 0, Max value: 2147483647, Default value: 0
             uint32 BlocksPathsDown;                         // 3 Blocks Paths Down, enum { false, true, }; Default: false
-            uint32 PathBlockerBump;                         // 4 Path Blocker Bump (ft), int, Min value: -2147483648, Max value: 2147483647, Default value: 0
+            int32 PathBlockerBump;                          // 4 Path Blocker Bump (ft), int, Min value: -2147483648, Max value: 2147483647, Default value: 0
+            uint32 GiganticAOI;                             // 5 Gigantic AOI, enum { false, true, }; Default: false
+            uint32 InfiniteAOI;                             // 6 Infinite AOI, enum { false, true, }; Default: false
+            uint32 DoorisOpaque;                            // 7 Door is Opaque (Disable portal on close), enum { false, true, }; Default: false
         } trapdoor;
         // 36 GAMEOBJECT_TYPE_NEW_FLAG
         struct
@@ -581,7 +586,7 @@ struct GameObjectTemplate
         struct
         {
             int32 SpawnMap;                                 // 0 Spawn Map, References: Map, NoValue = -1
-            uint32 AreaNameSet;                             // 1 Area Name Set (Index), int, Min value: -2147483648, Max value: 2147483647, Default value: 0
+            int32 AreaNameSet;                              // 1 Area Name Set (Index), int, Min value: -2147483648, Max value: 2147483647, Default value: 0
             uint32 DoodadSetA;                              // 2 Doodad Set A, int, Min value: 0, Max value: 2147483647, Default value: 0
             uint32 DoodadSetB;                              // 3 Doodad Set B, int, Min value: 0, Max value: 2147483647, Default value: 0
         } phaseableMO;
@@ -616,7 +621,7 @@ struct GameObjectTemplate
         // 48 GAMEOBJECT_TYPE_UI_LINK
         struct
         {
-            uint32 UILinkType;                              // 0 UI Link Type, enum { Adventure Journal, Obliterum Forge, }; Default: Adventure Journal
+            uint32 UILinkType;                              // 0 UI Link Type, enum { Adventure Journal, Obliterum Forge, Scrapping Machine, }; Default: Adventure Journal
             uint32 allowMounted;                            // 1 allowMounted, enum { false, true, }; Default: false
             uint32 GiganticAOI;                             // 2 Gigantic AOI, enum { false, true, }; Default: false
             uint32 spellFocusType;                          // 3 spellFocusType, References: SpellFocusObject, NoValue = 0
@@ -641,7 +646,7 @@ struct GameObjectTemplate
             uint32 openTextID;                              // 9 openTextID, References: BroadcastText, NoValue = 0
             uint32 floatingTooltip;                         // 10 floatingTooltip, enum { false, true, }; Default: false
             uint32 conditionID1;                            // 11 conditionID1, References: PlayerCondition, NoValue = 0
-            uint32 xpLevel;                                 // 12 xpLevel, int, Min value: -1, Max value: 123, Default value: 0
+            uint32 XPLevelRange;                            // 12 XP Level Range, References: ContentTuning, NoValue = 0
             uint32 xpDifficulty;                            // 13 xpDifficulty, enum { No Exp, Trivial, Very Small, Small, Substandard, Standard, High, Epic, Dungeon, 5, }; Default: No Exp
             uint32 spell;                                   // 14 spell, References: Spell, NoValue = 0
             uint32 GiganticAOI;                             // 15 Gigantic AOI, enum { false, true, }; Default: false
@@ -650,13 +655,45 @@ struct GameObjectTemplate
             uint32 MaxNumberofLoots;                        // 18 Max Number of Loots, int, Min value: 1, Max value: 40, Default value: 10
             uint32 logloot;                                 // 19 log loot, enum { false, true, }; Default: false
             uint32 linkedTrap;                              // 20 linkedTrap, References: GameObjects, NoValue = 0
+            uint32 PlayOpenAnimationonOpening;              // 21 Play Open Animation on Opening, enum { false, true, }; Default: false
         } gatheringNode;
         // 51 GAMEOBJECT_TYPE_CHALLENGE_MODE_REWARD
         struct
         {
             uint32 chestLoot;                               // 0 chestLoot, References: Treasure, NoValue = 0
             uint32 WhenAvailable;                           // 1 When Available, References: GameObjectDisplayInfo, NoValue = 0
+            uint32 open;                                    // 2 open, References: Lock_, NoValue = 0
+            uint32 openTextID;                              // 3 openTextID, References: BroadcastText, NoValue = 0
         } challengeModeReward;
+        // 52 GAMEOBJECT_TYPE_MULTI
+        struct
+        {
+            uint32 MultiProperties;                         // 0 Multi Properties, References: MultiProperties, NoValue = 0
+        } multi;
+        // 53 GAMEOBJECT_TYPE_SIEGEABLE_MULTI
+        struct
+        {
+            uint32 MultiProperties;                         // 0 Multi Properties, References: MultiProperties, NoValue = 0
+            uint32 InitialDamage;                           // 1 Initial Damage, enum { None, Raw, Ratio, }; Default: None
+        } siegeableMulti;
+        // 54 GAMEOBJECT_TYPE_SIEGEABLE_MO
+        struct
+        {
+            uint32 SiegeableProperties;                     // 0 Siegeable Properties, References: SiegeableProperties, NoValue = 0
+            uint32 DoodadSetA;                              // 1 Doodad Set A, int, Min value: 0, Max value: 2147483647, Default value: 0
+            uint32 DoodadSetB;                              // 2 Doodad Set B, int, Min value: 0, Max value: 2147483647, Default value: 0
+            uint32 DoodadSetC;                              // 3 Doodad Set C, int, Min value: 0, Max value: 2147483647, Default value: 0
+            int32 SpawnMap;                                 // 4 Spawn Map, References: Map, NoValue = -1
+            int32 AreaNameSet;                              // 5 Area Name Set (Index), int, Min value: -2147483648, Max value: 2147483647, Default value: 0
+        } siegeableMO;
+        // 55 GAMEOBJECT_TYPE_PVP_REWARD
+        struct
+        {
+            uint32 chestLoot;                               // 0 chestLoot, References: Treasure, NoValue = 0
+            uint32 WhenAvailable;                           // 1 When Available, References: GameObjectDisplayInfo, NoValue = 0
+            uint32 open;                                    // 2 open, References: Lock_, NoValue = 0
+            uint32 openTextID;                              // 3 openTextID, References: BroadcastText, NoValue = 0
+        } pvpReward;
         struct
         {
             uint32 data[MAX_GAMEOBJECT_DATA];
@@ -709,6 +746,8 @@ struct GameObjectTemplate
             case GAMEOBJECT_TYPE_NEW_FLAG_DROP:     return newflagdrop.open;
             case GAMEOBJECT_TYPE_CAPTURE_POINT:     return capturePoint.open;
             case GAMEOBJECT_TYPE_GATHERING_NODE:    return gatheringNode.open;
+            case GAMEOBJECT_TYPE_CHALLENGE_MODE_REWARD: return challengeModeReward.open;
+            case GAMEOBJECT_TYPE_PVP_REWARD:        return pvpReward.open;
             default: return 0;
         }
     }
diff --git a/src/server/game/Entities/Item/Item.cpp b/src/server/game/Entities/Item/Item.cpp
index a146d3f0b58..847c3c47c79 100644
--- a/src/server/game/Entities/Item/Item.cpp
+++ b/src/server/game/Entities/Item/Item.cpp
@@ -275,8 +275,6 @@ Item::Item()
     m_objectType |= TYPEMASK_ITEM;
     m_objectTypeId = TYPEID_ITEM;
 
-    m_updateFlag = 0;
-
     m_valuesCount = ITEM_END;
     _dynamicValuesCount = ITEM_DYNAMIC_END;
     m_slot = 0;
@@ -316,14 +314,8 @@ bool Item::Create(ObjectGuid::LowType guidlow, uint32 itemId, Player const* owne
     SetUInt32Value(ITEM_FIELD_DURABILITY, itemProto->MaxDurability);
 
     for (std::size_t i = 0; i < itemProto->Effects.size(); ++i)
-    {
         if (i < 5)
             SetSpellCharges(i, itemProto->Effects[i]->Charges);
-        if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itemProto->Effects[i]->SpellID))
-            if (owner && spellInfo->HasEffect(SPELL_EFFECT_GIVE_ARTIFACT_POWER))
-                if (uint32 artifactKnowledgeLevel = sWorld->getIntConfig(CONFIG_CURRENCY_START_ARTIFACT_KNOWLEDGE))
-                    SetModifier(ITEM_MODIFIER_ARTIFACT_KNOWLEDGE_LEVEL, artifactKnowledgeLevel + 1);
-    }
 
     SetUInt32Value(ITEM_FIELD_DURATION, itemProto->GetDuration());
     SetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME, 0);
@@ -1709,7 +1701,7 @@ bool Item::HasStats() const
     ItemTemplate const* proto = GetTemplate();
     Player const* owner = GetOwner();
     for (uint8 i = 0; i < MAX_ITEM_PROTO_STATS; ++i)
-        if ((owner ? GetItemStatValue(i, owner) : proto->GetItemStatValue(i)) != 0)
+        if ((owner ? GetItemStatValue(i, owner) : proto->GetItemStatAllocation(i)) != 0)
             return true;
 
     return false;
@@ -1721,7 +1713,7 @@ bool Item::HasStats(WorldPackets::Item::ItemInstance const& itemInstance, BonusD
         return true;
 
     for (uint8 i = 0; i < MAX_ITEM_PROTO_STATS; ++i)
-        if (bonus->ItemStatValue[i] != 0)
+        if (bonus->ItemStatAllocation[i] != 0)
             return true;
 
     return false;
@@ -2231,9 +2223,9 @@ uint32 Item::GetItemLevel(ItemTemplate const* itemTemplate, BonusData const& bon
         else
             level = std::min(std::max(int32(level), ssd->MinLevel), ssd->MaxLevel);
 
-        if (SandboxScalingEntry const* sandbox = sSandboxScalingStore.LookupEntry(bonusData.SandboxScalingId))
-            if ((sandbox->Flags & 2 || sandbox->MinLevel || sandbox->MaxLevel) && !(sandbox->Flags & 4))
-                level = std::min(std::max(int32(level), sandbox->MinLevel), sandbox->MaxLevel);
+        if (ContentTuningEntry const* contentTuning = sContentTuningStore.LookupEntry(bonusData.ContentTuningId))
+            if ((contentTuning->Flags & 2 || contentTuning->MinLevel || contentTuning->MaxLevel) && !(contentTuning->Flags & 4))
+                level = std::min(std::max(int32(level), contentTuning->MinLevel), contentTuning->MaxLevel);
 
         if (uint32 heirloomIlvl = uint32(sDB2Manager.GetCurveValueAt(ssd->PlayerLevelToItemLevelCurveID, level)))
             itemLevel = heirloomIlvl;
@@ -2276,7 +2268,7 @@ int32 Item::GetItemStatValue(uint32 index, Player const* owner) const
         return int32(std::floor(statValue + 0.5f));
     }
 
-    return _bonusData.ItemStatValue[index];
+    return 0;
 }
 
 ItemDisenchantLootEntry const* Item::GetDisenchantLoot(Player const* owner) const
@@ -2565,8 +2557,6 @@ void Item::GiveArtifactXp(uint64 amount, Item* sourceItem, uint32 artifactCatego
         uint32 artifactKnowledgeLevel = 1;
         if (sourceItem && sourceItem->GetModifier(ITEM_MODIFIER_ARTIFACT_KNOWLEDGE_LEVEL))
             artifactKnowledgeLevel = sourceItem->GetModifier(ITEM_MODIFIER_ARTIFACT_KNOWLEDGE_LEVEL);
-        else if (artifactCategoryId == ARTIFACT_CATEGORY_PRIMARY)
-            artifactKnowledgeLevel = sWorld->getIntConfig(CONFIG_CURRENCY_START_ARTIFACT_KNOWLEDGE) + 1;
 
         if (GtArtifactKnowledgeMultiplierEntry const* artifactKnowledge = sArtifactKnowledgeMultiplierGameTable.GetRow(artifactKnowledgeLevel))
             amount = uint64(amount * artifactKnowledge->Multiplier);
@@ -2598,9 +2588,9 @@ void Item::SetFixedLevel(uint8 level)
     {
         level = std::min(std::max(int32(level), ssd->MinLevel), ssd->MaxLevel);
 
-        if (SandboxScalingEntry const* sandbox = sSandboxScalingStore.LookupEntry(_bonusData.SandboxScalingId))
-            if ((sandbox->Flags & 2 || sandbox->MinLevel || sandbox->MaxLevel) && !(sandbox->Flags & 4))
-                level = std::min(std::max(int32(level), sandbox->MinLevel), sandbox->MaxLevel);
+        if (ContentTuningEntry const* contentTuning = sContentTuningStore.LookupEntry(_bonusData.ContentTuningId))
+            if ((contentTuning->Flags & 2 || contentTuning->MinLevel || contentTuning->MaxLevel) && !(contentTuning->Flags & 4))
+                level = std::min(std::max(int32(level), contentTuning->MinLevel), contentTuning->MaxLevel);
 
         SetModifier(ITEM_MODIFIER_SCALING_STAT_DISTRIBUTION_FIXED_LEVEL, level);
     }
@@ -2625,9 +2615,6 @@ void BonusData::Initialize(ItemTemplate const* proto)
         ItemStatType[i] = proto->GetItemStatType(i);
 
     for (uint32 i = 0; i < MAX_ITEM_PROTO_STATS; ++i)
-        ItemStatValue[i] = proto->GetItemStatValue(i);
-
-    for (uint32 i = 0; i < MAX_ITEM_PROTO_STATS; ++i)
         ItemStatAllocation[i] = proto->GetItemStatAllocation(i);
 
     for (uint32 i = 0; i < MAX_ITEM_PROTO_STATS; ++i)
@@ -2646,7 +2633,7 @@ void BonusData::Initialize(ItemTemplate const* proto)
     AppearanceModID = 0;
     RepairCostMultiplier = 1.0f;
     ScalingStatDistribution = proto->GetScalingStatDistribution();
-    SandboxScalingId = 0;
+    ContentTuningId = 0;
     RelicType = -1;
     HasItemLevelBonus = false;
     HasFixedLevel = false;
@@ -2734,7 +2721,7 @@ void BonusData::AddBonus(uint32 type, int32 const (&values)[3])
             if (values[1] < _state.ScalingStatDistributionPriority)
             {
                 ScalingStatDistribution = static_cast<uint32>(values[0]);
-                SandboxScalingId = static_cast<uint32>(values[2]);
+                ContentTuningId = static_cast<uint32>(values[2]);
                 _state.ScalingStatDistributionPriority = values[1];
                 HasFixedLevel = type == ITEM_BONUS_SCALING_STAT_DISTRIBUTION_FIXED;
             }
diff --git a/src/server/game/Entities/Item/Item.h b/src/server/game/Entities/Item/Item.h
index a51415abcbb..6ee784c8d7d 100644
--- a/src/server/game/Entities/Item/Item.h
+++ b/src/server/game/Entities/Item/Item.h
@@ -78,7 +78,6 @@ struct BonusData
     int32 ItemLevelBonus;
     int32 RequiredLevel;
     int32 ItemStatType[MAX_ITEM_PROTO_STATS];
-    int32 ItemStatValue[MAX_ITEM_PROTO_STATS];
     int32 ItemStatAllocation[MAX_ITEM_PROTO_STATS];
     float ItemStatSocketCostMultiplier[MAX_ITEM_PROTO_STATS];
     uint32 SocketColor[MAX_ITEM_PROTO_SOCKETS];
@@ -86,7 +85,7 @@ struct BonusData
     uint32 AppearanceModID;
     float RepairCostMultiplier;
     uint32 ScalingStatDistribution;
-    uint32 SandboxScalingId;
+    uint32 ContentTuningId;
     uint32 DisenchantLootId;
     uint32 GemItemLevelBonus[MAX_ITEM_PROTO_SOCKETS];
     int32 GemRelicType[MAX_ITEM_PROTO_SOCKETS];
diff --git a/src/server/game/Entities/Item/ItemDefines.h b/src/server/game/Entities/Item/ItemDefines.h
index 107a89c6152..6b74a600d50 100644
--- a/src/server/game/Entities/Item/ItemDefines.h
+++ b/src/server/game/Entities/Item/ItemDefines.h
@@ -51,79 +51,82 @@ enum InventoryResult : uint8
     EQUIP_ERR_TOO_FEW_TO_SPLIT                             = 26, // Tried to split more than number in stack.
     EQUIP_ERR_SPLIT_FAILED                                 = 27, // Couldn't split those items.
     EQUIP_ERR_SPELL_FAILED_REAGENTS_GENERIC                = 28, // Missing reagent
-    EQUIP_ERR_NOT_ENOUGH_MONEY                             = 29, // You don't have enough money.
-    EQUIP_ERR_NOT_A_BAG                                    = 30, // Not a bag.
-    EQUIP_ERR_DESTROY_NONEMPTY_BAG                         = 31, // You can only do that with empty bags.
-    EQUIP_ERR_NOT_OWNER                                    = 32, // You don't own that item.
-    EQUIP_ERR_ONLY_ONE_QUIVER                              = 33, // You can only equip one quiver.
-    EQUIP_ERR_NO_BANK_SLOT                                 = 34, // You must purchase that bag slot first
-    EQUIP_ERR_NO_BANK_HERE                                 = 35, // You are too far away from a bank.
-    EQUIP_ERR_ITEM_LOCKED                                  = 36, // Item is locked.
-    EQUIP_ERR_GENERIC_STUNNED                              = 37, // You are stunned
-    EQUIP_ERR_PLAYER_DEAD                                  = 38, // You can't do that when you're dead.
-    EQUIP_ERR_CLIENT_LOCKED_OUT                            = 39, // You can't do that right now.
-    EQUIP_ERR_INTERNAL_BAG_ERROR                           = 40, // Internal Bag Error
-    EQUIP_ERR_ONLY_ONE_BOLT                                = 41, // You can only equip one quiver.
-    EQUIP_ERR_ONLY_ONE_AMMO                                = 42, // You can only equip one ammo pouch.
-    EQUIP_ERR_CANT_WRAP_STACKABLE                          = 43, // Stackable items can't be wrapped.
-    EQUIP_ERR_CANT_WRAP_EQUIPPED                           = 44, // Equipped items can't be wrapped.
-    EQUIP_ERR_CANT_WRAP_WRAPPED                            = 45, // Wrapped items can't be wrapped.
-    EQUIP_ERR_CANT_WRAP_BOUND                              = 46, // Bound items can't be wrapped.
-    EQUIP_ERR_CANT_WRAP_UNIQUE                             = 47, // Unique items can't be wrapped.
-    EQUIP_ERR_CANT_WRAP_BAGS                               = 48, // Bags can't be wrapped.
-    EQUIP_ERR_LOOT_GONE                                    = 49, // Already looted
-    EQUIP_ERR_INV_FULL                                     = 50, // Inventory is full.
-    EQUIP_ERR_BANK_FULL                                    = 51, // Your bank is full
-    EQUIP_ERR_VENDOR_SOLD_OUT                              = 52, // That item is currently sold out.
-    EQUIP_ERR_BAG_FULL_2                                   = 53, // That bag is full.
-    EQUIP_ERR_ITEM_NOT_FOUND_2                             = 54, // The item was not found.
-    EQUIP_ERR_CANT_STACK_2                                 = 55, // This item cannot stack.
-    EQUIP_ERR_BAG_FULL_3                                   = 56, // That bag is full.
-    EQUIP_ERR_VENDOR_SOLD_OUT_2                            = 57, // That item is currently sold out.
-    EQUIP_ERR_OBJECT_IS_BUSY                               = 58, // That object is busy.
-    EQUIP_ERR_CANT_BE_DISENCHANTED                         = 59,
-    EQUIP_ERR_NOT_IN_COMBAT                                = 60, // You can't do that while in combat
-    EQUIP_ERR_NOT_WHILE_DISARMED                           = 61, // You can't do that while disarmed
-    EQUIP_ERR_BAG_FULL_4                                   = 62, // That bag is full.
-    EQUIP_ERR_CANT_EQUIP_RANK                              = 63, // You don't have the required rank for that item
-    EQUIP_ERR_CANT_EQUIP_REPUTATION                        = 64, // You don't have the required reputation for that item
-    EQUIP_ERR_TOO_MANY_SPECIAL_BAGS                        = 65, // You cannot equip another bag of that type
-    EQUIP_ERR_LOOT_CANT_LOOT_THAT_NOW                      = 66, // You can't loot that item now.
-    EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE                       = 67, // You cannot equip more than one of those.
-    EQUIP_ERR_VENDOR_MISSING_TURNINS                       = 68, // You do not have the required items for that purchase
-    EQUIP_ERR_NOT_ENOUGH_HONOR_POINTS                      = 69, // You don't have enough honor points
-    EQUIP_ERR_NOT_ENOUGH_ARENA_POINTS                      = 70, // You don't have enough arena points
-    EQUIP_ERR_ITEM_MAX_COUNT_SOCKETED                      = 71, // You have the maximum number of those gems in your inventory or socketed into items.
-    EQUIP_ERR_MAIL_BOUND_ITEM                              = 72, // You can't mail soulbound items.
-    EQUIP_ERR_INTERNAL_BAG_ERROR_2                         = 73, // Internal Bag Error
-    EQUIP_ERR_BAG_FULL_5                                   = 74, // That bag is full.
-    EQUIP_ERR_ITEM_MAX_COUNT_EQUIPPED_SOCKETED             = 75, // You have the maximum number of those gems socketed into equipped items.
-    EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED              = 76, // You cannot socket more than one of those gems into a single item.
-    EQUIP_ERR_TOO_MUCH_GOLD                                = 77, // At gold limit
-    EQUIP_ERR_NOT_DURING_ARENA_MATCH                       = 78, // You can't do that while in an arena match
-    EQUIP_ERR_TRADE_BOUND_ITEM                             = 79, // You can't trade a soulbound item.
-    EQUIP_ERR_CANT_EQUIP_RATING                            = 80, // You don't have the personal, team, or battleground rating required to buy that item
-    EQUIP_ERR_EVENT_AUTOEQUIP_BIND_CONFIRM                 = 81,
-    EQUIP_ERR_NOT_SAME_ACCOUNT                             = 82, // Account-bound items can only be given to your own characters.
-    EQUIP_ERR_NO_OUTPUT                                    = 83,
-    EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS    = 84, // You can only carry %d %s
-    EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_SOCKETED_EXCEEDED_IS = 85, // You can only equip %d |4item:items in the %s category
-    EQUIP_ERR_SCALING_STAT_ITEM_LEVEL_EXCEEDED             = 86, // Your level is too high to use that item
-    EQUIP_ERR_PURCHASE_LEVEL_TOO_LOW                       = 87, // You must reach level %d to purchase that item.
-    EQUIP_ERR_CANT_EQUIP_NEED_TALENT                       = 88, // You do not have the required talent to equip that.
-    EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_EQUIPPED_EXCEEDED_IS = 89, // You can only equip %d |4item:items in the %s category
-    EQUIP_ERR_SHAPESHIFT_FORM_CANNOT_EQUIP                 = 90, // Cannot equip item in this form
-    EQUIP_ERR_ITEM_INVENTORY_FULL_SATCHEL                  = 91, // Your inventory is full. Your satchel has been delivered to your mailbox.
-    EQUIP_ERR_SCALING_STAT_ITEM_LEVEL_TOO_LOW              = 92, // Your level is too low to use that item
-    EQUIP_ERR_CANT_BUY_QUANTITY                            = 93, // You can't buy the specified quantity of that item.
-    EQUIP_ERR_ITEM_IS_BATTLE_PAY_LOCKED                    = 94, // Your purchased item is still waiting to be unlocked
-    EQUIP_ERR_REAGENT_BANK_FULL                            = 95, // Your reagent bank is full
-    EQUIP_ERR_REAGENT_BANK_LOCKED                          = 96,
-    EQUIP_ERR_WRONG_BAG_TYPE_3                             = 97,
-    EQUIP_ERR_CANT_USE_ITEM                                = 98, // You can't use that item.
-    EQUIP_ERR_CANT_BE_OBLITERATED                          = 99, // You can't obliterate that item
-    EQUIP_ERR_GUILD_BANK_CONJURED_ITEM                     = 100,// You cannot store conjured items in the guild bank
-    EQUIP_ERR_CANT_DO_THAT_RIGHT_NOW                       = 101,// You can't do that right now.
+    EQUIP_ERR_CANT_TRADE_GOLD                              = 29, // Gold may only be offered by one trader.
+    EQUIP_ERR_NOT_ENOUGH_MONEY                             = 30, // You don't have enough money.
+    EQUIP_ERR_NOT_A_BAG                                    = 31, // Not a bag.
+    EQUIP_ERR_DESTROY_NONEMPTY_BAG                         = 32, // You can only do that with empty bags.
+    EQUIP_ERR_NOT_OWNER                                    = 33, // You don't own that item.
+    EQUIP_ERR_ONLY_ONE_QUIVER                              = 34, // You can only equip one quiver.
+    EQUIP_ERR_NO_BANK_SLOT                                 = 35, // You must purchase that bag slot first
+    EQUIP_ERR_NO_BANK_HERE                                 = 36, // You are too far away from a bank.
+    EQUIP_ERR_ITEM_LOCKED                                  = 37, // Item is locked.
+    EQUIP_ERR_GENERIC_STUNNED                              = 38, // You are stunned
+    EQUIP_ERR_PLAYER_DEAD                                  = 39, // You can't do that when you're dead.
+    EQUIP_ERR_CLIENT_LOCKED_OUT                            = 40, // You can't do that right now.
+    EQUIP_ERR_INTERNAL_BAG_ERROR                           = 41, // Internal Bag Error
+    EQUIP_ERR_ONLY_ONE_BOLT                                = 42, // You can only equip one quiver.
+    EQUIP_ERR_ONLY_ONE_AMMO                                = 43, // You can only equip one ammo pouch.
+    EQUIP_ERR_CANT_WRAP_STACKABLE                          = 44, // Stackable items can't be wrapped.
+    EQUIP_ERR_CANT_WRAP_EQUIPPED                           = 45, // Equipped items can't be wrapped.
+    EQUIP_ERR_CANT_WRAP_WRAPPED                            = 46, // Wrapped items can't be wrapped.
+    EQUIP_ERR_CANT_WRAP_BOUND                              = 47, // Bound items can't be wrapped.
+    EQUIP_ERR_CANT_WRAP_UNIQUE                             = 48, // Unique items can't be wrapped.
+    EQUIP_ERR_CANT_WRAP_BAGS                               = 49, // Bags can't be wrapped.
+    EQUIP_ERR_LOOT_GONE                                    = 50, // Already looted
+    EQUIP_ERR_INV_FULL                                     = 51, // Inventory is full.
+    EQUIP_ERR_BANK_FULL                                    = 52, // Your bank is full
+    EQUIP_ERR_VENDOR_SOLD_OUT                              = 53, // That item is currently sold out.
+    EQUIP_ERR_BAG_FULL_2                                   = 54, // That bag is full.
+    EQUIP_ERR_ITEM_NOT_FOUND_2                             = 55, // The item was not found.
+    EQUIP_ERR_CANT_STACK_2                                 = 56, // This item cannot stack.
+    EQUIP_ERR_BAG_FULL_3                                   = 57, // That bag is full.
+    EQUIP_ERR_VENDOR_SOLD_OUT_2                            = 58, // That item is currently sold out.
+    EQUIP_ERR_OBJECT_IS_BUSY                               = 59, // That object is busy.
+    EQUIP_ERR_CANT_BE_DISENCHANTED                         = 60, // Item cannot be disenchanted
+    EQUIP_ERR_NOT_IN_COMBAT                                = 61, // You can't do that while in combat
+    EQUIP_ERR_NOT_WHILE_DISARMED                           = 62, // You can't do that while disarmed
+    EQUIP_ERR_BAG_FULL_4                                   = 63, // That bag is full.
+    EQUIP_ERR_CANT_EQUIP_RANK                              = 64, // You don't have the required rank for that item
+    EQUIP_ERR_CANT_EQUIP_REPUTATION                        = 65, // You don't have the required reputation for that item
+    EQUIP_ERR_TOO_MANY_SPECIAL_BAGS                        = 66, // You cannot equip another bag of that type
+    EQUIP_ERR_LOOT_CANT_LOOT_THAT_NOW                      = 67, // You can't loot that item now.
+    EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE                       = 68, // You cannot equip more than one of those.
+    EQUIP_ERR_VENDOR_MISSING_TURNINS                       = 69, // You do not have the required items for that purchase
+    EQUIP_ERR_NOT_ENOUGH_HONOR_POINTS                      = 70, // You don't have enough honor points
+    EQUIP_ERR_NOT_ENOUGH_ARENA_POINTS                      = 71, // You don't have enough arena points
+    EQUIP_ERR_ITEM_MAX_COUNT_SOCKETED                      = 72, // You have the maximum number of those gems in your inventory or socketed into items.
+    EQUIP_ERR_MAIL_BOUND_ITEM                              = 73, // You can't mail soulbound items.
+    EQUIP_ERR_INTERNAL_BAG_ERROR_2                         = 74, // Internal Bag Error
+    EQUIP_ERR_BAG_FULL_5                                   = 75, // That bag is full.
+    EQUIP_ERR_ITEM_MAX_COUNT_EQUIPPED_SOCKETED             = 76, // You have the maximum number of those gems socketed into equipped items.
+    EQUIP_ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED              = 77, // You cannot socket more than one of those gems into a single item.
+    EQUIP_ERR_TOO_MUCH_GOLD                                = 78, // At gold limit
+    EQUIP_ERR_NOT_DURING_ARENA_MATCH                       = 79, // You can't do that while in an arena match
+    EQUIP_ERR_TRADE_BOUND_ITEM                             = 80, // You can't trade a soulbound item.
+    EQUIP_ERR_CANT_EQUIP_RATING                            = 81, // You don't have the personal, team, or battleground rating required to buy that item
+    EQUIP_ERR_EVENT_AUTOEQUIP_BIND_CONFIRM                 = 82,
+    EQUIP_ERR_NOT_SAME_ACCOUNT                             = 83, // Account-bound items can only be given to your own characters.
+    EQUIP_NONE_3                                           = 84,
+    EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS    = 85, // You can only carry %d %s
+    EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_SOCKETED_EXCEEDED_IS = 86, // You can only equip %d |4item:items in the %s category
+    EQUIP_ERR_SCALING_STAT_ITEM_LEVEL_EXCEEDED             = 87, // Your level is too high to use that item
+    EQUIP_ERR_PURCHASE_LEVEL_TOO_LOW                       = 88, // You must reach level %d to purchase that item.
+    EQUIP_ERR_CANT_EQUIP_NEED_TALENT                       = 89, // You do not have the required talent to equip that.
+    EQUIP_ERR_ITEM_MAX_LIMIT_CATEGORY_EQUIPPED_EXCEEDED_IS = 90, // You can only equip %d |4item:items in the %s category
+    EQUIP_ERR_SHAPESHIFT_FORM_CANNOT_EQUIP                 = 91, // Cannot equip item in this form
+    EQUIP_ERR_ITEM_INVENTORY_FULL_SATCHEL                  = 92, // Your inventory is full. Your satchel has been delivered to your mailbox.
+    EQUIP_ERR_SCALING_STAT_ITEM_LEVEL_TOO_LOW              = 93, // Your level is too low to use that item
+    EQUIP_ERR_CANT_BUY_QUANTITY                            = 94, // You can't buy the specified quantity of that item.
+    EQUIP_ERR_ITEM_IS_BATTLE_PAY_LOCKED                    = 95, // Your purchased item is still waiting to be unlocked
+    EQUIP_ERR_REAGENT_BANK_FULL                            = 96, // Your reagent bank is full
+    EQUIP_ERR_REAGENT_BANK_LOCKED                          = 97,
+    EQUIP_ERR_WRONG_BAG_TYPE_3                             = 98, // That item doesn't go in that container.
+    EQUIP_ERR_CANT_USE_ITEM                                = 99, // You can't use that item.
+    EQUIP_ERR_CANT_BE_OBLITERATED                          = 100,// You can't obliterate that item
+    EQUIP_ERR_GUILD_BANK_CONJURED_ITEM                     = 101,// You cannot store conjured items in the guild bank
+    EQUIP_ERR_CANT_DO_THAT_RIGHT_NOW                       = 102,// You can't do that right now.
+    EQUIP_ERR_BAG_FULL_6                                   = 103,// That bag is full.
+    EQUIP_ERR_CANT_BE_SCRAPPED                             = 104,// You can't scrap that item
 };
 
 enum BuyResult
diff --git a/src/server/game/Entities/Item/ItemTemplate.cpp b/src/server/game/Entities/Item/ItemTemplate.cpp
index d541f70215d..abb4d47bfe8 100644
--- a/src/server/game/Entities/Item/ItemTemplate.cpp
+++ b/src/server/game/Entities/Item/ItemTemplate.cpp
@@ -21,7 +21,7 @@
 #include "ItemTemplate.h"
 #include "Player.h"
 
-uint32 const SocketColorToGemTypeMask[19] =
+int32 const SocketColorToGemTypeMask[19] =
 {
     0,
     SOCKET_COLOR_META,
@@ -241,7 +241,7 @@ bool ItemTemplate::IsUsableByLootSpecialization(Player const* player, bool alway
     if (GetFlags() & ITEM_FLAG_IS_BOUND_TO_ACCOUNT && alwaysAllowBoundToAccount)
         return true;
 
-    uint32 spec = player->GetUInt32Value(PLAYER_FIELD_LOOT_SPEC_ID);
+    uint32 spec = player->GetUInt32Value(ACTIVE_PLAYER_FIELD_LOOT_SPEC_ID);
     if (!spec)
         spec = player->GetUInt32Value(PLAYER_FIELD_CURRENT_SPEC_ID);
     if (!spec)
diff --git a/src/server/game/Entities/Item/ItemTemplate.h b/src/server/game/Entities/Item/ItemTemplate.h
index c5e83ff6bab..6e806f0c124 100644
--- a/src/server/game/Entities/Item/ItemTemplate.h
+++ b/src/server/game/Entities/Item/ItemTemplate.h
@@ -337,7 +337,7 @@ enum SocketColor
     SOCKET_COLOR_RELIC_HOLY                     = 0x10000
 };
 
-extern uint32 const SocketColorToGemTypeMask[19];
+extern int32 const SocketColorToGemTypeMask[19];
 
 #define SOCKET_COLOR_STANDARD (SOCKET_COLOR_RED | SOCKET_COLOR_YELLOW | SOCKET_COLOR_BLUE)
 
@@ -732,7 +732,6 @@ struct TC_GAME_API ItemTemplate
     uint32 GetMaxCount() const { return ExtendedData->MaxCount; }
     uint32 GetContainerSlots() const { return ExtendedData->ContainerSlots; }
     int32 GetItemStatType(uint32 index) const { ASSERT(index < MAX_ITEM_PROTO_STATS); return ExtendedData->StatModifierBonusStat[index]; }
-    int32 GetItemStatValue(uint32 index) const { ASSERT(index < MAX_ITEM_PROTO_STATS); return ExtendedData->ItemStatValue[index]; }
     int32 GetItemStatAllocation(uint32 index) const { ASSERT(index < MAX_ITEM_PROTO_STATS); return ExtendedData->StatPercentEditor[index]; }
     float GetItemStatSocketCostMultiplier(uint32 index) const { ASSERT(index < MAX_ITEM_PROTO_STATS); return ExtendedData->StatPercentageOfSocket[index]; }
     uint32 GetScalingStatDistribution() const { return ExtendedData->ScalingStatDistributionID; }
diff --git a/src/server/game/Entities/Object/Object.cpp b/src/server/game/Entities/Object/Object.cpp
index 47e07803819..2921ddf673f 100644
--- a/src/server/game/Entities/Object/Object.cpp
+++ b/src/server/game/Entities/Object/Object.cpp
@@ -55,7 +55,7 @@ Object::Object()
 {
     m_objectTypeId      = TYPEID_OBJECT;
     m_objectType        = TYPEMASK_OBJECT;
-    m_updateFlag        = UPDATEFLAG_NONE;
+    m_updateFlag.Clear();
 
     m_uint32Values      = nullptr;
     _dynamicValues      = nullptr;
@@ -130,7 +130,6 @@ void Object::_Create(ObjectGuid const& guid)
     if (!m_uint32Values) _InitValues();
 
     SetGuidValue(OBJECT_FIELD_GUID, guid);
-    SetUInt16Value(OBJECT_FIELD_TYPE, 0, m_objectType);
 }
 
 std::string Object::_ConcatFields(uint16 startIndex, uint16 size) const
@@ -171,12 +170,19 @@ void Object::BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target) c
     if (!target)
         return;
 
-    uint8  updateType = UPDATETYPE_CREATE_OBJECT;
-    uint32 flags      = m_updateFlag;
+    uint8 updateType = UPDATETYPE_CREATE_OBJECT;
+    uint8 objectType = m_objectTypeId;
+    uint16 objectTypeMask = m_objectType;
+    CreateObjectBits flags = m_updateFlag;
 
     /** lower flag1 **/
     if (target == this)                                      // building packet for yourself
-        flags |= UPDATEFLAG_SELF;
+    {
+        flags.ThisIsYou = true;
+        flags.ActivePlayer = true;
+        objectType = TYPEID_ACTIVE_PLAYER;
+        objectTypeMask |= TYPEMASK_ACTIVE_PLAYER;
+    }
 
     switch (GetGUID().GetHigh())
     {
@@ -209,15 +215,14 @@ void Object::BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target) c
 
     if (WorldObject const* worldObject = dynamic_cast<WorldObject const*>(this))
     {
-        if (!(flags & UPDATEFLAG_LIVING))
-            if (!worldObject->m_movementInfo.transport.guid.IsEmpty())
-                flags |= UPDATEFLAG_TRANSPORT_POSITION;
+        if (!flags.MovementUpdate && !worldObject->m_movementInfo.transport.guid.IsEmpty())
+            flags.MovementTransport = true;
 
         if (worldObject->GetAIAnimKitId() || worldObject->GetMovementAnimKitId() || worldObject->GetMeleeAnimKitId())
-            flags |= UPDATEFLAG_ANIMKITS;
+            flags.AnimKit = true;
     }
 
-    if (flags & UPDATEFLAG_STATIONARY_POSITION)
+    if (flags.Stationary)
     {
         // UPDATETYPE_CREATE_OBJECT2 for some gameobject types...
         if (isType(TYPEMASK_GAMEOBJECT))
@@ -238,12 +243,13 @@ void Object::BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target) c
 
     if (Unit const* unit = ToUnit())
         if (unit->GetVictim())
-            flags |= UPDATEFLAG_HAS_TARGET;
+            flags.CombatVictim = true;
 
     ByteBuffer buf(0x400);
     buf << uint8(updateType);
     buf << GetGUID();
-    buf << uint8(m_objectTypeId);
+    buf << uint8(objectType);
+    buf << uint32(objectTypeMask);
 
     BuildMovementUpdate(&buf, flags);
     BuildValuesUpdate(updateType, &buf, target);
@@ -338,25 +344,8 @@ ObjectGuid const& Object::GetGuidValue(uint16 index) const
     return *((ObjectGuid*)&(m_uint32Values[index]));
 }
 
-void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
-{
-    bool NoBirthAnim = false;
-    bool EnablePortals = false;
-    bool PlayHoverAnim = false;
-    bool HasMovementUpdate = (flags & UPDATEFLAG_LIVING) != 0;
-    bool HasMovementTransport = (flags & UPDATEFLAG_TRANSPORT_POSITION) != 0;
-    bool Stationary = (flags & UPDATEFLAG_STATIONARY_POSITION) != 0;
-    bool CombatVictim = (flags & UPDATEFLAG_HAS_TARGET) != 0;
-    bool ServerTime = (flags & UPDATEFLAG_TRANSPORT) != 0;
-    bool VehicleCreate = (flags & UPDATEFLAG_VEHICLE) != 0;
-    bool AnimKitCreate = (flags & UPDATEFLAG_ANIMKITS) != 0;
-    bool Rotation = (flags & UPDATEFLAG_ROTATION) != 0;
-    bool HasAreaTrigger = (flags & UPDATEFLAG_AREATRIGGER) != 0;
-    bool HasGameObject = (flags & UPDATEFLAG_GAMEOBJECT) != 0;
-    bool ThisIsYou = (flags & UPDATEFLAG_SELF) != 0;
-    bool SmoothPhasing = false;
-    bool SceneObjCreate = false;
-    bool PlayerCreateData = GetTypeId() == TYPEID_PLAYER && ToUnit()->GetPowerIndex(POWER_RUNES) != MAX_POWERS;
+void Object::BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags) const
+{
     std::vector<uint32> const* PauseTimes = nullptr;
     uint32 PauseTimesCount = 0;
     if (GameObject const* go = ToGameObject())
@@ -368,26 +357,27 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
         }
     }
 
-    data->WriteBit(NoBirthAnim);
-    data->WriteBit(EnablePortals);
-    data->WriteBit(PlayHoverAnim);
-    data->WriteBit(HasMovementUpdate);
-    data->WriteBit(HasMovementTransport);
-    data->WriteBit(Stationary);
-    data->WriteBit(CombatVictim);
-    data->WriteBit(ServerTime);
-    data->WriteBit(VehicleCreate);
-    data->WriteBit(AnimKitCreate);
-    data->WriteBit(Rotation);
-    data->WriteBit(HasAreaTrigger);
-    data->WriteBit(HasGameObject);
-    data->WriteBit(SmoothPhasing);
-    data->WriteBit(ThisIsYou);
-    data->WriteBit(SceneObjCreate);
-    data->WriteBit(PlayerCreateData);
+    data->WriteBit(flags.NoBirthAnim);
+    data->WriteBit(flags.EnablePortals);
+    data->WriteBit(flags.PlayHoverAnim);
+    data->WriteBit(flags.MovementUpdate);
+    data->WriteBit(flags.MovementTransport);
+    data->WriteBit(flags.Stationary);
+    data->WriteBit(flags.CombatVictim);
+    data->WriteBit(flags.ServerTime);
+    data->WriteBit(flags.Vehicle);
+    data->WriteBit(flags.AnimKit);
+    data->WriteBit(flags.Rotation);
+    data->WriteBit(flags.AreaTrigger);
+    data->WriteBit(flags.GameObject);
+    data->WriteBit(flags.SmoothPhasing);
+    data->WriteBit(flags.ThisIsYou);
+    data->WriteBit(flags.SceneObject);
+    data->WriteBit(flags.ActivePlayer);
+    data->WriteBit(flags.Conversation);
     data->FlushBits();
 
-    if (HasMovementUpdate)
+    if (flags.MovementUpdate)
     {
         Unit const* unit = ToUnit();
         bool HasFallDirection = unit->HasUnitMovementFlag(MOVEMENTFLAG_FALLING);
@@ -458,6 +448,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
         //    *data << uint32(TransportID);
         //    *data << float(Magnitude);
         //    data->WriteBits(Type, 2);
+        //    data->FlushBits();
         //}
 
         if (HasSpline)
@@ -466,7 +457,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
 
     *data << uint32(PauseTimesCount);
 
-    if (Stationary)
+    if (flags.Stationary)
     {
         WorldObject const* self = static_cast<WorldObject const*>(this);
         *data << float(self->GetStationaryX());
@@ -475,10 +466,10 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
         *data << float(self->GetStationaryO());
     }
 
-    if (CombatVictim)
+    if (flags.CombatVictim)
         *data << ToUnit()->GetVictim()->GetGUID();                      // CombatVictim
 
-    if (ServerTime)
+    if (flags.ServerTime)
     {
         GameObject const* go = ToGameObject();
         /** @TODO Use IsTransport() to also handle type 11 (TRANSPORT)
@@ -492,14 +483,14 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
             *data << uint32(getMSTime());
     }
 
-    if (VehicleCreate)
+    if (flags.Vehicle)
     {
         Unit const* unit = ToUnit();
         *data << uint32(unit->GetVehicleKit()->GetVehicleInfo()->ID); // RecID
         *data << float(unit->GetOrientation());                         // InitialRawFacing
     }
 
-    if (AnimKitCreate)
+    if (flags.AnimKit)
     {
         WorldObject const* self = static_cast<WorldObject const*>(this);
         *data << uint16(self->GetAIAnimKitId());                        // AiID
@@ -507,19 +498,19 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
         *data << uint16(self->GetMeleeAnimKitId());                     // MeleeID
     }
 
-    if (Rotation)
+    if (flags.Rotation)
         *data << uint64(ToGameObject()->GetPackedWorldRotation());      // Rotation
 
     if (PauseTimesCount)
         data->append(PauseTimes->data(), PauseTimes->size());
 
-    if (HasMovementTransport)
+    if (flags.MovementTransport)
     {
         WorldObject const* self = static_cast<WorldObject const*>(this);
         *data << self->m_movementInfo.transport;
     }
 
-    if (HasAreaTrigger)
+    if (flags.AreaTrigger)
     {
         AreaTrigger const* areaTrigger = ToAreaTrigger();
         AreaTriggerMiscTemplate const* areaTriggerMiscTemplate = areaTrigger->GetMiscTemplate();
@@ -540,9 +531,10 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
         bool hasMorphCurveID        = areaTriggerMiscTemplate->MorphCurveId != 0;
         bool hasFacingCurveID       = areaTriggerMiscTemplate->FacingCurveId != 0;
         bool hasMoveCurveID         = areaTriggerMiscTemplate->MoveCurveId != 0;
-        bool hasUnk2                = areaTriggerTemplate->HasFlag(AREATRIGGER_FLAG_UNK2);
+        bool hasAnimation           = areaTriggerTemplate->HasFlag(AREATRIGGER_FLAG_HAS_ANIM_ID);
         bool hasUnk3                = areaTriggerTemplate->HasFlag(AREATRIGGER_FLAG_UNK3);
-        bool hasUnk4                = areaTriggerTemplate->HasFlag(AREATRIGGER_FLAG_UNK4);
+        bool hasAnimKitID           = areaTriggerTemplate->HasFlag(AREATRIGGER_FLAG_HAS_ANIM_KIT_ID);
+        bool hasAnimProgress        = false;
         bool hasAreaTriggerSphere   = areaTriggerTemplate->IsSphere();
         bool hasAreaTriggerBox      = areaTriggerTemplate->IsBox();
         bool hasAreaTriggerPolygon  = areaTriggerTemplate->IsPolygon();
@@ -561,9 +553,10 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
         data->WriteBit(hasMorphCurveID);
         data->WriteBit(hasFacingCurveID);
         data->WriteBit(hasMoveCurveID);
-        data->WriteBit(hasUnk2);
+        data->WriteBit(hasAnimation);
+        data->WriteBit(hasAnimKitID);
         data->WriteBit(hasUnk3);
-        data->WriteBit(hasUnk4);
+        data->WriteBit(hasAnimProgress);
         data->WriteBit(hasAreaTriggerSphere);
         data->WriteBit(hasAreaTriggerBox);
         data->WriteBit(hasAreaTriggerPolygon);
@@ -599,10 +592,13 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
         if (hasMoveCurveID)
             *data << uint32(areaTriggerMiscTemplate->MoveCurveId);
 
-        if (hasUnk2)
-            *data << int32(0);
+        if (hasAnimation)
+            *data << int32(areaTriggerMiscTemplate->AnimId);
+
+        if (hasAnimKitID)
+            *data << int32(areaTriggerMiscTemplate->AnimKitId);
 
-        if (hasUnk4)
+        if (hasAnimProgress)
             *data << uint32(0);
 
         if (hasAreaTriggerSphere)
@@ -649,7 +645,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
             *data << *areaTrigger->GetCircularMovementInfo();
     }
 
-    if (HasGameObject)
+    if (flags.GameObject)
     {
         bool bit8 = false;
         uint32 Int1 = 0;
@@ -664,7 +660,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
             *data << uint32(Int1);
     }
 
-    //if (SmoothPhasing)
+    //if (flags.SmoothPhasing)
     //{
     //    data->WriteBit(ReplaceActive);
     //    data->WriteBit(HasReplaceObject);
@@ -673,7 +669,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
     //        *data << ObjectGuid(ReplaceObject);
     //}
 
-    //if (SceneObjCreate)
+    //if (flags.SceneObject)
     //{
     //    data->WriteBit(HasLocalScriptData);
     //    data->WriteBit(HasPetBattleFullUpdate);
@@ -783,7 +779,7 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
     //    }
     //}
 
-    if (PlayerCreateData)
+    if (flags.ActivePlayer)
     {
         bool HasSceneInstanceIDs = false;
         bool HasRuneState = ToUnit()->GetPowerIndex(POWER_RUNES) != MAX_POWERS;
@@ -810,6 +806,15 @@ void Object::BuildMovementUpdate(ByteBuffer* data, uint32 flags) const
                 *data << uint8((baseCd - float(player->GetRuneCooldown(i))) / baseCd * 255);
         }
     }
+
+    if (flags.Conversation)
+    {
+        Conversation const* self = ToConversation();
+        if (data->WriteBit(self->GetTextureKitId() != 0))
+            *data << uint32(self->GetTextureKitId());
+
+        data->FlushBits();
+    }
 }
 
 void Object::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target) const
@@ -843,7 +848,11 @@ void Object::BuildDynamicValuesUpdate(uint8 updateType, ByteBuffer* data, Player
     if (!target)
         return;
 
-    std::size_t blockCount = UpdateMask::GetBlockCount(_dynamicValuesCount);
+    std::size_t valueCount = _dynamicValuesCount;
+    if (target != this && GetTypeId() == TYPEID_PLAYER)
+        valueCount = PLAYER_DYNAMIC_END;
+
+    std::size_t blockCount = UpdateMask::GetBlockCount(valueCount);
 
     uint32* flags = nullptr;
     uint32 visibleFlag = GetDynamicUpdateFieldData(target, flags);
@@ -852,7 +861,7 @@ void Object::BuildDynamicValuesUpdate(uint8 updateType, ByteBuffer* data, Player
     std::size_t maskPos = data->wpos();
     data->resize(data->size() + blockCount * sizeof(UpdateMask::BlockType));
 
-    for (uint16 index = 0; index < _dynamicValuesCount; ++index)
+    for (uint16 index = 0; index < valueCount; ++index)
     {
         std::vector<uint32> const& values = _dynamicValues[index];
         if (_fieldNotifyFlags & flags[index] ||
@@ -928,7 +937,17 @@ uint32 Object::GetUpdateFieldData(Player const* target, uint32*& flags) const
     {
         case TYPEID_ITEM:
         case TYPEID_CONTAINER:
-            flags = ItemUpdateFieldFlags;
+            flags = ContainerUpdateFieldFlags;
+            if (((Item const*)this)->GetOwnerGUID() == target->GetGUID())
+                visibleFlag |= UF_FLAG_OWNER | UF_FLAG_ITEM_OWNER;
+            break;
+        case TYPEID_AZERITE_EMPOWERED_ITEM:
+            flags = AzeriteEmpoweredItemUpdateFieldFlags;
+            if (((Item const*)this)->GetOwnerGUID() == target->GetGUID())
+                visibleFlag |= UF_FLAG_OWNER | UF_FLAG_ITEM_OWNER;
+            break;
+        case TYPEID_AZERITE_ITEM:
+            flags = AzeriteItemUpdateFieldFlags;
             if (((Item const*)this)->GetOwnerGUID() == target->GetGUID())
                 visibleFlag |= UF_FLAG_OWNER | UF_FLAG_ITEM_OWNER;
             break;
@@ -973,6 +992,7 @@ uint32 Object::GetUpdateFieldData(Player const* target, uint32*& flags) const
             flags = ConversationUpdateFieldFlags;
             break;
         case TYPEID_OBJECT:
+        case TYPEID_ACTIVE_PLAYER:
             ABORT();
             break;
     }
@@ -991,6 +1011,8 @@ uint32 Object::GetDynamicUpdateFieldData(Player const* target, uint32*& flags) c
     {
         case TYPEID_ITEM:
         case TYPEID_CONTAINER:
+        case TYPEID_AZERITE_EMPOWERED_ITEM:
+        case TYPEID_AZERITE_ITEM:
             flags = ItemDynamicUpdateFieldFlags;
             if (((Item const*)this)->GetOwnerGUID() == target->GetGUID())
                 visibleFlag |= UF_FLAG_OWNER | UF_FLAG_ITEM_OWNER;
@@ -2983,7 +3005,7 @@ struct WorldObjectChangeAccumulator
             {
                 //Caster may be NULL if DynObj is in removelist
                 if (Player* caster = ObjectAccessor::FindPlayer(guid))
-                    if (caster->GetGuidValue(PLAYER_FARSIGHT) == source->GetGUID())
+                    if (caster->GetGuidValue(ACTIVE_PLAYER_FIELD_FARSIGHT) == source->GetGUID())
                         BuildPacket(caster);
             }
         }
diff --git a/src/server/game/Entities/Object/Object.h b/src/server/game/Entities/Object/Object.h
index 7823a2a2a68..17979a441a8 100644
--- a/src/server/game/Entities/Object/Object.h
+++ b/src/server/game/Entities/Object/Object.h
@@ -55,6 +55,33 @@ struct QuaternionData;
 
 typedef std::unordered_map<Player*, UpdateData> UpdateDataMapType;
 
+struct CreateObjectBits
+{
+    bool NoBirthAnim : 1;
+    bool EnablePortals : 1;
+    bool PlayHoverAnim : 1;
+    bool MovementUpdate : 1;
+    bool MovementTransport : 1;
+    bool Stationary : 1;
+    bool CombatVictim : 1;
+    bool ServerTime : 1;
+    bool Vehicle : 1;
+    bool AnimKit : 1;
+    bool Rotation : 1;
+    bool AreaTrigger : 1;
+    bool GameObject : 1;
+    bool SmoothPhasing : 1;
+    bool ThisIsYou : 1;
+    bool SceneObject : 1;
+    bool ActivePlayer : 1;
+    bool Conversation : 1;
+
+    void Clear()
+    {
+        memset(this, 0, sizeof(CreateObjectBits));
+    }
+};
+
 namespace UpdateMask
 {
     typedef uint32 BlockType;
@@ -299,14 +326,14 @@ class TC_GAME_API Object
         uint32 GetUpdateFieldData(Player const* target, uint32*& flags) const;
         uint32 GetDynamicUpdateFieldData(Player const* target, uint32*& flags) const;
 
-        void BuildMovementUpdate(ByteBuffer* data, uint32 flags) const;
+        void BuildMovementUpdate(ByteBuffer* data, CreateObjectBits flags) const;
         virtual void BuildValuesUpdate(uint8 updatetype, ByteBuffer* data, Player* target) const;
         virtual void BuildDynamicValuesUpdate(uint8 updatetype, ByteBuffer* data, Player* target) const;
 
         uint16 m_objectType;
 
         TypeID m_objectTypeId;
-        uint32 m_updateFlag;
+        CreateObjectBits m_updateFlag;
 
         union
         {
diff --git a/src/server/game/Entities/Object/ObjectGuid.cpp b/src/server/game/Entities/Object/ObjectGuid.cpp
index d5094aea2b0..f8ee803ed22 100644
--- a/src/server/game/Entities/Object/ObjectGuid.cpp
+++ b/src/server/game/Entities/Object/ObjectGuid.cpp
@@ -87,6 +87,7 @@ namespace
         SET_GUID_NAME(CommerceObj);
         SET_GUID_NAME(ClientSession);
         SET_GUID_NAME(Cast);
+        SET_GUID_NAME(ClientConnection);
 
 #undef SET_GUID_NAME
     }
diff --git a/src/server/game/Entities/Object/ObjectGuid.h b/src/server/game/Entities/Object/ObjectGuid.h
index 941608f9493..0584c0d7262 100644
--- a/src/server/game/Entities/Object/ObjectGuid.h
+++ b/src/server/game/Entities/Object/ObjectGuid.h
@@ -30,35 +30,41 @@
 
 enum TypeID
 {
-    TYPEID_OBJECT        = 0,
-    TYPEID_ITEM          = 1,
-    TYPEID_CONTAINER     = 2,
-    TYPEID_UNIT          = 3,
-    TYPEID_PLAYER        = 4,
-    TYPEID_GAMEOBJECT    = 5,
-    TYPEID_DYNAMICOBJECT = 6,
-    TYPEID_CORPSE        = 7,
-    TYPEID_AREATRIGGER   = 8,
-    TYPEID_SCENEOBJECT   = 9,
-    TYPEID_CONVERSATION  = 10
+    TYPEID_OBJECT                 = 0,
+    TYPEID_ITEM                   = 1,
+    TYPEID_CONTAINER              = 2,
+    TYPEID_AZERITE_EMPOWERED_ITEM = 3,
+    TYPEID_AZERITE_ITEM           = 4,
+    TYPEID_UNIT                   = 5,
+    TYPEID_PLAYER                 = 6,
+    TYPEID_ACTIVE_PLAYER          = 7,
+    TYPEID_GAMEOBJECT             = 8,
+    TYPEID_DYNAMICOBJECT          = 9,
+    TYPEID_CORPSE                 = 10,
+    TYPEID_AREATRIGGER            = 11,
+    TYPEID_SCENEOBJECT            = 12,
+    TYPEID_CONVERSATION           = 13
 };
 
-#define NUM_CLIENT_OBJECT_TYPES             11
+#define NUM_CLIENT_OBJECT_TYPES             14
 
 enum TypeMask
 {
-    TYPEMASK_OBJECT         = 0x0001,
-    TYPEMASK_ITEM           = 0x0002,
-    TYPEMASK_CONTAINER      = 0x0004,
-    TYPEMASK_UNIT           = 0x0008,
-    TYPEMASK_PLAYER         = 0x0010,
-    TYPEMASK_GAMEOBJECT     = 0x0020,
-    TYPEMASK_DYNAMICOBJECT  = 0x0040,
-    TYPEMASK_CORPSE         = 0x0080,
-    TYPEMASK_AREATRIGGER    = 0x0100,
-    TYPEMASK_SCENEOBJECT    = 0x0200,
-    TYPEMASK_CONVERSATION   = 0x0400,
-    TYPEMASK_SEER           = TYPEMASK_PLAYER | TYPEMASK_UNIT | TYPEMASK_DYNAMICOBJECT
+    TYPEMASK_OBJECT                 = 0x0001,
+    TYPEMASK_ITEM                   = 0x0002,
+    TYPEMASK_CONTAINER              = 0x0004,
+    TYPEMASK_AZERITE_EMPOWERED_ITEM = 0x0008,
+    TYPEMASK_AZERITE_ITEM           = 0x0010,
+    TYPEMASK_UNIT                   = 0x0020,
+    TYPEMASK_PLAYER                 = 0x0040,
+    TYPEMASK_ACTIVE_PLAYER          = 0x0080,
+    TYPEMASK_GAMEOBJECT             = 0x0100,
+    TYPEMASK_DYNAMICOBJECT          = 0x0200,
+    TYPEMASK_CORPSE                 = 0x0400,
+    TYPEMASK_AREATRIGGER            = 0x0800,
+    TYPEMASK_SCENEOBJECT            = 0x1000,
+    TYPEMASK_CONVERSATION           = 0x2000,
+    TYPEMASK_SEER                   = TYPEMASK_PLAYER | TYPEMASK_UNIT | TYPEMASK_DYNAMICOBJECT
 };
 
 enum class HighGuid
@@ -111,6 +117,7 @@ enum class HighGuid
     CommerceObj      = 45,
     ClientSession    = 46,
     Cast             = 47,
+    ClientConnection = 48,
 
     Count,
 };
@@ -349,6 +356,7 @@ class TC_GAME_API ObjectGuidGeneratorBase
 {
 public:
     ObjectGuidGeneratorBase(ObjectGuid::LowType start = UI64LIT(1)) : _nextGuid(start) { }
+    virtual ~ObjectGuidGeneratorBase() { }
 
     virtual void Set(uint64 val) { _nextGuid = val; }
     virtual ObjectGuid::LowType Generate() = 0;
diff --git a/src/server/game/Entities/Object/Updates/UpdateData.h b/src/server/game/Entities/Object/Updates/UpdateData.h
index 800948c4281..9d438ed625e 100644
--- a/src/server/game/Entities/Object/Updates/UpdateData.h
+++ b/src/server/game/Entities/Object/Updates/UpdateData.h
@@ -34,29 +34,6 @@ enum OBJECT_UPDATE_TYPE
     UPDATETYPE_OUT_OF_RANGE_OBJECTS = 3,
 };
 
-enum OBJECT_UPDATE_FLAGS
-{
-    UPDATEFLAG_NONE                  = 0x0000,
-    UPDATEFLAG_SELF                  = 0x0001,
-    UPDATEFLAG_TRANSPORT             = 0x0002,
-    UPDATEFLAG_HAS_TARGET            = 0x0004,
-    UPDATEFLAG_LIVING                = 0x0008,
-    UPDATEFLAG_STATIONARY_POSITION   = 0x0010,
-    UPDATEFLAG_VEHICLE               = 0x0020,
-    UPDATEFLAG_TRANSPORT_POSITION    = 0x0040,
-    UPDATEFLAG_ROTATION              = 0x0080,
-    UPDATEFLAG_ANIMKITS              = 0x0100,
-    UPDATEFLAG_AREATRIGGER           = 0x0200,
-    UPDATEFLAG_GAMEOBJECT            = 0x0400,
-    //UPDATEFLAG_REPLACE_ACTIVE        = 0x0800,
-    //UPDATEFLAG_NO_BIRTH_ANIM         = 0x1000,
-    //UPDATEFLAG_ENABLE_PORTALS        = 0x2000,
-    //UPDATEFLAG_PLAY_HOVER_ANIM       = 0x4000,
-    //UPDATEFLAG_IS_SUPPRESSING_GREETINGS = 0x8000
-    //UPDATEFLAG_SCENEOBJECT           = 0x10000,
-    //UPDATEFLAG_SCENE_PENDING_INSTANCE = 0x20000
-};
-
 class UpdateData
 {
     public:
diff --git a/src/server/game/Entities/Object/Updates/UpdateFieldFlags.cpp b/src/server/game/Entities/Object/Updates/UpdateFieldFlags.cpp
index 9a26e2a8c53..350c64d3c7b 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFieldFlags.cpp
+++ b/src/server/game/Entities/Object/Updates/UpdateFieldFlags.cpp
@@ -17,17 +17,12 @@
 
 #include "UpdateFieldFlags.h"
 
-uint32 ItemUpdateFieldFlags[CONTAINER_END] =
+uint32 ContainerUpdateFieldFlags[CONTAINER_END] =
 {
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+1
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+2
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_TYPE
     UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
@@ -251,26 +246,198 @@ uint32 ItemUpdateFieldFlags[CONTAINER_END] =
     UF_FLAG_PUBLIC,                                         // CONTAINER_FIELD_NUM_SLOTS
 };
 
-uint32 ItemDynamicUpdateFieldFlags[CONTAINER_DYNAMIC_END] =
+uint32 AzeriteEmpoweredItemUpdateFieldFlags[AZERITE_EMPOWERED_ITEM_END] =
+{
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
+    UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
+    UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_OWNER
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_OWNER+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_OWNER+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_OWNER+3
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTAINED
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTAINED+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTAINED+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTAINED+3
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATOR
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATOR+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATOR+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATOR+3
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_GIFTCREATOR
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_GIFTCREATOR+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_GIFTCREATOR+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_GIFTCREATOR+3
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_STACK_COUNT
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_DURATION
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES+1
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES+2
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES+3
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES+4
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_FLAGS
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+3
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+4
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+5
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+6
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+7
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+8
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+9
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+10
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+11
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+12
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+13
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+14
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+15
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+16
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+17
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+18
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+19
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+20
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+21
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+22
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+23
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+24
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+25
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+26
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+27
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+28
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+29
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+30
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+31
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+32
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+33
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+34
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+35
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+36
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+37
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+38
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_PROPERTY_SEED
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_RANDOM_PROPERTIES_ID
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_DURABILITY
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_MAXDURABILITY
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATE_PLAYED_TIME
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_MODIFIERS_MASK
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTEXT
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_ARTIFACT_XP
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_ARTIFACT_XP+1
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_APPEARANCE_MOD_ID
+    UF_FLAG_PUBLIC,                                         // AZERITE_EMPOWERED_ITEM_FIELD_SELECTIONS
+    UF_FLAG_PUBLIC,                                         // AZERITE_EMPOWERED_ITEM_FIELD_SELECTIONS+1
+    UF_FLAG_PUBLIC,                                         // AZERITE_EMPOWERED_ITEM_FIELD_SELECTIONS+2
+    UF_FLAG_PUBLIC,                                         // AZERITE_EMPOWERED_ITEM_FIELD_SELECTIONS+3
+};
+
+uint32 AzeriteItemUpdateFieldFlags[AZERITE_ITEM_END] =
+{
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
+    UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
+    UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
+    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_OWNER
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_OWNER+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_OWNER+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_OWNER+3
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTAINED
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTAINED+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTAINED+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTAINED+3
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATOR
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATOR+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATOR+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATOR+3
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_GIFTCREATOR
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_GIFTCREATOR+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_GIFTCREATOR+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_GIFTCREATOR+3
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_STACK_COUNT
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_DURATION
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES+1
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES+2
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES+3
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_SPELL_CHARGES+4
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_FLAGS
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+1
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+2
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+3
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+4
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+5
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+6
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+7
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+8
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+9
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+10
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+11
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+12
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+13
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+14
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+15
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+16
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+17
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+18
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+19
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+20
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+21
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+22
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+23
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+24
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+25
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+26
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+27
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+28
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+29
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+30
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+31
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+32
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+33
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+34
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+35
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+36
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+37
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_ENCHANTMENT+38
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_PROPERTY_SEED
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_RANDOM_PROPERTIES_ID
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_DURABILITY
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_MAXDURABILITY
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CREATE_PLAYED_TIME
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_MODIFIERS_MASK
+    UF_FLAG_PUBLIC,                                         // ITEM_FIELD_CONTEXT
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_ARTIFACT_XP
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_ARTIFACT_XP+1
+    UF_FLAG_OWNER,                                          // ITEM_FIELD_APPEARANCE_MOD_ID
+    UF_FLAG_PUBLIC,                                         // AZERITE_ITEM_FIELD_XP
+    UF_FLAG_PUBLIC,                                         // AZERITE_ITEM_FIELD_XP+1
+    UF_FLAG_PUBLIC,                                         // AZERITE_ITEM_FIELD_LEVEL
+    UF_FLAG_PUBLIC,                                         // AZERITE_ITEM_FIELD_AURA_LEVEL
+    UF_FLAG_OWNER,                                          // AZERITE_ITEM_FIELD_KNOWLEDGE_LEVEL
+    UF_FLAG_OWNER,                                          // AZERITE_ITEM_FIELD_DEBUG_KNOWLEDGE_WEEK
+};
+
+uint32 ItemDynamicUpdateFieldFlags[ITEM_DYNAMIC_END] =
 {
     UF_FLAG_OWNER,                                          // ITEM_DYNAMIC_FIELD_MODIFIERS
     UF_FLAG_OWNER | UF_FLAG_0x100,                          // ITEM_DYNAMIC_FIELD_BONUSLIST_IDS
     UF_FLAG_OWNER,                                          // ITEM_DYNAMIC_FIELD_ARTIFACT_POWERS
     UF_FLAG_OWNER,                                          // ITEM_DYNAMIC_FIELD_GEMS
-    UF_FLAG_OWNER,                                          // ITEM_DYNAMIC_FIELD_RELIC_TALENT_DATA
 };
 
-uint32 UnitUpdateFieldFlags[PLAYER_END] =
+uint32 UnitUpdateFieldFlags[ACTIVE_PLAYER_END] =
 {
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+1
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+2
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_TYPE
     UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
@@ -302,6 +469,10 @@ uint32 UnitUpdateFieldFlags[PLAYER_END] =
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_DEMON_CREATOR+1
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_DEMON_CREATOR+2
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_DEMON_CREATOR+3
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET+1
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET+2
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET+3
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_TARGET
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_TARGET+1
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_TARGET+2
@@ -348,10 +519,13 @@ uint32 UnitUpdateFieldFlags[PLAYER_END] =
     UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_UNIT_ALL,     // UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER+5
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LEVEL
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_EFFECTIVE_LEVEL
-    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_SANDBOX_SCALING_ID
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_CONTENT_TUNING_ID
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_SCALING_LEVEL_MIN
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_SCALING_LEVEL_MAX
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_SCALING_LEVEL_DELTA
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_SCALING_FACTION_GROUP
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_SCALING_HEALTH_ITEM_LEVEL_CURVE_ID
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_SCALING_DAMAGE_ITEM_LEVEL_CURVE_ID
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_FACTIONTEMPLATE
     UF_FLAG_PUBLIC,                                         // UNIT_VIRTUAL_ITEM_SLOT_ID
     UF_FLAG_PUBLIC,                                         // UNIT_VIRTUAL_ITEM_SLOT_ID+1
@@ -369,7 +543,9 @@ uint32 UnitUpdateFieldFlags[PLAYER_END] =
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_BOUNDINGRADIUS
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_COMBATREACH
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // UNIT_FIELD_DISPLAYID
+    UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // UNIT_FIELD_DISPLAY_SCALE
     UF_FLAG_PUBLIC | UF_FLAG_URGENT,                        // UNIT_FIELD_NATIVEDISPLAYID
+    UF_FLAG_PUBLIC | UF_FLAG_URGENT,                        // UNIT_FIELD_NATIVE_X_DISPLAY_SCALE
     UF_FLAG_PUBLIC | UF_FLAG_URGENT,                        // UNIT_FIELD_MOUNTDISPLAYID
     UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_SPECIAL_INFO, // UNIT_FIELD_MINDAMAGE
     UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_SPECIAL_INFO, // UNIT_FIELD_MAXDAMAGE
@@ -409,21 +585,13 @@ uint32 UnitUpdateFieldFlags[PLAYER_END] =
     UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_SPECIAL_INFO, // UNIT_FIELD_RESISTANCES+4
     UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_SPECIAL_INFO, // UNIT_FIELD_RESISTANCES+5
     UF_FLAG_PRIVATE | UF_FLAG_OWNER | UF_FLAG_SPECIAL_INFO, // UNIT_FIELD_RESISTANCES+6
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+1
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+2
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+3
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+4
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+5
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+6
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+1
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+2
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+3
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+4
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+5
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+6
-    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_MOD_BONUS_ARMOR
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_BONUS_RESISTANCE_MODS
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_BONUS_RESISTANCE_MODS+1
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_BONUS_RESISTANCE_MODS+2
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_BONUS_RESISTANCE_MODS+3
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_BONUS_RESISTANCE_MODS+4
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_BONUS_RESISTANCE_MODS+5
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_BONUS_RESISTANCE_MODS+6
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_BASE_MANA
     UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_BASE_HEALTH
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_BYTES_2
@@ -435,7 +603,11 @@ uint32 UnitUpdateFieldFlags[PLAYER_END] =
     UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS
     UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RANGED_ATTACK_POWER_MOD_NEG
     UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_MAIN_HAND_WEAPON_ATTACK_POWER
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_OFF_HAND_WEAPON_ATTACK_POWER
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_RANGED_HAND_WEAPON_ATTACK_POWER
     UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_ATTACK_SPEED_AURA
+    UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_LIFESTEAL
     UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_MINRANGEDDAMAGE
     UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_MAXRANGEDDAMAGE
     UF_FLAG_PRIVATE | UF_FLAG_OWNER,                        // UNIT_FIELD_POWER_COST_MODIFIER
@@ -471,10 +643,10 @@ uint32 UnitUpdateFieldFlags[PLAYER_END] =
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOKS_LIKE_MOUNT_ID
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOKS_LIKE_CREATURE_ID
     UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOK_AT_CONTROLLER_ID
-    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET
-    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET+1
-    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET+2
-    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET+3
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_GUILD_GUID
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_GUILD_GUID+1
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_GUILD_GUID+2
+    UF_FLAG_PUBLIC,                                         // UNIT_FIELD_GUILD_GUID+3
     UF_FLAG_PUBLIC,                                         // PLAYER_DUEL_ARBITER
     UF_FLAG_PUBLIC,                                         // PLAYER_DUEL_ARBITER+1
     UF_FLAG_PUBLIC,                                         // PLAYER_DUEL_ARBITER+2
@@ -1298,6 +1470,806 @@ uint32 UnitUpdateFieldFlags[PLAYER_END] =
     UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+797
     UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+798
     UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+799
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+800
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+801
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+802
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+803
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+804
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+805
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+806
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+807
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+808
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+809
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+810
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+811
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+812
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+813
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+814
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+815
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+816
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+817
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+818
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+819
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+820
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+821
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+822
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+823
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+824
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+825
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+826
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+827
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+828
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+829
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+830
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+831
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+832
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+833
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+834
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+835
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+836
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+837
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+838
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+839
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+840
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+841
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+842
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+843
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+844
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+845
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+846
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+847
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+848
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+849
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+850
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+851
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+852
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+853
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+854
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+855
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+856
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+857
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+858
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+859
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+860
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+861
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+862
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+863
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+864
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+865
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+866
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+867
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+868
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+869
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+870
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+871
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+872
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+873
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+874
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+875
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+876
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+877
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+878
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+879
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+880
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+881
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+882
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+883
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+884
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+885
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+886
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+887
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+888
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+889
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+890
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+891
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+892
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+893
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+894
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+895
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+896
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+897
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+898
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+899
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+900
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+901
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+902
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+903
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+904
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+905
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+906
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+907
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+908
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+909
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+910
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+911
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+912
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+913
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+914
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+915
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+916
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+917
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+918
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+919
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+920
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+921
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+922
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+923
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+924
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+925
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+926
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+927
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+928
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+929
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+930
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+931
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+932
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+933
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+934
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+935
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+936
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+937
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+938
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+939
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+940
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+941
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+942
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+943
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+944
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+945
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+946
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+947
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+948
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+949
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+950
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+951
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+952
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+953
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+954
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+955
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+956
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+957
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+958
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+959
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+960
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+961
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+962
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+963
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+964
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+965
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+966
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+967
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+968
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+969
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+970
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+971
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+972
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+973
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+974
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+975
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+976
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+977
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+978
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+979
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+980
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+981
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+982
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+983
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+984
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+985
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+986
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+987
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+988
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+989
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+990
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+991
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+992
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+993
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+994
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+995
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+996
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+997
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+998
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+999
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1000
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1001
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1002
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1003
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1004
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1005
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1006
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1007
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1008
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1009
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1010
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1011
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1012
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1013
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1014
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1015
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1016
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1017
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1018
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1019
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1020
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1021
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1022
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1023
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1024
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1025
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1026
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1027
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1028
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1029
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1030
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1031
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1032
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1033
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1034
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1035
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1036
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1037
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1038
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1039
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1040
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1041
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1042
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1043
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1044
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1045
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1046
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1047
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1048
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1049
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1050
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1051
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1052
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1053
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1054
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1055
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1056
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1057
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1058
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1059
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1060
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1061
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1062
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1063
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1064
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1065
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1066
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1067
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1068
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1069
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1070
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1071
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1072
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1073
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1074
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1075
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1076
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1077
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1078
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1079
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1080
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1081
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1082
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1083
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1084
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1085
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1086
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1087
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1088
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1089
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1090
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1091
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1092
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1093
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1094
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1095
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1096
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1097
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1098
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1099
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1100
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1101
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1102
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1103
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1104
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1105
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1106
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1107
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1108
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1109
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1110
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1111
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1112
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1113
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1114
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1115
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1116
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1117
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1118
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1119
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1120
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1121
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1122
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1123
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1124
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1125
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1126
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1127
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1128
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1129
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1130
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1131
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1132
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1133
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1134
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1135
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1136
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1137
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1138
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1139
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1140
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1141
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1142
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1143
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1144
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1145
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1146
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1147
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1148
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1149
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1150
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1151
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1152
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1153
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1154
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1155
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1156
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1157
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1158
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1159
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1160
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1161
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1162
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1163
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1164
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1165
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1166
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1167
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1168
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1169
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1170
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1171
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1172
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1173
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1174
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1175
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1176
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1177
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1178
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1179
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1180
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1181
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1182
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1183
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1184
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1185
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1186
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1187
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1188
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1189
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1190
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1191
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1192
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1193
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1194
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1195
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1196
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1197
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1198
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1199
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1200
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1201
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1202
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1203
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1204
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1205
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1206
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1207
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1208
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1209
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1210
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1211
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1212
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1213
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1214
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1215
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1216
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1217
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1218
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1219
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1220
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1221
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1222
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1223
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1224
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1225
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1226
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1227
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1228
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1229
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1230
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1231
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1232
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1233
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1234
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1235
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1236
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1237
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1238
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1239
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1240
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1241
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1242
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1243
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1244
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1245
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1246
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1247
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1248
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1249
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1250
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1251
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1252
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1253
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1254
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1255
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1256
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1257
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1258
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1259
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1260
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1261
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1262
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1263
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1264
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1265
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1266
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1267
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1268
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1269
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1270
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1271
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1272
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1273
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1274
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1275
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1276
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1277
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1278
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1279
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1280
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1281
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1282
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1283
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1284
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1285
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1286
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1287
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1288
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1289
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1290
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1291
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1292
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1293
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1294
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1295
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1296
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1297
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1298
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1299
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1300
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1301
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1302
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1303
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1304
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1305
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1306
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1307
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1308
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1309
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1310
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1311
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1312
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1313
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1314
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1315
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1316
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1317
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1318
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1319
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1320
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1321
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1322
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1323
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1324
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1325
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1326
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1327
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1328
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1329
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1330
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1331
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1332
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1333
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1334
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1335
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1336
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1337
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1338
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1339
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1340
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1341
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1342
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1343
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1344
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1345
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1346
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1347
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1348
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1349
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1350
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1351
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1352
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1353
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1354
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1355
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1356
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1357
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1358
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1359
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1360
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1361
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1362
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1363
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1364
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1365
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1366
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1367
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1368
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1369
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1370
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1371
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1372
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1373
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1374
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1375
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1376
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1377
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1378
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1379
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1380
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1381
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1382
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1383
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1384
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1385
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1386
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1387
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1388
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1389
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1390
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1391
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1392
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1393
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1394
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1395
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1396
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1397
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1398
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1399
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1400
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1401
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1402
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1403
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1404
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1405
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1406
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1407
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1408
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1409
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1410
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1411
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1412
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1413
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1414
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1415
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1416
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1417
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1418
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1419
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1420
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1421
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1422
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1423
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1424
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1425
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1426
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1427
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1428
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1429
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1430
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1431
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1432
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1433
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1434
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1435
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1436
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1437
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1438
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1439
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1440
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1441
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1442
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1443
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1444
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1445
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1446
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1447
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1448
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1449
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1450
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1451
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1452
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1453
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1454
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1455
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1456
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1457
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1458
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1459
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1460
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1461
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1462
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1463
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1464
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1465
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1466
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1467
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1468
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1469
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1470
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1471
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1472
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1473
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1474
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1475
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1476
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1477
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1478
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1479
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1480
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1481
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1482
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1483
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1484
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1485
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1486
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1487
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1488
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1489
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1490
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1491
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1492
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1493
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1494
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1495
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1496
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1497
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1498
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1499
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1500
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1501
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1502
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1503
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1504
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1505
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1506
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1507
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1508
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1509
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1510
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1511
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1512
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1513
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1514
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1515
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1516
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1517
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1518
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1519
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1520
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1521
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1522
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1523
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1524
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1525
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1526
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1527
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1528
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1529
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1530
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1531
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1532
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1533
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1534
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1535
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1536
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1537
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1538
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1539
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1540
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1541
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1542
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1543
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1544
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1545
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1546
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1547
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1548
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1549
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1550
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1551
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1552
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1553
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1554
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1555
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1556
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1557
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1558
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1559
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1560
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1561
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1562
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1563
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1564
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1565
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1566
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1567
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1568
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1569
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1570
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1571
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1572
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1573
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1574
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1575
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1576
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1577
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1578
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1579
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1580
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1581
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1582
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1583
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1584
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1585
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1586
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1587
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1588
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1589
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1590
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1591
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1592
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1593
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1594
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1595
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1596
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1597
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1598
+    UF_FLAG_PARTY_MEMBER,                                   // PLAYER_QUEST_LOG+1599
     UF_FLAG_PUBLIC,                                         // PLAYER_VISIBLE_ITEM
     UF_FLAG_PUBLIC,                                         // PLAYER_VISIBLE_ITEM+1
     UF_FLAG_PUBLIC,                                         // PLAYER_VISIBLE_ITEM+2
@@ -1346,3568 +2318,4021 @@ uint32 UnitUpdateFieldFlags[PLAYER_END] =
     UF_FLAG_PUBLIC,                                         // PLAYER_FIELD_AVG_ITEM_LEVEL+2
     UF_FLAG_PUBLIC,                                         // PLAYER_FIELD_AVG_ITEM_LEVEL+3
     UF_FLAG_PUBLIC,                                         // PLAYER_FIELD_CURRENT_BATTLE_PET_BREED_QUALITY
-    UF_FLAG_PUBLIC,                                         // PLAYER_FIELD_PRESTIGE
     UF_FLAG_PUBLIC,                                         // PLAYER_FIELD_HONOR_LEVEL
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+7
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+8
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+9
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+10
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+11
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+12
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+13
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+14
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+15
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+16
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+17
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+18
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+19
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+20
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+21
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+22
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+23
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+24
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+25
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+26
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+27
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+28
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+29
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+30
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+31
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+32
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+33
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+34
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+35
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+36
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+37
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+38
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+39
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+40
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+41
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+42
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+43
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+44
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+45
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+46
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+47
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+48
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+49
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+50
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+51
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+52
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+53
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+54
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+55
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+56
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+57
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+58
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+59
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+60
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+61
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+62
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+63
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+64
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+65
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+66
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+67
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+68
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+69
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+70
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+71
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+72
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+73
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+74
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+75
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+76
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+77
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+78
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+79
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+80
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+81
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+82
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+83
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+84
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+85
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+86
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+87
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+88
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+89
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+90
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+91
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+92
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+93
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+94
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+95
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+96
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+97
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+98
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+99
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+100
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+101
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+102
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+103
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+104
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+105
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+106
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+107
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+108
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+109
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+110
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+111
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+112
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+113
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+114
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+115
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+116
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+117
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+118
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+119
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+120
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+121
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+122
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+123
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+124
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+125
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+126
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+127
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+128
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+129
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+130
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+131
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+132
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+133
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+134
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+135
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+136
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+137
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+138
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+139
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+140
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+141
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+142
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+143
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+144
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+145
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+146
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+147
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+148
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+149
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+150
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+151
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+152
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+153
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+154
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+155
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+156
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+157
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+158
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+159
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+160
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+161
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+162
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+163
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+164
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+165
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+166
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+167
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+168
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+169
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+170
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+171
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+172
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+173
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+174
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+175
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+176
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+177
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+178
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+179
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+180
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+181
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+182
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+183
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+184
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+185
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+186
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+187
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+188
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+189
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+190
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+191
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+192
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+193
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+194
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+195
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+196
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+197
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+198
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+199
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+200
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+201
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+202
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+203
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+204
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+205
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+206
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+207
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+208
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+209
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+210
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+211
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+212
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+213
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+214
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+215
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+216
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+217
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+218
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+219
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+220
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+221
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+222
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+223
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+224
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+225
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+226
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+227
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+228
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+229
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+230
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+231
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+232
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+233
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+234
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+235
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+236
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+237
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+238
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+239
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+240
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+241
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+242
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+243
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+244
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+245
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+246
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+247
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+248
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+249
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+250
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+251
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+252
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+253
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+254
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+255
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+256
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+257
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+258
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+259
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+260
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+261
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+262
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+263
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+264
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+265
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+266
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+267
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+268
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+269
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+270
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+271
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+272
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+273
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+274
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+275
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+276
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+277
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+278
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+279
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+280
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+281
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+282
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+283
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+284
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+285
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+286
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+287
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+288
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+289
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+290
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+291
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+292
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+293
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+294
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+295
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+296
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+297
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+298
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+299
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+300
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+301
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+302
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+303
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+304
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+305
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+306
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+307
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+308
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+309
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+310
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+311
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+312
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+313
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+314
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+315
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+316
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+317
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+318
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+319
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+320
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+321
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+322
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+323
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+324
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+325
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+326
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+327
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+328
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+329
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+330
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+331
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+332
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+333
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+334
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+335
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+336
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+337
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+338
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+339
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+340
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+341
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+342
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+343
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+344
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+345
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+346
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+347
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+348
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+349
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+350
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+351
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+352
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+353
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+354
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+355
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+356
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+357
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+358
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+359
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+360
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+361
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+362
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+363
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+364
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+365
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+366
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+367
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+368
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+369
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+370
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+371
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+372
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+373
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+374
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+375
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+376
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+377
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+378
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+379
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+380
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+381
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+382
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+383
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+384
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+385
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+386
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+387
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+388
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+389
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+390
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+391
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+392
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+393
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+394
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+395
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+396
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+397
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+398
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+399
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+400
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+401
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+402
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+403
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+404
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+405
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+406
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+407
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+408
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+409
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+410
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+411
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+412
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+413
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+414
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+415
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+416
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+417
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+418
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+419
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+420
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+421
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+422
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+423
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+424
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+425
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+426
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+427
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+428
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+429
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+430
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+431
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+432
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+433
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+434
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+435
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+436
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+437
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+438
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+439
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+440
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+441
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+442
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+443
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+444
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+445
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+446
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+447
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+448
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+449
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+450
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+451
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+452
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+453
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+454
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+455
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+456
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+457
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+458
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+459
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+460
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+461
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+462
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+463
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+464
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+465
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+466
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+467
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+468
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+469
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+470
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+471
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+472
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+473
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+474
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+475
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+476
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+477
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+478
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+479
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+480
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+481
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+482
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+483
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+484
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+485
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+486
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+487
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+488
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+489
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+490
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+491
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+492
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+493
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+494
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+495
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+496
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+497
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+498
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+499
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+500
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+501
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+502
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+503
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+504
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+505
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+506
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+507
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+508
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+509
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+510
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+511
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+512
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+513
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+514
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+515
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+516
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+517
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+518
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+519
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+520
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+521
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+522
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+523
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+524
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+525
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+526
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+527
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+528
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+529
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+530
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+531
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+532
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+533
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+534
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+535
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+536
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+537
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+538
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+539
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+540
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+541
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+542
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+543
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+544
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+545
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+546
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+547
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+548
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+549
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+550
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+551
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+552
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+553
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+554
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+555
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+556
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+557
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+558
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+559
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+560
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+561
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+562
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+563
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+564
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+565
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+566
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+567
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+568
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+569
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+570
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+571
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+572
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+573
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+574
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+575
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+576
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+577
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+578
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+579
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+580
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+581
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+582
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+583
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+584
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+585
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+586
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+587
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+588
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+589
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+590
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+591
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+592
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+593
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+594
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+595
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+596
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+597
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+598
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+599
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+600
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+601
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+602
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+603
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+604
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+605
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+606
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+607
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+608
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+609
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+610
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+611
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+612
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+613
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+614
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+615
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+616
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+617
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+618
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+619
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+620
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+621
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+622
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+623
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+624
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+625
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+626
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+627
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+628
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+629
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+630
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+631
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+632
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+633
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+634
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+635
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+636
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+637
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+638
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+639
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+640
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+641
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+642
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+643
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+644
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+645
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+646
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+647
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+648
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+649
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+650
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+651
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+652
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+653
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+654
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+655
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+656
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+657
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+658
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+659
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+660
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+661
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+662
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+663
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+664
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+665
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+666
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+667
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+668
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+669
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+670
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+671
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+672
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+673
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+674
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+675
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+676
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+677
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+678
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+679
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+680
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+681
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+682
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+683
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+684
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+685
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+686
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+687
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+688
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+689
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+690
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+691
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+692
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+693
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+694
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+695
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+696
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+697
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+698
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+699
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+700
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+701
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+702
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+703
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+704
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+705
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+706
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+707
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+708
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+709
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+710
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+711
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+712
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+713
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+714
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+715
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+716
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+717
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+718
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+719
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+720
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+721
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+722
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+723
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+724
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+725
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+726
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+727
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+728
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+729
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+730
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+731
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+732
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+733
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+734
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+735
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+736
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+737
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+738
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+739
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+740
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+741
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+742
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+743
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+744
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+745
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+746
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+747
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+748
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+749
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+750
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+751
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+752
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+753
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+754
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+755
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+756
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+757
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+758
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+759
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+760
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+761
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+762
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+763
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+764
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+765
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+766
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+767
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+768
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+769
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+770
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+771
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+772
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+773
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+774
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+775
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+776
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+777
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+778
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INV_SLOT_HEAD+779
-    UF_FLAG_PRIVATE,                                        // PLAYER_FARSIGHT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FARSIGHT+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FARSIGHT+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FARSIGHT+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_SUMMONED_BATTLE_PET_ID
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_SUMMONED_BATTLE_PET_ID+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_SUMMONED_BATTLE_PET_ID+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_SUMMONED_BATTLE_PET_ID+3
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+1
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+2
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+3
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+4
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+5
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+6
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+7
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+8
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+9
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+10
-    UF_FLAG_PRIVATE,                                        // PLAYER__FIELD_KNOWN_TITLES+11
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COINAGE
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COINAGE+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_XP
-    UF_FLAG_PRIVATE,                                        // PLAYER_NEXT_LEVEL_XP
-    UF_FLAG_PRIVATE,                                        // PLAYER_TRIAL_XP
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+7
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+8
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+9
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+10
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+11
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+12
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+13
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+14
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+15
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+16
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+17
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+18
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+19
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+20
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+21
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+22
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+23
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+24
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+25
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+26
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+27
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+28
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+29
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+30
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+31
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+32
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+33
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+34
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+35
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+36
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+37
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+38
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+39
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+40
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+41
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+42
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+43
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+44
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+45
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+46
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+47
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+48
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+49
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+50
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+51
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+52
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+53
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+54
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+55
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+56
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+57
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+58
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+59
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+60
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+61
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+62
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+63
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+64
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+65
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+66
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+67
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+68
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+69
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+70
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+71
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+72
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+73
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+74
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+75
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+76
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+77
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+78
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+79
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+80
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+81
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+82
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+83
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+84
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+85
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+86
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+87
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+88
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+89
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+90
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+91
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+92
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+93
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+94
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+95
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+96
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+97
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+98
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+99
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+100
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+101
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+102
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+103
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+104
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+105
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+106
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+107
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+108
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+109
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+110
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+111
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+112
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+113
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+114
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+115
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+116
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+117
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+118
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+119
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+120
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+121
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+122
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+123
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+124
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+125
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+126
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+127
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+128
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+129
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+130
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+131
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+132
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+133
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+134
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+135
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+136
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+137
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+138
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+139
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+140
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+141
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+142
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+143
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+144
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+145
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+146
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+147
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+148
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+149
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+150
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+151
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+152
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+153
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+154
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+155
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+156
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+157
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+158
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+159
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+160
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+161
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+162
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+163
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+164
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+165
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+166
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+167
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+168
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+169
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+170
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+171
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+172
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+173
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+174
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+175
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+176
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+177
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+178
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+179
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+180
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+181
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+182
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+183
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+184
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+185
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+186
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+187
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+188
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+189
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+190
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+191
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+192
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+193
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+194
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+195
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+196
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+197
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+198
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+199
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+200
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+201
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+202
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+203
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+204
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+205
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+206
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+207
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+208
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+209
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+210
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+211
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+212
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+213
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+214
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+215
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+216
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+217
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+218
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+219
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+220
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+221
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+222
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+223
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+224
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+225
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+226
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+227
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+228
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+229
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+230
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+231
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+232
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+233
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+234
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+235
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+236
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+237
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+238
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+239
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+240
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+241
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+242
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+243
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+244
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+245
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+246
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+247
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+248
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+249
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+250
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+251
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+252
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+253
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+254
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+255
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+256
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+257
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+258
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+259
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+260
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+261
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+262
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+263
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+264
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+265
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+266
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+267
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+268
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+269
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+270
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+271
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+272
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+273
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+274
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+275
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+276
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+277
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+278
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+279
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+280
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+281
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+282
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+283
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+284
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+285
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+286
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+287
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+288
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+289
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+290
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+291
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+292
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+293
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+294
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+295
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+296
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+297
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+298
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+299
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+300
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+301
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+302
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+303
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+304
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+305
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+306
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+307
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+308
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+309
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+310
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+311
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+312
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+313
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+314
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+315
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+316
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+317
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+318
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+319
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+320
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+321
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+322
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+323
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+324
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+325
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+326
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+327
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+328
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+329
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+330
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+331
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+332
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+333
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+334
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+335
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+336
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+337
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+338
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+339
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+340
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+341
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+342
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+343
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+344
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+345
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+346
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+347
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+348
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+349
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+350
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+351
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+352
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+353
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+354
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+355
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+356
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+357
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+358
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+359
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+360
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+361
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+362
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+363
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+364
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+365
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+366
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+367
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+368
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+369
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+370
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+371
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+372
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+373
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+374
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+375
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+376
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+377
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+378
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+379
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+380
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+381
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+382
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+383
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+384
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+385
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+386
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+387
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+388
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+389
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+390
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+391
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+392
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+393
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+394
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+395
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+396
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+397
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+398
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+399
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+400
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+401
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+402
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+403
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+404
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+405
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+406
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+407
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+408
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+409
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+410
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+411
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+412
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+413
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+414
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+415
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+416
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+417
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+418
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+419
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+420
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+421
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+422
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+423
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+424
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+425
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+426
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+427
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+428
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+429
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+430
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+431
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+432
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+433
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+434
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+435
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+436
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+437
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+438
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+439
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+440
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+441
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+442
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+443
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+444
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+445
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+446
-    UF_FLAG_PRIVATE,                                        // PLAYER_SKILL_LINEID+447
-    UF_FLAG_PRIVATE,                                        // PLAYER_CHARACTER_POINTS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MAX_TALENT_TIERS
-    UF_FLAG_PRIVATE,                                        // PLAYER_TRACK_CREATURES
-    UF_FLAG_PRIVATE,                                        // PLAYER_TRACK_RESOURCES
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPERTISE
-    UF_FLAG_PRIVATE,                                        // PLAYER_OFFHAND_EXPERTISE
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RANGED_EXPERTISE
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_EXPERTISE
-    UF_FLAG_PRIVATE,                                        // PLAYER_BLOCK_PERCENTAGE
-    UF_FLAG_PRIVATE,                                        // PLAYER_DODGE_PERCENTAGE
-    UF_FLAG_PRIVATE,                                        // PLAYER_DODGE_PERCENTAGE_FROM_ATTRIBUTE
-    UF_FLAG_PRIVATE,                                        // PLAYER_PARRY_PERCENTAGE
-    UF_FLAG_PRIVATE,                                        // PLAYER_PARRY_PERCENTAGE_FROM_ATTRIBUTE
-    UF_FLAG_PRIVATE,                                        // PLAYER_CRIT_PERCENTAGE
-    UF_FLAG_PRIVATE,                                        // PLAYER_RANGED_CRIT_PERCENTAGE
-    UF_FLAG_PRIVATE,                                        // PLAYER_OFFHAND_CRIT_PERCENTAGE
-    UF_FLAG_PRIVATE,                                        // PLAYER_SPELL_CRIT_PERCENTAGE1
-    UF_FLAG_PRIVATE,                                        // PLAYER_SHIELD_BLOCK
-    UF_FLAG_PRIVATE,                                        // PLAYER_SHIELD_BLOCK_CRIT_PERCENTAGE
-    UF_FLAG_PRIVATE,                                        // PLAYER_MASTERY
-    UF_FLAG_PRIVATE,                                        // PLAYER_SPEED
-    UF_FLAG_PRIVATE,                                        // PLAYER_LIFESTEAL
-    UF_FLAG_PRIVATE,                                        // PLAYER_AVOIDANCE
-    UF_FLAG_PRIVATE,                                        // PLAYER_STURDINESS
-    UF_FLAG_PRIVATE,                                        // PLAYER_VERSATILITY
-    UF_FLAG_PRIVATE,                                        // PLAYER_VERSATILITY_BONUS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_PVP_POWER_DAMAGE
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_PVP_POWER_HEALING
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+7
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+8
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+9
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+10
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+11
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+12
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+13
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+14
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+15
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+16
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+17
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+18
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+19
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+20
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+21
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+22
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+23
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+24
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+25
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+26
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+27
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+28
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+29
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+30
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+31
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+32
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+33
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+34
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+35
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+36
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+37
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+38
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+39
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+40
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+41
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+42
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+43
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+44
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+45
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+46
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+47
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+48
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+49
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+50
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+51
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+52
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+53
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+54
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+55
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+56
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+57
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+58
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+59
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+60
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+61
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+62
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+63
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+64
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+65
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+66
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+67
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+68
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+69
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+70
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+71
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+72
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+73
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+74
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+75
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+76
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+77
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+78
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+79
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+80
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+81
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+82
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+83
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+84
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+85
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+86
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+87
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+88
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+89
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+90
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+91
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+92
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+93
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+94
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+95
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+96
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+97
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+98
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+99
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+100
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+101
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+102
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+103
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+104
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+105
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+106
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+107
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+108
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+109
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+110
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+111
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+112
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+113
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+114
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+115
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+116
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+117
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+118
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+119
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+120
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+121
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+122
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+123
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+124
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+125
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+126
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+127
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+128
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+129
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+130
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+131
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+132
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+133
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+134
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+135
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+136
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+137
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+138
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+139
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+140
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+141
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+142
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+143
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+144
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+145
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+146
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+147
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+148
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+149
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+150
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+151
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+152
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+153
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+154
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+155
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+156
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+157
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+158
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+159
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+160
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+161
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+162
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+163
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+164
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+165
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+166
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+167
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+168
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+169
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+170
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+171
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+172
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+173
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+174
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+175
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+176
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+177
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+178
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+179
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+180
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+181
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+182
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+183
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+184
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+185
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+186
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+187
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+188
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+189
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+190
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+191
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+192
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+193
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+194
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+195
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+196
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+197
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+198
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+199
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+200
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+201
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+202
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+203
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+204
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+205
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+206
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+207
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+208
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+209
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+210
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+211
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+212
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+213
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+214
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+215
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+216
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+217
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+218
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+219
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+220
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+221
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+222
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+223
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+224
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+225
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+226
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+227
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+228
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+229
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+230
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+231
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+232
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+233
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+234
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+235
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+236
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+237
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+238
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+239
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+240
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+241
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+242
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+243
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+244
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+245
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+246
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+247
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+248
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+249
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+250
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+251
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+252
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+253
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+254
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+255
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+256
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+257
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+258
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+259
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+260
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+261
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+262
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+263
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+264
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+265
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+266
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+267
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+268
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+269
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+270
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+271
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+272
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+273
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+274
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+275
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+276
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+277
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+278
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+279
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+280
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+281
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+282
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+283
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+284
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+285
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+286
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+287
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+288
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+289
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+290
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+291
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+292
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+293
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+294
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+295
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+296
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+297
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+298
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+299
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+300
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+301
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+302
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+303
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+304
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+305
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+306
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+307
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+308
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+309
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+310
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+311
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+312
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+313
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+314
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+315
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+316
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+317
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+318
-    UF_FLAG_PRIVATE,                                        // PLAYER_EXPLORED_ZONES_1+319
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_REST_INFO
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_REST_INFO+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_REST_INFO+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_REST_INFO+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_POS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_POS+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_POS+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_POS+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_POS+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_POS+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_POS+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_PCT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_HEALING_DONE_POS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_HEALING_PCT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_HEALING_DONE_PCT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_PERIODIC_HEALING_DONE_PERCENT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_SPELL_POWER_PCT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_RESILIENCE_PERCENT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_TARGET_RESISTANCE
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_LOCAL_FLAGS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BYTES
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_PVP_MEDALS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+7
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+8
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+9
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+10
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_PRICE_1+11
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+7
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+8
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+9
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+10
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BUYBACK_TIMESTAMP_1+11
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_KILLS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_LIFETIME_HONORABLE_KILLS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_WATCHED_FACTION_INDEX
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+7
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+8
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+9
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+10
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+11
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+12
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+13
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+14
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+15
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+16
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+17
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+18
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+19
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+20
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+21
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+22
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+23
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+24
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+25
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+26
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+27
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+28
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+29
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+30
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_COMBAT_RATING_1+31
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+7
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+8
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+9
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+10
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+11
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+12
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+13
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+14
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+15
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+16
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+17
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+18
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+19
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+20
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+21
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+22
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+23
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+24
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+25
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+26
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+27
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+28
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+29
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+30
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+31
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+32
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+33
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+34
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+35
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+36
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+37
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+38
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+39
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+40
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_ARENA_TEAM_INFO_1_1+41
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MAX_LEVEL
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MAX_CREATURE_SCALING_LEVEL
-    UF_FLAG_PRIVATE,                                        // PLAYER_NO_REAGENT_COST_1
-    UF_FLAG_PRIVATE,                                        // PLAYER_NO_REAGENT_COST_1+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_NO_REAGENT_COST_1+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_NO_REAGENT_COST_1+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_PET_SPELL_POWER
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1+7
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1+8
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_RESEARCHING_1+9
-    UF_FLAG_PRIVATE,                                        // PLAYER_PROFESSION_SKILL_LINE_1
-    UF_FLAG_PRIVATE,                                        // PLAYER_PROFESSION_SKILL_LINE_1+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_UI_HIT_MODIFIER
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_UI_SPELL_HIT_MODIFIER
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_HOME_REALM_TIME_OFFSET
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_MOD_PET_HASTE
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BYTES2
-    UF_FLAG_PRIVATE | UF_FLAG_URGENT_SELF_ONLY,             // PLAYER_FIELD_BYTES3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_LFG_BONUS_FACTION_ID
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_LOOT_SPEC_ID
-    UF_FLAG_PRIVATE | UF_FLAG_URGENT_SELF_ONLY,             // PLAYER_FIELD_OVERRIDE_ZONE_PVP_TYPE
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BAG_SLOT_FLAGS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BAG_SLOT_FLAGS+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BAG_SLOT_FLAGS+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BAG_SLOT_FLAGS+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BANK_BAG_SLOT_FLAGS
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_INSERT_ITEMS_LEFT_TO_RIGHT
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+2
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+3
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+4
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+5
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+6
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+7
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+8
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+9
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+10
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+11
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+12
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+13
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+14
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+15
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+16
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+17
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+18
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+19
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+20
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+21
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+22
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+23
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+24
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+25
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+26
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+27
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+28
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+29
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+30
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+31
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+32
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+33
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+34
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+35
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+36
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+37
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+38
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+39
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+40
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+41
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+42
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+43
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+44
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+45
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+46
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+47
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+48
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+49
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+50
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+51
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+52
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+53
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+54
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+55
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+56
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+57
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+58
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+59
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+60
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+61
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+62
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+63
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+64
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+65
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+66
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+67
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+68
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+69
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+70
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+71
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+72
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+73
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+74
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+75
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+76
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+77
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+78
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+79
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+80
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+81
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+82
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+83
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+84
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+85
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+86
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+87
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+88
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+89
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+90
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+91
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+92
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+93
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+94
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+95
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+96
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+97
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+98
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+99
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+100
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+101
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+102
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+103
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+104
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+105
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+106
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+107
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+108
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+109
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+110
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+111
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+112
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+113
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+114
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+115
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+116
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+117
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+118
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+119
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+120
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+121
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+122
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+123
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+124
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+125
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+126
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+127
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+128
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+129
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+130
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+131
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+132
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+133
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+134
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+135
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+136
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+137
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+138
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+139
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+140
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+141
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+142
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+143
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+144
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+145
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+146
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+147
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+148
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+149
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+150
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+151
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+152
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+153
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+154
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+155
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+156
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+157
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+158
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+159
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+160
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+161
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+162
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+163
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+164
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+165
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+166
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+167
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+168
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+169
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+170
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+171
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+172
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+173
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+174
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+175
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+176
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+177
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+178
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+179
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+180
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+181
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+182
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+183
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+184
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+185
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+186
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+187
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+188
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+189
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+190
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+191
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+192
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+193
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+194
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+195
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+196
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+197
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+198
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+199
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+200
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+201
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+202
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+203
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+204
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+205
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+206
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+207
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+208
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+209
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+210
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+211
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+212
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+213
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+214
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+215
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+216
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+217
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+218
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+219
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+220
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+221
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+222
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+223
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+224
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+225
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+226
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+227
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+228
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+229
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+230
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+231
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+232
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+233
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+234
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+235
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+236
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+237
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+238
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+239
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+240
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+241
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+242
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+243
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+244
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+245
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+246
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+247
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+248
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+249
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+250
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+251
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+252
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+253
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+254
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+255
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+256
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+257
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+258
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+259
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+260
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+261
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+262
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+263
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+264
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+265
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+266
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+267
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+268
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+269
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+270
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+271
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+272
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+273
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+274
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+275
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+276
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+277
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+278
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+279
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+280
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+281
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+282
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+283
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+284
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+285
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+286
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+287
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+288
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+289
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+290
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+291
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+292
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+293
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+294
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+295
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+296
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+297
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+298
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+299
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+300
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+301
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+302
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+303
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+304
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+305
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+306
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+307
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+308
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+309
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+310
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+311
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+312
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+313
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+314
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+315
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+316
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+317
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+318
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+319
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+320
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+321
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+322
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+323
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+324
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+325
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+326
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+327
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+328
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+329
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+330
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+331
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+332
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+333
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+334
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+335
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+336
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+337
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+338
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+339
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+340
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+341
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+342
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+343
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+344
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+345
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+346
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+347
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+348
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+349
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+350
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+351
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+352
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+353
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+354
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+355
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+356
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+357
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+358
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+359
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+360
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+361
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+362
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+363
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+364
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+365
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+366
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+367
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+368
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+369
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+370
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+371
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+372
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+373
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+374
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+375
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+376
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+377
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+378
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+379
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+380
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+381
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+382
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+383
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+384
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+385
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+386
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+387
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+388
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+389
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+390
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+391
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+392
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+393
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+394
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+395
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+396
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+397
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+398
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+399
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+400
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+401
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+402
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+403
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+404
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+405
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+406
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+407
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+408
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+409
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+410
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+411
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+412
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+413
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+414
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+415
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+416
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+417
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+418
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+419
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+420
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+421
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+422
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+423
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+424
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+425
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+426
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+427
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+428
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+429
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+430
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+431
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+432
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+433
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+434
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+435
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+436
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+437
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+438
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+439
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+440
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+441
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+442
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+443
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+444
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+445
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+446
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+447
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+448
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+449
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+450
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+451
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+452
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+453
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+454
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+455
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+456
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+457
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+458
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+459
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+460
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+461
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+462
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+463
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+464
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+465
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+466
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+467
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+468
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+469
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+470
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+471
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+472
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+473
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+474
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+475
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+476
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+477
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+478
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+479
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+480
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+481
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+482
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+483
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+484
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+485
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+486
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+487
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+488
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+489
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+490
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+491
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+492
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+493
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+494
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+495
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+496
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+497
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+498
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+499
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+500
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+501
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+502
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+503
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+504
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+505
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+506
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+507
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+508
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+509
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+510
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+511
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+512
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+513
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+514
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+515
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+516
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+517
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+518
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+519
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+520
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+521
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+522
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+523
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+524
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+525
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+526
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+527
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+528
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+529
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+530
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+531
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+532
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+533
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+534
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+535
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+536
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+537
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+538
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+539
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+540
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+541
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+542
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+543
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+544
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+545
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+546
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+547
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+548
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+549
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+550
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+551
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+552
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+553
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+554
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+555
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+556
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+557
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+558
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+559
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+560
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+561
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+562
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+563
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+564
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+565
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+566
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+567
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+568
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+569
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+570
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+571
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+572
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+573
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+574
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+575
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+576
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+577
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+578
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+579
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+580
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+581
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+582
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+583
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+584
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+585
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+586
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+587
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+588
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+589
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+590
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+591
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+592
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+593
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+594
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+595
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+596
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+597
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+598
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+599
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+600
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+601
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+602
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+603
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+604
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+605
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+606
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+607
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+608
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+609
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+610
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+611
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+612
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+613
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+614
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+615
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+616
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+617
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+618
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+619
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+620
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+621
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+622
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+623
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+624
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+625
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+626
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+627
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+628
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+629
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+630
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+631
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+632
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+633
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+634
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+635
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+636
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+637
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+638
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+639
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+640
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+641
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+642
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+643
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+644
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+645
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+646
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+647
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+648
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+649
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+650
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+651
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+652
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+653
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+654
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+655
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+656
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+657
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+658
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+659
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+660
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+661
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+662
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+663
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+664
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+665
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+666
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+667
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+668
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+669
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+670
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+671
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+672
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+673
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+674
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+675
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+676
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+677
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+678
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+679
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+680
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+681
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+682
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+683
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+684
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+685
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+686
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+687
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+688
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+689
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+690
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+691
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+692
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+693
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+694
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+695
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+696
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+697
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+698
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+699
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+700
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+701
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+702
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+703
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+704
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+705
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+706
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+707
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+708
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+709
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+710
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+711
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+712
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+713
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+714
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+715
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+716
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+717
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+718
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+719
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+720
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+721
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+722
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+723
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+724
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+725
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+726
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+727
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+728
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+729
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+730
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+731
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+732
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+733
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+734
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+735
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+736
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+737
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+738
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+739
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+740
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+741
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+742
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+743
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+744
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+745
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+746
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+747
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+748
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+749
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+750
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+751
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+752
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+753
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+754
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+755
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+756
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+757
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+758
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+759
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+760
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+761
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+762
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+763
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+764
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+765
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+766
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+767
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+768
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+769
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+770
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+771
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+772
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+773
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+774
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+775
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+776
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+777
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+778
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+779
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+780
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+781
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+782
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+783
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+784
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+785
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+786
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+787
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+788
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+789
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+790
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+791
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+792
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+793
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+794
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+795
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+796
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+797
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+798
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+799
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+800
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+801
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+802
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+803
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+804
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+805
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+806
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+807
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+808
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+809
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+810
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+811
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+812
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+813
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+814
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+815
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+816
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+817
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+818
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+819
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+820
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+821
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+822
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+823
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+824
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+825
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+826
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+827
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+828
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+829
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+830
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+831
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+832
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+833
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+834
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+835
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+836
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+837
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+838
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+839
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+840
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+841
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+842
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+843
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+844
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+845
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+846
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+847
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+848
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+849
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+850
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+851
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+852
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+853
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+854
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+855
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+856
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+857
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+858
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+859
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+860
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+861
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+862
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+863
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+864
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+865
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+866
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+867
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+868
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+869
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+870
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+871
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+872
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+873
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+874
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+875
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+876
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+877
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+878
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+879
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+880
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+881
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+882
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+883
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+884
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+885
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+886
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+887
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+888
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+889
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+890
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+891
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+892
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+893
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+894
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+895
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+896
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+897
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+898
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+899
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+900
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+901
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+902
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+903
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+904
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+905
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+906
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+907
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+908
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+909
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+910
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+911
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+912
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+913
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+914
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+915
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+916
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+917
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+918
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+919
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+920
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+921
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+922
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+923
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+924
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+925
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+926
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+927
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+928
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+929
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+930
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+931
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+932
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+933
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+934
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+935
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+936
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+937
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+938
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+939
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+940
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+941
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+942
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+943
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+944
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+945
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+946
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+947
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+948
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+949
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+950
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+951
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+952
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+953
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+954
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+955
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+956
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+957
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+958
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+959
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+960
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+961
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+962
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+963
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+964
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+965
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+966
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+967
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+968
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+969
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+970
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+971
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+972
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+973
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+974
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+975
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+976
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+977
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+978
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+979
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+980
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+981
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+982
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+983
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+984
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+985
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+986
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+987
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+988
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+989
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+990
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+991
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+992
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+993
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+994
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+995
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+996
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+997
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+998
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+999
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1000
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1001
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1002
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1003
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1004
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1005
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1006
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1007
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1008
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1009
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1010
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1011
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1012
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1013
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1014
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1015
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1016
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1017
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1018
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1019
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1020
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1021
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1022
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1023
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1024
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1025
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1026
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1027
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1028
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1029
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1030
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1031
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1032
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1033
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1034
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1035
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1036
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1037
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1038
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1039
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1040
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1041
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1042
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1043
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1044
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1045
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1046
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1047
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1048
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1049
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1050
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1051
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1052
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1053
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1054
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1055
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1056
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1057
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1058
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1059
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1060
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1061
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1062
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1063
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1064
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1065
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1066
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1067
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1068
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1069
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1070
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1071
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1072
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1073
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1074
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1075
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1076
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1077
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1078
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1079
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1080
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1081
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1082
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1083
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1084
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1085
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1086
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1087
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1088
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1089
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1090
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1091
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1092
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1093
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1094
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1095
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1096
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1097
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1098
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1099
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1100
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1101
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1102
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1103
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1104
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1105
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1106
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1107
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1108
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1109
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1110
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1111
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1112
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1113
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1114
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1115
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1116
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1117
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1118
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1119
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1120
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1121
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1122
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1123
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1124
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1125
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1126
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1127
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1128
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1129
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1130
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1131
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1132
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1133
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1134
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1135
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1136
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1137
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1138
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1139
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1140
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1141
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1142
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1143
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1144
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1145
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1146
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1147
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1148
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1149
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1150
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1151
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1152
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1153
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1154
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1155
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1156
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1157
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1158
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1159
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1160
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1161
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1162
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1163
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1164
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1165
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1166
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1167
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1168
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1169
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1170
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1171
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1172
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1173
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1174
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1175
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1176
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1177
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1178
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1179
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1180
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1181
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1182
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1183
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1184
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1185
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1186
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1187
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1188
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1189
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1190
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1191
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1192
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1193
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1194
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1195
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1196
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1197
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1198
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1199
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1200
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1201
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1202
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1203
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1204
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1205
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1206
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1207
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1208
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1209
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1210
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1211
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1212
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1213
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1214
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1215
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1216
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1217
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1218
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1219
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1220
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1221
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1222
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1223
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1224
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1225
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1226
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1227
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1228
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1229
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1230
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1231
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1232
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1233
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1234
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1235
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1236
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1237
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1238
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1239
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1240
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1241
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1242
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1243
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1244
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1245
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1246
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1247
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1248
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1249
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1250
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1251
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1252
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1253
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1254
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1255
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1256
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1257
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1258
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1259
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1260
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1261
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1262
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1263
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1264
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1265
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1266
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1267
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1268
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1269
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1270
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1271
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1272
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1273
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1274
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1275
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1276
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1277
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1278
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1279
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1280
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1281
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1282
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1283
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1284
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1285
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1286
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1287
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1288
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1289
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1290
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1291
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1292
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1293
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1294
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1295
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1296
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1297
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1298
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1299
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1300
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1301
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1302
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1303
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1304
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1305
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1306
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1307
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1308
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1309
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1310
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1311
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1312
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1313
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1314
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1315
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1316
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1317
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1318
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1319
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1320
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1321
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1322
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1323
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1324
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1325
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1326
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1327
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1328
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1329
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1330
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1331
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1332
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1333
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1334
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1335
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1336
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1337
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1338
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1339
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1340
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1341
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1342
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1343
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1344
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1345
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1346
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1347
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1348
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1349
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1350
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1351
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1352
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1353
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1354
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1355
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1356
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1357
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1358
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1359
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1360
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1361
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1362
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1363
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1364
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1365
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1366
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1367
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1368
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1369
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1370
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1371
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1372
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1373
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1374
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1375
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1376
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1377
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1378
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1379
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1380
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1381
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1382
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1383
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1384
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1385
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1386
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1387
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1388
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1389
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1390
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1391
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1392
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1393
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1394
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1395
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1396
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1397
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1398
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1399
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1400
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1401
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1402
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1403
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1404
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1405
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1406
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1407
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1408
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1409
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1410
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1411
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1412
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1413
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1414
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1415
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1416
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1417
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1418
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1419
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1420
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1421
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1422
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1423
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1424
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1425
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1426
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1427
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1428
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1429
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1430
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1431
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1432
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1433
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1434
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1435
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1436
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1437
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1438
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1439
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1440
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1441
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1442
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1443
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1444
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1445
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1446
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1447
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1448
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1449
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1450
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1451
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1452
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1453
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1454
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1455
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1456
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1457
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1458
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1459
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1460
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1461
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1462
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1463
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1464
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1465
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1466
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1467
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1468
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1469
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1470
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1471
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1472
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1473
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1474
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1475
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1476
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1477
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1478
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1479
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1480
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1481
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1482
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1483
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1484
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1485
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1486
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1487
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1488
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1489
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1490
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1491
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1492
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1493
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1494
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1495
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1496
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1497
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1498
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1499
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1500
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1501
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1502
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1503
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1504
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1505
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1506
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1507
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1508
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1509
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1510
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1511
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1512
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1513
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1514
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1515
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1516
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1517
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1518
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1519
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1520
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1521
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1522
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1523
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1524
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1525
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1526
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1527
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1528
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1529
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1530
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1531
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1532
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1533
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1534
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1535
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1536
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1537
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1538
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1539
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1540
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1541
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1542
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1543
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1544
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1545
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1546
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1547
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1548
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1549
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1550
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1551
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1552
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1553
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1554
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1555
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1556
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1557
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1558
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1559
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1560
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1561
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1562
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1563
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1564
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1565
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1566
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1567
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1568
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1569
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1570
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1571
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1572
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1573
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1574
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1575
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1576
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1577
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1578
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1579
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1580
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1581
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1582
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1583
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1584
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1585
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1586
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1587
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1588
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1589
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1590
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1591
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1592
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1593
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1594
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1595
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1596
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1597
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1598
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1599
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1600
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1601
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1602
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1603
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1604
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1605
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1606
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1607
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1608
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1609
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1610
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1611
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1612
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1613
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1614
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1615
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1616
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1617
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1618
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1619
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1620
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1621
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1622
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1623
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1624
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1625
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1626
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1627
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1628
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1629
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1630
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1631
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1632
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1633
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1634
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1635
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1636
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1637
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1638
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1639
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1640
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1641
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1642
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1643
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1644
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1645
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1646
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1647
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1648
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1649
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1650
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1651
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1652
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1653
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1654
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1655
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1656
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1657
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1658
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1659
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1660
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1661
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1662
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1663
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1664
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1665
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1666
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1667
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1668
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1669
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1670
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1671
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1672
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1673
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1674
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1675
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1676
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1677
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1678
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1679
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1680
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1681
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1682
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1683
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1684
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1685
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1686
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1687
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1688
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1689
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1690
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1691
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1692
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1693
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1694
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1695
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1696
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1697
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1698
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1699
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1700
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1701
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1702
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1703
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1704
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1705
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1706
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1707
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1708
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1709
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1710
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1711
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1712
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1713
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1714
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1715
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1716
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1717
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1718
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1719
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1720
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1721
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1722
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1723
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1724
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1725
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1726
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1727
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1728
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1729
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1730
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1731
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1732
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1733
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1734
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1735
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1736
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1737
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1738
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1739
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1740
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1741
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1742
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1743
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1744
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1745
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1746
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1747
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1748
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_QUEST_COMPLETED+1749
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_HONOR
-    UF_FLAG_PRIVATE,                                        // PLAYER_FIELD_HONOR_NEXT_LEVEL
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+7
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+8
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+9
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+10
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+11
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+12
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+13
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+14
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+15
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+16
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+17
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+18
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+19
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+20
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+21
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+22
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+23
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+24
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+25
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+26
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+27
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+28
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+29
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+30
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+31
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+32
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+33
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+34
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+35
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+36
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+37
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+38
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+39
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+40
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+41
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+42
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+43
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+44
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+45
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+46
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+47
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+48
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+49
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+50
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+51
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+52
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+53
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+54
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+55
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+56
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+57
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+58
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+59
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+60
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+61
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+62
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+63
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+64
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+65
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+66
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+67
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+68
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+69
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+70
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+71
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+72
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+73
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+74
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+75
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+76
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+77
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+78
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+79
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+80
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+81
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+82
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+83
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+84
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+85
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+86
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+87
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+88
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+89
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+90
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+91
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+92
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+93
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+94
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+95
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+96
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+97
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+98
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+99
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+100
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+101
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+102
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+103
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+104
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+105
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+106
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+107
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+108
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+109
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+110
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+111
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+112
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+113
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+114
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+115
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+116
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+117
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+118
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+119
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+120
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+121
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+122
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+123
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+124
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+125
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+126
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+127
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+128
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+129
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+130
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+131
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+132
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+133
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+134
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+135
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+136
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+137
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+138
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+139
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+140
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+141
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+142
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+143
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+144
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+145
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+146
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+147
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+148
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+149
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+150
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+151
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+152
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+153
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+154
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+155
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+156
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+157
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+158
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+159
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+160
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+161
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+162
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+163
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+164
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+165
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+166
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+167
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+168
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+169
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+170
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+171
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+172
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+173
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+174
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+175
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+176
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+177
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+178
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+179
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+180
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+181
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+182
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+183
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+184
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+185
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+186
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+187
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+188
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+189
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+190
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+191
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+192
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+193
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+194
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+195
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+196
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+197
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+198
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+199
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+200
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+201
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+202
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+203
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+204
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+205
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+206
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+207
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+208
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+209
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+210
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+211
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+212
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+213
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+214
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+215
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+216
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+217
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+218
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+219
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+220
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+221
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+222
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+223
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+224
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+225
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+226
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+227
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+228
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+229
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+230
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+231
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+232
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+233
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+234
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+235
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+236
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+237
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+238
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+239
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+240
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+241
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+242
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+243
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+244
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+245
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+246
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+247
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+248
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+249
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+250
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+251
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+252
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+253
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+254
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+255
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+256
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+257
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+258
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+259
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+260
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+261
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+262
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+263
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+264
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+265
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+266
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+267
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+268
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+269
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+270
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+271
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+272
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+273
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+274
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+275
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+276
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+277
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+278
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+279
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+280
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+281
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+282
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+283
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+284
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+285
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+286
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+287
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+288
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+289
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+290
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+291
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+292
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+293
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+294
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+295
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+296
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+297
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+298
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+299
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+300
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+301
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+302
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+303
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+304
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+305
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+306
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+307
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+308
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+309
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+310
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+311
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+312
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+313
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+314
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+315
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+316
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+317
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+318
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+319
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+320
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+321
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+322
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+323
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+324
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+325
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+326
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+327
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+328
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+329
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+330
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+331
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+332
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+333
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+334
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+335
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+336
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+337
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+338
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+339
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+340
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+341
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+342
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+343
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+344
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+345
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+346
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+347
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+348
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+349
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+350
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+351
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+352
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+353
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+354
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+355
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+356
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+357
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+358
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+359
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+360
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+361
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+362
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+363
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+364
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+365
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+366
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+367
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+368
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+369
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+370
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+371
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+372
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+373
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+374
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+375
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+376
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+377
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+378
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+379
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+380
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+381
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+382
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+383
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+384
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+385
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+386
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+387
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+388
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+389
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+390
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+391
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+392
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+393
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+394
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+395
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+396
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+397
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+398
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+399
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+400
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+401
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+402
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+403
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+404
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+405
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+406
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+407
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+408
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+409
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+410
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+411
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+412
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+413
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+414
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+415
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+416
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+417
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+418
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+419
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+420
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+421
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+422
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+423
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+424
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+425
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+426
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+427
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+428
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+429
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+430
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+431
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+432
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+433
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+434
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+435
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+436
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+437
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+438
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+439
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+440
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+441
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+442
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+443
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+444
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+445
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+446
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+447
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+448
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+449
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+450
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+451
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+452
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+453
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+454
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+455
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+456
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+457
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+458
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+459
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+460
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+461
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+462
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+463
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+464
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+465
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+466
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+467
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+468
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+469
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+470
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+471
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+472
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+473
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+474
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+475
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+476
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+477
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+478
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+479
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+480
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+481
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+482
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+483
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+484
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+485
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+486
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+487
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+488
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+489
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+490
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+491
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+492
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+493
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+494
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+495
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+496
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+497
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+498
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+499
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+500
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+501
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+502
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+503
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+504
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+505
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+506
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+507
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+508
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+509
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+510
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+511
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+512
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+513
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+514
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+515
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+516
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+517
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+518
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+519
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+520
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+521
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+522
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+523
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+524
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+525
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+526
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+527
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+528
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+529
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+530
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+531
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+532
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+533
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+534
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+535
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+536
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+537
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+538
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+539
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+540
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+541
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+542
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+543
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+544
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+545
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+546
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+547
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+548
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+549
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+550
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+551
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+552
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+553
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+554
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+555
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+556
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+557
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+558
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+559
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+560
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+561
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+562
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+563
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+564
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+565
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+566
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+567
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+568
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+569
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+570
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+571
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+572
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+573
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+574
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+575
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+576
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+577
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+578
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+579
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+580
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+581
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+582
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+583
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+584
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+585
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+586
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+587
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+588
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+589
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+590
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+591
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+592
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+593
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+594
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+595
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+596
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+597
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+598
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+599
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+600
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+601
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+602
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+603
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+604
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+605
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+606
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+607
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+608
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+609
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+610
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+611
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+612
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+613
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+614
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+615
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+616
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+617
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+618
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+619
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+620
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+621
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+622
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+623
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+624
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+625
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+626
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+627
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+628
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+629
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+630
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+631
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+632
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+633
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+634
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+635
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+636
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+637
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+638
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+639
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+640
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+641
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+642
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+643
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+644
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+645
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+646
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+647
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+648
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+649
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+650
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+651
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+652
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+653
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+654
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+655
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+656
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+657
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+658
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+659
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+660
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+661
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+662
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+663
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+664
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+665
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+666
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+667
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+668
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+669
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+670
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+671
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+672
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+673
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+674
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+675
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+676
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+677
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+678
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+679
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+680
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+681
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+682
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+683
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+684
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+685
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+686
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+687
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+688
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+689
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+690
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+691
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+692
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+693
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+694
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+695
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+696
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+697
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+698
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+699
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+700
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+701
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+702
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+703
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+704
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+705
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+706
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+707
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+708
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+709
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+710
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+711
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+712
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+713
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+714
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+715
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+716
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+717
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+718
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+719
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+720
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+721
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+722
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+723
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+724
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+725
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+726
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+727
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+728
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+729
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+730
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+731
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+732
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+733
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+734
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+735
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+736
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+737
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+738
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+739
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+740
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+741
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+742
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+743
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+744
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+745
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+746
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+747
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+748
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+749
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+750
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+751
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+752
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+753
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+754
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+755
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+756
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+757
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+758
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+759
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+760
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+761
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+762
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+763
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+764
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+765
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+766
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+767
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+768
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+769
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+770
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+771
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+772
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+773
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+774
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+775
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+776
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+777
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+778
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD+779
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_FARSIGHT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_FARSIGHT+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_FARSIGHT+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_FARSIGHT+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+7
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+8
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+9
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+10
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KNOWN_TITLES+11
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COINAGE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COINAGE+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_XP
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_NEXT_LEVEL_XP
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_TRIAL_XP
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+7
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+8
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+9
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+10
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+11
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+12
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+13
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+14
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+15
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+16
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+17
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+18
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+19
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+20
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+21
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+22
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+23
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+24
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+25
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+26
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+27
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+28
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+29
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+30
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+31
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+32
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+33
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+34
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+35
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+36
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+37
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+38
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+39
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+40
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+41
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+42
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+43
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+44
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+45
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+46
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+47
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+48
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+49
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+50
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+51
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+52
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+53
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+54
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+55
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+56
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+57
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+58
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+59
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+60
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+61
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+62
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+63
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+64
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+65
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+66
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+67
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+68
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+69
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+70
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+71
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+72
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+73
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+74
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+75
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+76
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+77
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+78
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+79
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+80
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+81
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+82
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+83
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+84
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+85
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+86
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+87
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+88
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+89
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+90
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+91
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+92
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+93
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+94
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+95
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+96
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+97
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+98
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+99
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+100
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+101
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+102
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+103
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+104
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+105
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+106
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+107
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+108
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+109
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+110
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+111
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+112
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+113
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+114
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+115
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+116
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+117
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+118
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+119
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+120
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+121
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+122
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+123
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+124
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+125
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+126
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+127
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+128
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+129
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+130
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+131
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+132
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+133
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+134
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+135
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+136
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+137
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+138
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+139
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+140
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+141
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+142
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+143
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+144
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+145
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+146
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+147
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+148
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+149
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+150
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+151
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+152
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+153
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+154
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+155
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+156
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+157
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+158
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+159
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+160
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+161
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+162
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+163
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+164
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+165
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+166
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+167
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+168
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+169
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+170
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+171
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+172
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+173
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+174
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+175
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+176
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+177
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+178
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+179
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+180
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+181
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+182
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+183
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+184
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+185
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+186
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+187
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+188
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+189
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+190
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+191
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+192
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+193
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+194
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+195
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+196
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+197
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+198
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+199
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+200
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+201
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+202
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+203
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+204
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+205
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+206
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+207
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+208
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+209
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+210
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+211
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+212
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+213
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+214
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+215
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+216
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+217
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+218
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+219
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+220
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+221
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+222
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+223
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+224
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+225
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+226
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+227
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+228
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+229
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+230
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+231
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+232
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+233
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+234
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+235
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+236
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+237
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+238
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+239
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+240
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+241
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+242
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+243
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+244
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+245
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+246
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+247
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+248
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+249
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+250
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+251
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+252
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+253
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+254
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+255
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+256
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+257
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+258
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+259
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+260
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+261
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+262
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+263
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+264
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+265
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+266
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+267
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+268
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+269
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+270
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+271
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+272
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+273
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+274
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+275
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+276
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+277
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+278
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+279
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+280
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+281
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+282
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+283
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+284
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+285
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+286
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+287
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+288
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+289
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+290
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+291
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+292
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+293
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+294
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+295
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+296
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+297
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+298
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+299
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+300
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+301
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+302
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+303
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+304
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+305
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+306
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+307
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+308
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+309
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+310
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+311
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+312
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+313
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+314
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+315
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+316
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+317
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+318
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+319
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+320
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+321
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+322
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+323
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+324
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+325
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+326
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+327
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+328
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+329
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+330
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+331
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+332
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+333
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+334
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+335
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+336
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+337
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+338
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+339
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+340
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+341
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+342
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+343
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+344
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+345
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+346
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+347
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+348
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+349
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+350
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+351
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+352
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+353
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+354
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+355
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+356
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+357
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+358
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+359
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+360
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+361
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+362
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+363
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+364
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+365
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+366
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+367
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+368
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+369
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+370
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+371
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+372
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+373
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+374
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+375
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+376
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+377
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+378
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+379
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+380
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+381
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+382
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+383
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+384
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+385
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+386
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+387
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+388
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+389
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+390
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+391
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+392
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+393
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+394
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+395
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+396
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+397
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+398
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+399
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+400
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+401
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+402
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+403
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+404
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+405
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+406
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+407
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+408
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+409
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+410
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+411
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+412
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+413
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+414
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+415
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+416
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+417
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+418
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+419
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+420
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+421
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+422
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+423
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+424
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+425
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+426
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+427
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+428
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+429
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+430
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+431
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+432
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+433
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+434
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+435
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+436
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+437
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+438
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+439
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+440
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+441
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+442
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+443
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+444
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+445
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+446
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+447
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+448
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+449
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+450
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+451
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+452
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+453
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+454
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+455
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+456
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+457
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+458
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+459
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+460
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+461
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+462
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+463
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+464
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+465
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+466
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+467
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+468
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+469
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+470
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+471
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+472
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+473
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+474
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+475
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+476
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+477
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+478
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+479
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+480
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+481
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+482
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+483
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+484
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+485
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+486
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+487
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+488
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+489
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+490
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+491
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+492
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+493
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+494
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+495
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+496
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+497
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+498
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+499
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+500
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+501
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+502
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+503
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+504
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+505
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+506
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+507
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+508
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+509
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+510
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+511
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+512
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+513
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+514
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+515
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+516
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+517
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+518
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+519
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+520
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+521
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+522
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+523
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+524
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+525
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+526
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+527
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+528
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+529
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+530
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+531
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+532
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+533
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+534
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+535
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+536
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+537
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+538
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+539
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+540
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+541
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+542
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+543
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+544
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+545
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+546
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+547
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+548
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+549
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+550
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+551
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+552
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+553
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+554
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+555
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+556
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+557
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+558
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+559
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+560
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+561
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+562
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+563
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+564
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+565
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+566
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+567
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+568
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+569
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+570
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+571
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+572
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+573
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+574
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+575
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+576
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+577
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+578
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+579
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+580
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+581
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+582
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+583
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+584
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+585
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+586
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+587
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+588
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+589
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+590
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+591
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+592
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+593
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+594
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+595
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+596
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+597
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+598
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+599
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+600
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+601
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+602
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+603
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+604
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+605
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+606
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+607
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+608
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+609
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+610
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+611
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+612
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+613
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+614
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+615
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+616
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+617
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+618
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+619
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+620
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+621
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+622
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+623
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+624
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+625
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+626
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+627
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+628
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+629
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+630
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+631
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+632
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+633
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+634
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+635
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+636
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+637
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+638
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+639
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+640
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+641
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+642
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+643
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+644
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+645
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+646
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+647
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+648
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+649
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+650
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+651
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+652
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+653
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+654
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+655
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+656
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+657
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+658
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+659
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+660
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+661
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+662
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+663
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+664
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+665
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+666
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+667
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+668
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+669
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+670
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+671
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+672
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+673
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+674
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+675
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+676
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+677
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+678
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+679
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+680
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+681
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+682
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+683
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+684
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+685
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+686
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+687
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+688
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+689
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+690
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+691
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+692
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+693
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+694
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+695
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+696
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+697
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+698
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+699
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+700
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+701
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+702
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+703
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+704
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+705
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+706
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+707
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+708
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+709
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+710
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+711
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+712
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+713
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+714
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+715
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+716
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+717
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+718
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+719
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+720
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+721
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+722
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+723
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+724
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+725
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+726
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+727
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+728
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+729
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+730
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+731
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+732
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+733
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+734
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+735
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+736
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+737
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+738
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+739
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+740
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+741
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+742
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+743
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+744
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+745
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+746
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+747
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+748
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+749
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+750
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+751
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+752
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+753
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+754
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+755
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+756
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+757
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+758
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+759
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+760
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+761
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+762
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+763
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+764
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+765
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+766
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+767
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+768
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+769
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+770
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+771
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+772
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+773
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+774
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+775
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+776
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+777
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+778
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+779
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+780
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+781
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+782
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+783
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+784
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+785
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+786
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+787
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+788
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+789
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+790
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+791
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+792
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+793
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+794
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+795
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+796
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+797
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+798
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+799
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+800
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+801
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+802
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+803
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+804
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+805
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+806
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+807
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+808
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+809
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+810
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+811
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+812
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+813
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+814
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+815
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+816
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+817
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+818
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+819
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+820
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+821
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+822
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+823
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+824
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+825
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+826
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+827
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+828
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+829
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+830
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+831
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+832
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+833
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+834
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+835
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+836
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+837
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+838
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+839
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+840
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+841
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+842
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+843
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+844
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+845
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+846
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+847
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+848
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+849
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+850
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+851
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+852
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+853
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+854
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+855
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+856
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+857
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+858
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+859
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+860
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+861
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+862
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+863
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+864
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+865
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+866
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+867
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+868
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+869
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+870
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+871
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+872
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+873
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+874
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+875
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+876
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+877
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+878
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+879
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+880
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+881
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+882
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+883
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+884
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+885
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+886
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+887
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+888
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+889
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+890
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+891
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+892
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+893
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+894
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SKILL_LINEID+895
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_CHARACTER_POINTS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MAX_TALENT_TIERS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_TRACK_CREATURES
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_TRACK_RESOURCES
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_TRACK_RESOURCES+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPERTISE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_OFFHAND_EXPERTISE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_RANGED_EXPERTISE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING_EXPERTISE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BLOCK_PERCENTAGE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_DODGE_PERCENTAGE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_DODGE_PERCENTAGE_FROM_ATTRIBUTE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PARRY_PERCENTAGE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PARRY_PERCENTAGE_FROM_ATTRIBUTE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_CRIT_PERCENTAGE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_RANGED_CRIT_PERCENTAGE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_OFFHAND_CRIT_PERCENTAGE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SPELL_CRIT_PERCENTAGE1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SHIELD_BLOCK
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SHIELD_BLOCK_CRIT_PERCENTAGE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MASTERY
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SPEED
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_AVOIDANCE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_STURDINESS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_VERSATILITY
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_VERSATILITY_BONUS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PVP_POWER_DAMAGE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PVP_POWER_HEALING
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+7
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+8
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+9
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+10
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+11
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+12
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+13
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+14
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+15
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+16
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+17
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+18
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+19
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+20
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+21
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+22
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+23
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+24
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+25
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+26
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+27
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+28
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+29
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+30
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+31
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+32
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+33
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+34
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+35
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+36
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+37
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+38
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+39
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+40
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+41
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+42
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+43
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+44
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+45
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+46
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+47
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+48
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+49
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+50
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+51
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+52
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+53
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+54
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+55
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+56
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+57
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+58
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+59
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+60
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+61
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+62
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+63
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+64
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+65
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+66
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+67
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+68
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+69
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+70
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+71
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+72
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+73
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+74
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+75
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+76
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+77
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+78
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+79
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+80
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+81
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+82
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+83
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+84
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+85
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+86
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+87
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+88
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+89
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+90
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+91
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+92
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+93
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+94
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+95
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+96
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+97
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+98
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+99
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+100
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+101
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+102
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+103
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+104
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+105
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+106
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+107
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+108
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+109
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+110
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+111
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+112
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+113
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+114
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+115
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+116
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+117
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+118
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+119
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+120
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+121
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+122
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+123
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+124
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+125
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+126
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+127
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+128
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+129
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+130
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+131
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+132
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+133
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+134
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+135
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+136
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+137
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+138
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+139
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+140
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+141
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+142
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+143
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+144
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+145
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+146
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+147
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+148
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+149
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+150
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+151
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+152
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+153
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+154
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+155
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+156
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+157
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+158
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+159
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+160
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+161
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+162
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+163
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+164
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+165
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+166
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+167
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+168
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+169
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+170
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+171
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+172
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+173
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+174
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+175
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+176
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+177
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+178
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+179
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+180
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+181
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+182
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+183
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+184
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+185
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+186
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+187
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+188
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+189
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+190
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+191
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+192
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+193
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+194
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+195
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+196
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+197
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+198
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+199
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+200
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+201
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+202
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+203
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+204
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+205
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+206
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+207
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+208
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+209
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+210
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+211
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+212
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+213
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+214
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+215
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+216
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+217
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+218
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+219
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+220
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+221
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+222
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+223
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+224
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+225
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+226
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+227
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+228
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+229
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+230
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+231
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+232
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+233
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+234
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+235
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+236
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+237
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+238
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+239
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+240
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+241
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+242
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+243
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+244
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+245
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+246
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+247
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+248
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+249
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+250
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+251
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+252
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+253
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+254
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+255
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+256
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+257
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+258
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+259
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+260
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+261
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+262
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+263
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+264
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+265
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+266
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+267
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+268
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+269
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+270
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+271
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+272
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+273
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+274
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+275
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+276
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+277
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+278
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+279
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+280
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+281
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+282
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+283
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+284
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+285
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+286
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+287
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+288
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+289
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+290
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+291
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+292
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+293
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+294
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+295
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+296
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+297
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+298
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+299
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+300
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+301
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+302
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+303
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+304
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+305
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+306
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+307
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+308
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+309
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+310
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+311
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+312
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+313
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+314
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+315
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+316
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+317
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+318
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+319
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_REST_INFO
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_REST_INFO+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_REST_INFO+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_REST_INFO+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_POS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_HEALING_PCT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_PCT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_PERIODIC_HEALING_DONE_PERCENT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_SPELL_POWER_PCT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_RESILIENCE_PERCENT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_TARGET_RESISTANCE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_LOCAL_FLAGS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BYTES
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PVP_MEDALS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+7
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+8
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+9
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+10
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_PRICE+11
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+7
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+8
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+9
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+10
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP+11
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_KILLS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_WATCHED_FACTION_INDEX
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+7
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+8
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+9
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+10
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+11
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+12
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+13
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+14
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+15
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+16
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+17
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+18
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+19
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+20
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+21
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+22
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+23
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+24
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+25
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+26
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+27
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+28
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+29
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+30
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_COMBAT_RATING+31
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+7
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+8
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+9
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+10
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+11
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+12
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+13
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+14
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+15
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+16
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+17
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+18
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+19
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+20
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+21
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+22
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+23
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+24
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+25
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+26
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+27
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+28
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+29
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+30
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+31
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+32
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+33
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+34
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+35
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+36
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+37
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+38
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+39
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+40
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+41
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+42
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+43
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+44
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+45
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+46
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+47
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+48
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+49
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+50
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+51
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+52
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO+53
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MAX_LEVEL
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MAX_CREATURE_SCALING_LEVEL
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_NO_REAGENT_COST
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_NO_REAGENT_COST+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_NO_REAGENT_COST+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_NO_REAGENT_COST+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PET_SPELL_POWER
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_UI_HIT_MODIFIER
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_UI_SPELL_HIT_MODIFIER
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_HOME_REALM_TIME_OFFSET
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_MOD_PET_HASTE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BYTES2
+    UF_FLAG_PUBLIC | UF_FLAG_URGENT_SELF_ONLY,              // ACTIVE_PLAYER_FIELD_BYTES3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_LFG_BONUS_FACTION_ID
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_LOOT_SPEC_ID
+    UF_FLAG_PUBLIC | UF_FLAG_URGENT_SELF_ONLY,              // ACTIVE_PLAYER_FIELD_OVERRIDE_ZONE_PVP_TYPE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BAG_SLOT_FLAGS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BAG_SLOT_FLAGS+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BAG_SLOT_FLAGS+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BAG_SLOT_FLAGS+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BANK_BAG_SLOT_FLAGS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_BANK_BAG_SLOT_FLAGS+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_INSERT_ITEMS_LEFT_TO_RIGHT
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+2
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+3
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+4
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+5
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+6
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+7
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+8
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+9
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+10
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+11
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+12
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+13
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+14
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+15
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+16
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+17
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+18
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+19
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+20
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+21
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+22
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+23
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+24
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+25
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+26
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+27
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+28
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+29
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+30
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+31
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+32
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+33
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+34
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+35
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+36
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+37
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+38
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+39
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+40
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+41
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+42
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+43
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+44
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+45
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+46
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+47
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+48
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+49
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+50
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+51
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+52
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+53
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+54
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+55
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+56
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+57
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+58
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+59
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+60
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+61
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+62
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+63
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+64
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+65
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+66
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+67
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+68
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+69
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+70
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+71
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+72
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+73
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+74
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+75
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+76
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+77
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+78
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+79
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+80
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+81
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+82
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+83
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+84
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+85
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+86
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+87
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+88
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+89
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+90
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+91
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+92
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+93
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+94
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+95
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+96
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+97
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+98
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+99
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+100
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+101
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+102
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+103
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+104
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+105
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+106
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+107
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+108
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+109
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+110
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+111
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+112
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+113
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+114
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+115
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+116
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+117
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+118
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+119
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+120
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+121
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+122
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+123
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+124
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+125
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+126
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+127
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+128
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+129
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+130
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+131
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+132
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+133
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+134
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+135
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+136
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+137
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+138
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+139
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+140
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+141
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+142
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+143
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+144
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+145
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+146
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+147
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+148
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+149
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+150
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+151
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+152
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+153
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+154
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+155
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+156
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+157
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+158
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+159
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+160
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+161
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+162
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+163
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+164
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+165
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+166
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+167
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+168
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+169
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+170
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+171
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+172
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+173
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+174
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+175
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+176
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+177
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+178
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+179
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+180
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+181
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+182
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+183
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+184
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+185
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+186
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+187
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+188
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+189
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+190
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+191
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+192
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+193
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+194
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+195
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+196
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+197
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+198
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+199
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+200
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+201
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+202
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+203
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+204
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+205
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+206
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+207
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+208
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+209
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+210
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+211
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+212
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+213
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+214
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+215
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+216
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+217
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+218
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+219
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+220
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+221
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+222
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+223
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+224
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+225
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+226
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+227
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+228
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+229
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+230
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+231
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+232
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+233
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+234
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+235
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+236
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+237
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+238
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+239
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+240
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+241
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+242
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+243
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+244
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+245
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+246
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+247
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+248
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+249
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+250
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+251
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+252
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+253
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+254
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+255
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+256
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+257
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+258
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+259
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+260
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+261
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+262
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+263
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+264
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+265
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+266
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+267
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+268
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+269
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+270
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+271
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+272
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+273
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+274
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+275
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+276
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+277
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+278
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+279
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+280
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+281
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+282
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+283
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+284
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+285
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+286
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+287
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+288
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+289
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+290
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+291
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+292
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+293
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+294
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+295
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+296
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+297
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+298
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+299
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+300
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+301
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+302
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+303
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+304
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+305
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+306
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+307
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+308
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+309
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+310
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+311
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+312
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+313
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+314
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+315
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+316
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+317
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+318
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+319
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+320
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+321
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+322
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+323
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+324
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+325
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+326
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+327
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+328
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+329
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+330
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+331
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+332
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+333
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+334
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+335
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+336
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+337
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+338
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+339
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+340
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+341
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+342
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+343
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+344
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+345
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+346
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+347
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+348
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+349
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+350
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+351
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+352
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+353
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+354
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+355
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+356
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+357
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+358
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+359
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+360
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+361
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+362
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+363
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+364
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+365
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+366
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+367
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+368
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+369
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+370
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+371
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+372
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+373
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+374
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+375
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+376
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+377
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+378
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+379
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+380
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+381
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+382
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+383
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+384
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+385
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+386
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+387
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+388
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+389
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+390
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+391
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+392
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+393
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+394
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+395
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+396
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+397
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+398
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+399
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+400
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+401
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+402
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+403
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+404
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+405
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+406
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+407
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+408
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+409
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+410
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+411
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+412
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+413
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+414
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+415
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+416
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+417
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+418
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+419
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+420
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+421
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+422
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+423
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+424
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+425
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+426
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+427
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+428
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+429
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+430
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+431
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+432
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+433
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+434
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+435
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+436
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+437
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+438
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+439
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+440
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+441
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+442
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+443
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+444
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+445
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+446
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+447
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+448
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+449
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+450
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+451
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+452
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+453
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+454
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+455
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+456
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+457
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+458
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+459
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+460
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+461
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+462
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+463
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+464
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+465
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+466
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+467
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+468
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+469
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+470
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+471
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+472
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+473
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+474
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+475
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+476
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+477
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+478
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+479
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+480
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+481
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+482
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+483
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+484
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+485
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+486
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+487
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+488
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+489
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+490
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+491
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+492
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+493
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+494
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+495
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+496
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+497
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+498
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+499
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+500
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+501
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+502
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+503
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+504
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+505
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+506
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+507
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+508
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+509
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+510
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+511
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+512
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+513
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+514
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+515
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+516
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+517
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+518
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+519
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+520
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+521
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+522
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+523
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+524
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+525
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+526
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+527
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+528
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+529
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+530
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+531
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+532
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+533
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+534
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+535
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+536
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+537
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+538
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+539
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+540
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+541
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+542
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+543
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+544
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+545
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+546
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+547
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+548
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+549
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+550
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+551
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+552
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+553
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+554
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+555
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+556
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+557
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+558
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+559
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+560
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+561
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+562
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+563
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+564
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+565
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+566
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+567
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+568
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+569
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+570
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+571
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+572
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+573
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+574
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+575
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+576
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+577
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+578
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+579
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+580
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+581
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+582
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+583
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+584
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+585
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+586
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+587
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+588
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+589
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+590
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+591
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+592
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+593
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+594
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+595
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+596
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+597
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+598
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+599
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+600
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+601
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+602
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+603
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+604
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+605
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+606
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+607
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+608
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+609
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+610
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+611
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+612
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+613
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+614
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+615
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+616
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+617
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+618
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+619
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+620
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+621
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+622
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+623
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+624
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+625
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+626
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+627
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+628
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+629
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+630
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+631
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+632
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+633
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+634
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+635
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+636
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+637
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+638
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+639
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+640
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+641
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+642
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+643
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+644
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+645
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+646
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+647
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+648
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+649
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+650
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+651
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+652
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+653
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+654
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+655
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+656
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+657
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+658
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+659
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+660
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+661
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+662
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+663
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+664
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+665
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+666
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+667
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+668
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+669
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+670
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+671
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+672
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+673
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+674
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+675
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+676
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+677
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+678
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+679
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+680
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+681
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+682
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+683
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+684
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+685
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+686
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+687
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+688
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+689
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+690
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+691
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+692
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+693
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+694
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+695
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+696
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+697
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+698
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+699
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+700
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+701
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+702
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+703
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+704
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+705
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+706
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+707
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+708
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+709
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+710
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+711
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+712
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+713
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+714
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+715
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+716
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+717
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+718
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+719
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+720
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+721
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+722
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+723
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+724
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+725
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+726
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+727
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+728
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+729
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+730
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+731
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+732
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+733
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+734
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+735
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+736
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+737
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+738
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+739
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+740
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+741
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+742
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+743
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+744
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+745
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+746
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+747
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+748
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+749
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+750
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+751
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+752
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+753
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+754
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+755
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+756
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+757
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+758
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+759
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+760
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+761
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+762
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+763
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+764
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+765
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+766
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+767
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+768
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+769
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+770
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+771
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+772
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+773
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+774
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+775
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+776
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+777
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+778
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+779
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+780
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+781
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+782
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+783
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+784
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+785
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+786
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+787
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+788
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+789
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+790
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+791
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+792
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+793
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+794
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+795
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+796
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+797
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+798
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+799
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+800
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+801
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+802
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+803
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+804
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+805
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+806
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+807
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+808
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+809
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+810
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+811
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+812
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+813
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+814
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+815
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+816
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+817
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+818
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+819
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+820
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+821
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+822
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+823
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+824
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+825
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+826
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+827
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+828
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+829
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+830
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+831
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+832
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+833
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+834
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+835
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+836
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+837
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+838
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+839
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+840
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+841
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+842
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+843
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+844
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+845
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+846
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+847
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+848
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+849
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+850
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+851
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+852
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+853
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+854
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+855
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+856
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+857
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+858
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+859
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+860
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+861
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+862
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+863
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+864
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+865
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+866
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+867
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+868
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+869
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+870
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+871
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+872
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+873
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+874
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+875
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+876
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+877
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+878
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+879
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+880
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+881
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+882
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+883
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+884
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+885
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+886
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+887
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+888
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+889
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+890
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+891
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+892
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+893
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+894
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+895
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+896
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+897
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+898
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+899
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+900
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+901
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+902
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+903
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+904
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+905
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+906
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+907
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+908
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+909
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+910
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+911
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+912
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+913
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+914
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+915
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+916
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+917
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+918
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+919
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+920
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+921
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+922
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+923
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+924
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+925
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+926
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+927
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+928
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+929
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+930
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+931
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+932
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+933
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+934
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+935
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+936
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+937
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+938
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+939
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+940
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+941
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+942
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+943
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+944
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+945
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+946
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+947
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+948
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+949
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+950
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+951
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+952
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+953
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+954
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+955
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+956
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+957
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+958
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+959
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+960
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+961
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+962
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+963
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+964
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+965
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+966
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+967
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+968
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+969
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+970
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+971
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+972
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+973
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+974
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+975
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+976
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+977
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+978
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+979
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+980
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+981
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+982
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+983
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+984
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+985
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+986
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+987
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+988
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+989
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+990
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+991
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+992
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+993
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+994
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+995
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+996
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+997
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+998
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+999
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1000
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1001
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1002
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1003
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1004
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1005
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1006
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1007
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1008
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1009
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1010
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1011
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1012
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1013
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1014
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1015
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1016
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1017
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1018
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1019
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1020
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1021
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1022
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1023
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1024
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1025
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1026
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1027
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1028
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1029
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1030
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1031
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1032
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1033
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1034
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1035
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1036
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1037
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1038
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1039
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1040
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1041
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1042
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1043
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1044
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1045
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1046
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1047
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1048
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1049
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1050
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1051
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1052
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1053
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1054
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1055
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1056
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1057
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1058
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1059
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1060
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1061
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1062
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1063
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1064
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1065
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1066
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1067
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1068
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1069
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1070
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1071
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1072
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1073
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1074
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1075
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1076
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1077
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1078
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1079
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1080
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1081
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1082
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1083
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1084
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1085
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1086
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1087
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1088
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1089
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1090
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1091
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1092
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1093
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1094
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1095
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1096
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1097
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1098
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1099
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1100
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1101
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1102
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1103
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1104
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1105
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1106
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1107
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1108
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1109
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1110
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1111
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1112
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1113
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1114
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1115
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1116
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1117
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1118
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1119
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1120
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1121
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1122
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1123
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1124
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1125
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1126
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1127
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1128
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1129
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1130
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1131
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1132
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1133
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1134
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1135
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1136
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1137
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1138
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1139
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1140
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1141
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1142
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1143
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1144
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1145
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1146
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1147
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1148
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1149
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1150
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1151
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1152
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1153
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1154
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1155
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1156
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1157
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1158
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1159
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1160
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1161
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1162
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1163
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1164
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1165
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1166
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1167
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1168
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1169
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1170
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1171
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1172
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1173
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1174
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1175
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1176
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1177
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1178
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1179
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1180
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1181
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1182
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1183
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1184
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1185
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1186
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1187
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1188
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1189
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1190
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1191
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1192
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1193
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1194
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1195
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1196
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1197
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1198
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1199
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1200
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1201
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1202
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1203
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1204
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1205
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1206
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1207
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1208
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1209
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1210
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1211
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1212
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1213
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1214
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1215
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1216
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1217
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1218
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1219
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1220
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1221
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1222
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1223
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1224
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1225
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1226
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1227
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1228
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1229
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1230
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1231
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1232
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1233
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1234
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1235
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1236
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1237
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1238
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1239
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1240
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1241
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1242
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1243
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1244
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1245
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1246
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1247
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1248
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1249
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1250
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1251
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1252
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1253
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1254
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1255
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1256
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1257
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1258
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1259
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1260
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1261
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1262
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1263
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1264
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1265
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1266
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1267
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1268
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1269
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1270
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1271
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1272
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1273
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1274
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1275
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1276
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1277
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1278
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1279
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1280
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1281
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1282
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1283
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1284
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1285
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1286
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1287
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1288
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1289
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1290
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1291
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1292
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1293
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1294
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1295
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1296
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1297
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1298
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1299
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1300
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1301
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1302
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1303
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1304
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1305
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1306
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1307
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1308
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1309
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1310
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1311
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1312
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1313
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1314
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1315
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1316
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1317
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1318
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1319
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1320
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1321
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1322
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1323
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1324
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1325
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1326
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1327
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1328
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1329
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1330
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1331
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1332
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1333
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1334
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1335
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1336
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1337
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1338
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1339
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1340
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1341
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1342
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1343
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1344
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1345
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1346
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1347
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1348
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1349
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1350
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1351
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1352
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1353
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1354
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1355
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1356
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1357
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1358
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1359
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1360
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1361
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1362
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1363
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1364
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1365
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1366
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1367
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1368
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1369
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1370
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1371
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1372
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1373
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1374
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1375
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1376
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1377
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1378
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1379
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1380
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1381
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1382
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1383
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1384
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1385
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1386
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1387
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1388
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1389
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1390
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1391
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1392
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1393
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1394
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1395
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1396
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1397
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1398
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1399
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1400
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1401
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1402
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1403
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1404
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1405
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1406
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1407
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1408
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1409
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1410
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1411
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1412
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1413
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1414
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1415
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1416
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1417
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1418
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1419
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1420
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1421
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1422
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1423
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1424
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1425
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1426
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1427
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1428
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1429
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1430
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1431
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1432
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1433
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1434
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1435
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1436
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1437
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1438
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1439
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1440
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1441
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1442
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1443
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1444
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1445
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1446
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1447
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1448
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1449
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1450
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1451
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1452
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1453
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1454
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1455
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1456
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1457
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1458
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1459
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1460
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1461
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1462
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1463
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1464
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1465
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1466
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1467
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1468
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1469
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1470
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1471
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1472
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1473
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1474
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1475
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1476
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1477
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1478
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1479
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1480
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1481
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1482
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1483
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1484
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1485
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1486
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1487
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1488
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1489
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1490
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1491
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1492
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1493
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1494
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1495
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1496
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1497
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1498
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1499
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1500
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1501
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1502
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1503
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1504
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1505
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1506
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1507
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1508
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1509
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1510
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1511
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1512
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1513
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1514
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1515
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1516
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1517
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1518
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1519
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1520
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1521
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1522
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1523
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1524
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1525
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1526
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1527
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1528
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1529
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1530
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1531
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1532
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1533
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1534
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1535
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1536
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1537
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1538
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1539
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1540
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1541
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1542
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1543
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1544
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1545
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1546
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1547
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1548
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1549
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1550
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1551
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1552
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1553
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1554
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1555
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1556
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1557
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1558
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1559
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1560
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1561
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1562
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1563
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1564
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1565
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1566
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1567
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1568
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1569
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1570
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1571
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1572
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1573
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1574
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1575
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1576
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1577
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1578
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1579
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1580
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1581
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1582
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1583
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1584
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1585
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1586
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1587
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1588
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1589
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1590
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1591
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1592
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1593
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1594
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1595
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1596
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1597
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1598
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1599
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1600
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1601
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1602
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1603
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1604
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1605
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1606
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1607
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1608
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1609
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1610
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1611
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1612
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1613
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1614
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1615
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1616
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1617
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1618
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1619
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1620
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1621
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1622
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1623
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1624
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1625
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1626
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1627
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1628
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1629
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1630
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1631
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1632
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1633
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1634
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1635
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1636
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1637
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1638
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1639
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1640
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1641
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1642
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1643
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1644
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1645
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1646
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1647
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1648
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1649
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1650
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1651
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1652
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1653
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1654
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1655
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1656
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1657
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1658
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1659
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1660
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1661
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1662
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1663
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1664
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1665
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1666
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1667
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1668
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1669
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1670
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1671
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1672
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1673
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1674
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1675
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1676
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1677
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1678
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1679
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1680
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1681
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1682
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1683
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1684
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1685
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1686
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1687
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1688
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1689
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1690
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1691
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1692
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1693
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1694
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1695
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1696
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1697
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1698
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1699
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1700
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1701
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1702
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1703
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1704
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1705
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1706
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1707
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1708
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1709
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1710
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1711
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1712
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1713
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1714
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1715
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1716
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1717
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1718
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1719
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1720
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1721
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1722
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1723
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1724
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1725
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1726
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1727
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1728
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1729
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1730
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1731
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1732
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1733
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1734
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1735
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1736
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1737
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1738
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1739
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1740
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1741
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1742
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1743
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1744
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1745
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1746
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1747
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1748
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_QUEST_COMPLETED+1749
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_HONOR
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_HONOR_NEXT_LEVEL
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PVP_TIER_MAX_FROM_WINS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_FIELD_PVP_LAST_WEEKS_TIER_MAX_FROM_WINS
 };
 
-uint32 UnitDynamicUpdateFieldFlags[PLAYER_DYNAMIC_END] =
+uint32 UnitDynamicUpdateFieldFlags[ACTIVE_PLAYER_DYNAMIC_END] =
 {
     UF_FLAG_PUBLIC | UF_FLAG_URGENT,                        // UNIT_DYNAMIC_FIELD_PASSIVE_SPELLS
     UF_FLAG_PUBLIC | UF_FLAG_URGENT,                        // UNIT_DYNAMIC_FIELD_WORLD_EFFECTS
     UF_FLAG_PUBLIC | UF_FLAG_URGENT,                        // UNIT_DYNAMIC_FIELD_CHANNEL_OBJECTS
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_RESERACH_SITE
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_RESEARCH_SITE_PROGRESS
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_DAILY_QUESTS
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_AVAILABLE_QUEST_LINE_X_QUEST_ID
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_HEIRLOOMS
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_TOYS
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_TRANSMOG
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_CHARACTER_RESTRICTIONS
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_SPELL_PCT_MOD_BY_LABEL
-    UF_FLAG_PRIVATE,                                        // PLAYER_DYNAMIC_FIELD_SPELL_FLAT_MOD_BY_LABEL
     UF_FLAG_PUBLIC,                                         // PLAYER_DYNAMIC_FIELD_ARENA_COOLDOWNS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_RESERACH_SITE
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_RESEARCH_SITE_PROGRESS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_AVAILABLE_QUEST_LINE_X_QUEST_ID
+    UF_FLAG_NONE,                                           //
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOMS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_TOYS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_TRANSMOG
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_CHARACTER_RESTRICTIONS
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_SPELL_PCT_MOD_BY_LABEL
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_SPELL_FLAT_MOD_BY_LABEL
+    UF_FLAG_PUBLIC,                                         // ACTIVE_PLAYER_DYNAMIC_FIELD_RESERACH
 };
 
 uint32 GameObjectUpdateFieldFlags[GAMEOBJECT_END] =
@@ -4916,11 +6341,6 @@ uint32 GameObjectUpdateFieldFlags[GAMEOBJECT_END] =
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+1
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+2
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_TYPE
     UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
@@ -4928,6 +6348,10 @@ uint32 GameObjectUpdateFieldFlags[GAMEOBJECT_END] =
     UF_FLAG_PUBLIC,                                         // GAMEOBJECT_FIELD_CREATED_BY+1
     UF_FLAG_PUBLIC,                                         // GAMEOBJECT_FIELD_CREATED_BY+2
     UF_FLAG_PUBLIC,                                         // GAMEOBJECT_FIELD_CREATED_BY+3
+    UF_FLAG_PUBLIC,                                         // GAMEOBJECT_FIELD_GUILD_GUID
+    UF_FLAG_PUBLIC,                                         // GAMEOBJECT_FIELD_GUILD_GUID+1
+    UF_FLAG_PUBLIC,                                         // GAMEOBJECT_FIELD_GUILD_GUID+2
+    UF_FLAG_PUBLIC,                                         // GAMEOBJECT_FIELD_GUILD_GUID+3
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // GAMEOBJECT_DISPLAYID
     UF_FLAG_PUBLIC | UF_FLAG_URGENT,                        // GAMEOBJECT_FLAGS
     UF_FLAG_PUBLIC,                                         // GAMEOBJECT_PARENTROTATION
@@ -4945,6 +6369,7 @@ uint32 GameObjectUpdateFieldFlags[GAMEOBJECT_END] =
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // GAMEOBJECT_STATE_WORLD_EFFECT_ID+1
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // GAMEOBJECT_STATE_WORLD_EFFECT_ID+2
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // GAMEOBJECT_STATE_WORLD_EFFECT_ID+3
+    UF_FLAG_PUBLIC | UF_FLAG_URGENT,                        // GAMEOBJECT_FIELD_CUSTOM_PARAM
 };
 
 uint32 GameObjectDynamicUpdateFieldFlags[GAMEOBJECT_DYNAMIC_END] =
@@ -4958,11 +6383,6 @@ uint32 DynamicObjectUpdateFieldFlags[DYNAMICOBJECT_END] =
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+1
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+2
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_TYPE
     UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
@@ -4983,11 +6403,6 @@ uint32 CorpseUpdateFieldFlags[CORPSE_END] =
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+1
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+2
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_TYPE
     UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
@@ -4999,6 +6414,10 @@ uint32 CorpseUpdateFieldFlags[CORPSE_END] =
     UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_PARTY+1
     UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_PARTY+2
     UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_PARTY+3
+    UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_GUILD_GUID
+    UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_GUILD_GUID+1
+    UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_GUILD_GUID+2
+    UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_GUILD_GUID+3
     UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_DISPLAY_ID
     UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_ITEM
     UF_FLAG_PUBLIC,                                         // CORPSE_FIELD_ITEM+1
@@ -5033,11 +6452,6 @@ uint32 AreaTriggerUpdateFieldFlags[AREATRIGGER_END] =
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+1
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+2
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_TYPE
     UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
@@ -5080,11 +6494,6 @@ uint32 SceneObjectUpdateFieldFlags[SCENEOBJECT_END] =
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+1
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+2
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_TYPE
     UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
@@ -5103,11 +6512,6 @@ uint32 ConversationUpdateFieldFlags[CONVERSATION_END] =
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+1
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+2
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_GUID+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+1
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+2
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_DATA+3
-    UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_TYPE
     UF_FLAG_DYNAMIC,                                        // OBJECT_FIELD_ENTRY
     UF_FLAG_DYNAMIC | UF_FLAG_URGENT,                       // OBJECT_DYNAMIC_FLAGS
     UF_FLAG_PUBLIC,                                         // OBJECT_FIELD_SCALE_X
diff --git a/src/server/game/Entities/Object/Updates/UpdateFieldFlags.h b/src/server/game/Entities/Object/Updates/UpdateFieldFlags.h
index d5c151ee4a9..97523f323e3 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFieldFlags.h
+++ b/src/server/game/Entities/Object/Updates/UpdateFieldFlags.h
@@ -37,10 +37,12 @@ enum UpdatefieldFlags
     UF_FLAG_URGENT_SELF_ONLY    = 0x400
 };
 
-TC_GAME_API extern uint32 ItemUpdateFieldFlags[CONTAINER_END];
+TC_GAME_API extern uint32 ContainerUpdateFieldFlags[CONTAINER_END];
+TC_GAME_API extern uint32 AzeriteEmpoweredItemUpdateFieldFlags[AZERITE_EMPOWERED_ITEM_END];
+TC_GAME_API extern uint32 AzeriteItemUpdateFieldFlags[AZERITE_ITEM_END];
 TC_GAME_API extern uint32 ItemDynamicUpdateFieldFlags[CONTAINER_DYNAMIC_END];
-TC_GAME_API extern uint32 UnitUpdateFieldFlags[PLAYER_END];
-TC_GAME_API extern uint32 UnitDynamicUpdateFieldFlags[PLAYER_DYNAMIC_END];
+TC_GAME_API extern uint32 UnitUpdateFieldFlags[ACTIVE_PLAYER_END];
+TC_GAME_API extern uint32 UnitDynamicUpdateFieldFlags[ACTIVE_PLAYER_DYNAMIC_END];
 TC_GAME_API extern uint32 GameObjectUpdateFieldFlags[GAMEOBJECT_END];
 TC_GAME_API extern uint32 GameObjectDynamicUpdateFieldFlags[GAMEOBJECT_DYNAMIC_END];
 TC_GAME_API extern uint32 DynamicObjectUpdateFieldFlags[DYNAMICOBJECT_END];
diff --git a/src/server/game/Entities/Object/Updates/UpdateFields.h b/src/server/game/Entities/Object/Updates/UpdateFields.h
index 6fb0a5d952c..ca3410f5dfd 100644
--- a/src/server/game/Entities/Object/Updates/UpdateFields.h
+++ b/src/server/game/Entities/Object/Updates/UpdateFields.h
@@ -19,17 +19,15 @@
 #ifndef _UPDATEFIELDS_H
 #define _UPDATEFIELDS_H
 
-// Auto generated for version 7, 3, 5, 25928
+// Auto generated for version 8, 0, 1, 27980
 
 enum ObjectFields
 {
     OBJECT_FIELD_GUID                                      = 0x000, // Size: 4, Flags: PUBLIC
-    OBJECT_FIELD_DATA                                      = 0x004, // Size: 4, Flags: PUBLIC
-    OBJECT_FIELD_TYPE                                      = 0x008, // Size: 1, Flags: PUBLIC
-    OBJECT_FIELD_ENTRY                                     = 0x009, // Size: 1, Flags: DYNAMIC
-    OBJECT_DYNAMIC_FLAGS                                   = 0x00A, // Size: 1, Flags: DYNAMIC, URGENT
-    OBJECT_FIELD_SCALE_X                                   = 0x00B, // Size: 1, Flags: PUBLIC
-    OBJECT_END                                             = 0x00C,
+    OBJECT_FIELD_ENTRY                                     = 0x004, // Size: 1, Flags: DYNAMIC
+    OBJECT_DYNAMIC_FLAGS                                   = 0x005, // Size: 1, Flags: DYNAMIC, URGENT
+    OBJECT_FIELD_SCALE_X                                   = 0x006, // Size: 1, Flags: PUBLIC
+    OBJECT_END                                             = 0x007,
 };
 
 enum ObjectDynamicFields
@@ -66,8 +64,7 @@ enum ItemDynamicFields
     ITEM_DYNAMIC_FIELD_BONUSLIST_IDS                       = OBJECT_DYNAMIC_END + 0x001, // Flags: OWNER, 0x100
     ITEM_DYNAMIC_FIELD_ARTIFACT_POWERS                     = OBJECT_DYNAMIC_END + 0x002, // Flags: OWNER
     ITEM_DYNAMIC_FIELD_GEMS                                = OBJECT_DYNAMIC_END + 0x003, // Flags: OWNER
-    ITEM_DYNAMIC_FIELD_RELIC_TALENT_DATA                   = OBJECT_DYNAMIC_END + 0x004, // Flags: OWNER
-    ITEM_DYNAMIC_END                                       = OBJECT_DYNAMIC_END + 0x005,
+    ITEM_DYNAMIC_END                                       = OBJECT_DYNAMIC_END + 0x004,
 };
 
 enum ContainerFields
@@ -82,6 +79,32 @@ enum ContainerDynamicFields
     CONTAINER_DYNAMIC_END                                  = ITEM_DYNAMIC_END + 0x000,
 };
 
+enum AzeriteEmpoweredItemField
+{
+    AZERITE_EMPOWERED_ITEM_FIELD_SELECTIONS                = ITEM_END + 0x000, // Size: 4, Flags: PUBLIC
+    AZERITE_EMPOWERED_ITEM_END                             = ITEM_END + 0x004,
+};
+
+enum AzeriteEmpoweredItemDynamicField
+{
+    AZERITE_EMPOWERED_ITEM_DYNAMIC_END                     = ITEM_DYNAMIC_END + 0x000,
+};
+
+enum AzeriteItemField
+{
+    AZERITE_ITEM_FIELD_XP                                  = ITEM_END + 0x000, // Size: 2, Flags: PUBLIC
+    AZERITE_ITEM_FIELD_LEVEL                               = ITEM_END + 0x002, // Size: 1, Flags: PUBLIC
+    AZERITE_ITEM_FIELD_AURA_LEVEL                          = ITEM_END + 0x003, // Size: 1, Flags: PUBLIC
+    AZERITE_ITEM_FIELD_KNOWLEDGE_LEVEL                     = ITEM_END + 0x004, // Size: 1, Flags: OWNER
+    AZERITE_ITEM_FIELD_DEBUG_KNOWLEDGE_WEEK                = ITEM_END + 0x005, // Size: 1, Flags: OWNER
+    AZERITE_ITEM_END                                       = ITEM_END + 0x006,
+};
+
+enum AzeriteItemDynamicField
+{
+    AZERITE_ITEM_DYNAMIC_END                               = ITEM_DYNAMIC_END + 0x000,
+};
+
 enum UnitFields
 {
     UNIT_FIELD_CHARM                                       = OBJECT_END + 0x000, // Size: 4, Flags: PUBLIC
@@ -91,98 +114,106 @@ enum UnitFields
     UNIT_FIELD_SUMMONEDBY                                  = OBJECT_END + 0x010, // Size: 4, Flags: PUBLIC
     UNIT_FIELD_CREATEDBY                                   = OBJECT_END + 0x014, // Size: 4, Flags: PUBLIC
     UNIT_FIELD_DEMON_CREATOR                               = OBJECT_END + 0x018, // Size: 4, Flags: PUBLIC
-    UNIT_FIELD_TARGET                                      = OBJECT_END + 0x01C, // Size: 4, Flags: PUBLIC
-    UNIT_FIELD_BATTLE_PET_COMPANION_GUID                   = OBJECT_END + 0x020, // Size: 4, Flags: PUBLIC
-    UNIT_FIELD_BATTLE_PET_DB_ID                            = OBJECT_END + 0x024, // Size: 2, Flags: PUBLIC
-    UNIT_FIELD_CHANNEL_DATA                                = OBJECT_END + 0x026, // Size: 2, Flags: PUBLIC, URGENT
-    UNIT_FIELD_SUMMONED_BY_HOME_REALM                      = OBJECT_END + 0x028, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_BYTES_0                                     = OBJECT_END + 0x029, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_DISPLAY_POWER                               = OBJECT_END + 0x02A, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_OVERRIDE_DISPLAY_POWER_ID                   = OBJECT_END + 0x02B, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_HEALTH                                      = OBJECT_END + 0x02C, // Size: 2, Flags: PUBLIC
-    UNIT_FIELD_POWER                                       = OBJECT_END + 0x02E, // Size: 6, Flags: PUBLIC, URGENT_SELF_ONLY
-    UNIT_FIELD_MAXHEALTH                                   = OBJECT_END + 0x034, // Size: 2, Flags: PUBLIC
-    UNIT_FIELD_MAXPOWER                                    = OBJECT_END + 0x036, // Size: 6, Flags: PUBLIC
-    UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER                   = OBJECT_END + 0x03C, // Size: 6, Flags: PRIVATE, OWNER, UNIT_ALL
-    UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER       = OBJECT_END + 0x042, // Size: 6, Flags: PRIVATE, OWNER, UNIT_ALL
-    UNIT_FIELD_LEVEL                                       = OBJECT_END + 0x048, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_EFFECTIVE_LEVEL                             = OBJECT_END + 0x049, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_SANDBOX_SCALING_ID                          = OBJECT_END + 0x04A, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_SCALING_LEVEL_MIN                           = OBJECT_END + 0x04B, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_SCALING_LEVEL_MAX                           = OBJECT_END + 0x04C, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_SCALING_LEVEL_DELTA                         = OBJECT_END + 0x04D, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_FACTIONTEMPLATE                             = OBJECT_END + 0x04E, // Size: 1, Flags: PUBLIC
-    UNIT_VIRTUAL_ITEM_SLOT_ID                              = OBJECT_END + 0x04F, // Size: 6, Flags: PUBLIC
-    UNIT_FIELD_FLAGS                                       = OBJECT_END + 0x055, // Size: 1, Flags: PUBLIC, URGENT
-    UNIT_FIELD_FLAGS_2                                     = OBJECT_END + 0x056, // Size: 1, Flags: PUBLIC, URGENT
-    UNIT_FIELD_FLAGS_3                                     = OBJECT_END + 0x057, // Size: 1, Flags: PUBLIC, URGENT
-    UNIT_FIELD_AURASTATE                                   = OBJECT_END + 0x058, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_BASEATTACKTIME                              = OBJECT_END + 0x059, // Size: 2, Flags: PUBLIC
-    UNIT_FIELD_RANGEDATTACKTIME                            = OBJECT_END + 0x05B, // Size: 1, Flags: PRIVATE
-    UNIT_FIELD_BOUNDINGRADIUS                              = OBJECT_END + 0x05C, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_COMBATREACH                                 = OBJECT_END + 0x05D, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_DISPLAYID                                   = OBJECT_END + 0x05E, // Size: 1, Flags: DYNAMIC, URGENT
-    UNIT_FIELD_NATIVEDISPLAYID                             = OBJECT_END + 0x05F, // Size: 1, Flags: PUBLIC, URGENT
-    UNIT_FIELD_MOUNTDISPLAYID                              = OBJECT_END + 0x060, // Size: 1, Flags: PUBLIC, URGENT
-    UNIT_FIELD_MINDAMAGE                                   = OBJECT_END + 0x061, // Size: 1, Flags: PRIVATE, OWNER, SPECIAL_INFO
-    UNIT_FIELD_MAXDAMAGE                                   = OBJECT_END + 0x062, // Size: 1, Flags: PRIVATE, OWNER, SPECIAL_INFO
-    UNIT_FIELD_MINOFFHANDDAMAGE                            = OBJECT_END + 0x063, // Size: 1, Flags: PRIVATE, OWNER, SPECIAL_INFO
-    UNIT_FIELD_MAXOFFHANDDAMAGE                            = OBJECT_END + 0x064, // Size: 1, Flags: PRIVATE, OWNER, SPECIAL_INFO
-    UNIT_FIELD_BYTES_1                                     = OBJECT_END + 0x065, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_PETNUMBER                                   = OBJECT_END + 0x066, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_PET_NAME_TIMESTAMP                          = OBJECT_END + 0x067, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_PETEXPERIENCE                               = OBJECT_END + 0x068, // Size: 1, Flags: OWNER
-    UNIT_FIELD_PETNEXTLEVELEXP                             = OBJECT_END + 0x069, // Size: 1, Flags: OWNER
-    UNIT_MOD_CAST_SPEED                                    = OBJECT_END + 0x06A, // Size: 1, Flags: PUBLIC
-    UNIT_MOD_CAST_HASTE                                    = OBJECT_END + 0x06B, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_MOD_HASTE                                   = OBJECT_END + 0x06C, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_MOD_RANGED_HASTE                            = OBJECT_END + 0x06D, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_MOD_HASTE_REGEN                             = OBJECT_END + 0x06E, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_MOD_TIME_RATE                               = OBJECT_END + 0x06F, // Size: 1, Flags: PUBLIC
-    UNIT_CREATED_BY_SPELL                                  = OBJECT_END + 0x070, // Size: 1, Flags: PUBLIC
-    UNIT_NPC_FLAGS                                         = OBJECT_END + 0x071, // Size: 2, Flags: PUBLIC, DYNAMIC
-    UNIT_NPC_EMOTESTATE                                    = OBJECT_END + 0x073, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_STAT                                        = OBJECT_END + 0x074, // Size: 4, Flags: PRIVATE, OWNER
-    UNIT_FIELD_POSSTAT                                     = OBJECT_END + 0x078, // Size: 4, Flags: PRIVATE, OWNER
-    UNIT_FIELD_NEGSTAT                                     = OBJECT_END + 0x07C, // Size: 4, Flags: PRIVATE, OWNER
-    UNIT_FIELD_RESISTANCES                                 = OBJECT_END + 0x080, // Size: 7, Flags: PRIVATE, OWNER, SPECIAL_INFO
-    UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE                  = OBJECT_END + 0x087, // Size: 7, Flags: PRIVATE, OWNER
-    UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE                  = OBJECT_END + 0x08E, // Size: 7, Flags: PRIVATE, OWNER
-    UNIT_FIELD_MOD_BONUS_ARMOR                             = OBJECT_END + 0x095, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_BASE_MANA                                   = OBJECT_END + 0x096, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_BASE_HEALTH                                 = OBJECT_END + 0x097, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_BYTES_2                                     = OBJECT_END + 0x098, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_ATTACK_POWER                                = OBJECT_END + 0x099, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_ATTACK_POWER_MOD_POS                        = OBJECT_END + 0x09A, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_ATTACK_POWER_MOD_NEG                        = OBJECT_END + 0x09B, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_ATTACK_POWER_MULTIPLIER                     = OBJECT_END + 0x09C, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_RANGED_ATTACK_POWER                         = OBJECT_END + 0x09D, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS                 = OBJECT_END + 0x09E, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_RANGED_ATTACK_POWER_MOD_NEG                 = OBJECT_END + 0x09F, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER              = OBJECT_END + 0x0A0, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_ATTACK_SPEED_AURA                           = OBJECT_END + 0x0A1, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_MINRANGEDDAMAGE                             = OBJECT_END + 0x0A2, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_MAXRANGEDDAMAGE                             = OBJECT_END + 0x0A3, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_POWER_COST_MODIFIER                         = OBJECT_END + 0x0A4, // Size: 7, Flags: PRIVATE, OWNER
-    UNIT_FIELD_POWER_COST_MULTIPLIER                       = OBJECT_END + 0x0AB, // Size: 7, Flags: PRIVATE, OWNER
-    UNIT_FIELD_MAXHEALTHMODIFIER                           = OBJECT_END + 0x0B2, // Size: 1, Flags: PRIVATE, OWNER
-    UNIT_FIELD_HOVERHEIGHT                                 = OBJECT_END + 0x0B3, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_MIN_ITEM_LEVEL_CUTOFF                       = OBJECT_END + 0x0B4, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_MIN_ITEM_LEVEL                              = OBJECT_END + 0x0B5, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_MAXITEMLEVEL                                = OBJECT_END + 0x0B6, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_WILD_BATTLEPET_LEVEL                        = OBJECT_END + 0x0B7, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_BATTLEPET_COMPANION_NAME_TIMESTAMP          = OBJECT_END + 0x0B8, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_INTERACT_SPELLID                            = OBJECT_END + 0x0B9, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_STATE_SPELL_VISUAL_ID                       = OBJECT_END + 0x0BA, // Size: 1, Flags: DYNAMIC, URGENT
-    UNIT_FIELD_STATE_ANIM_ID                               = OBJECT_END + 0x0BB, // Size: 1, Flags: DYNAMIC, URGENT
-    UNIT_FIELD_STATE_ANIM_KIT_ID                           = OBJECT_END + 0x0BC, // Size: 1, Flags: DYNAMIC, URGENT
-    UNIT_FIELD_STATE_WORLD_EFFECT_ID                       = OBJECT_END + 0x0BD, // Size: 4, Flags: DYNAMIC, URGENT
-    UNIT_FIELD_SCALE_DURATION                              = OBJECT_END + 0x0C1, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_LOOKS_LIKE_MOUNT_ID                         = OBJECT_END + 0x0C2, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_LOOKS_LIKE_CREATURE_ID                      = OBJECT_END + 0x0C3, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_LOOK_AT_CONTROLLER_ID                       = OBJECT_END + 0x0C4, // Size: 1, Flags: PUBLIC
-    UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET                   = OBJECT_END + 0x0C5, // Size: 4, Flags: PUBLIC
-    UNIT_END                                               = OBJECT_END + 0x0C9,
+    UNIT_FIELD_LOOK_AT_CONTROLLER_TARGET                   = OBJECT_END + 0x01C, // Size: 4, Flags: PUBLIC
+    UNIT_FIELD_TARGET                                      = OBJECT_END + 0x020, // Size: 4, Flags: PUBLIC
+    UNIT_FIELD_BATTLE_PET_COMPANION_GUID                   = OBJECT_END + 0x024, // Size: 4, Flags: PUBLIC
+    UNIT_FIELD_BATTLE_PET_DB_ID                            = OBJECT_END + 0x028, // Size: 2, Flags: PUBLIC
+    UNIT_FIELD_CHANNEL_DATA                                = OBJECT_END + 0x02A, // Size: 2, Flags: PUBLIC, URGENT
+    UNIT_FIELD_SUMMONED_BY_HOME_REALM                      = OBJECT_END + 0x02C, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_BYTES_0                                     = OBJECT_END + 0x02D, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_DISPLAY_POWER                               = OBJECT_END + 0x02E, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_OVERRIDE_DISPLAY_POWER_ID                   = OBJECT_END + 0x02F, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_HEALTH                                      = OBJECT_END + 0x030, // Size: 2, Flags: PUBLIC
+    UNIT_FIELD_POWER                                       = OBJECT_END + 0x032, // Size: 6, Flags: PUBLIC, URGENT_SELF_ONLY
+    UNIT_FIELD_MAXHEALTH                                   = OBJECT_END + 0x038, // Size: 2, Flags: PUBLIC
+    UNIT_FIELD_MAXPOWER                                    = OBJECT_END + 0x03A, // Size: 6, Flags: PUBLIC
+    UNIT_FIELD_POWER_REGEN_FLAT_MODIFIER                   = OBJECT_END + 0x040, // Size: 6, Flags: PRIVATE, OWNER, UNIT_ALL
+    UNIT_FIELD_POWER_REGEN_INTERRUPTED_FLAT_MODIFIER       = OBJECT_END + 0x046, // Size: 6, Flags: PRIVATE, OWNER, UNIT_ALL
+    UNIT_FIELD_LEVEL                                       = OBJECT_END + 0x04C, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_EFFECTIVE_LEVEL                             = OBJECT_END + 0x04D, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_CONTENT_TUNING_ID                           = OBJECT_END + 0x04E, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_SCALING_LEVEL_MIN                           = OBJECT_END + 0x04F, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_SCALING_LEVEL_MAX                           = OBJECT_END + 0x050, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_SCALING_LEVEL_DELTA                         = OBJECT_END + 0x051, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_SCALING_FACTION_GROUP                       = OBJECT_END + 0x052, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_SCALING_HEALTH_ITEM_LEVEL_CURVE_ID          = OBJECT_END + 0x053, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_SCALING_DAMAGE_ITEM_LEVEL_CURVE_ID          = OBJECT_END + 0x054, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_FACTIONTEMPLATE                             = OBJECT_END + 0x055, // Size: 1, Flags: PUBLIC
+    UNIT_VIRTUAL_ITEM_SLOT_ID                              = OBJECT_END + 0x056, // Size: 6, Flags: PUBLIC
+    UNIT_FIELD_FLAGS                                       = OBJECT_END + 0x05C, // Size: 1, Flags: PUBLIC, URGENT
+    UNIT_FIELD_FLAGS_2                                     = OBJECT_END + 0x05D, // Size: 1, Flags: PUBLIC, URGENT
+    UNIT_FIELD_FLAGS_3                                     = OBJECT_END + 0x05E, // Size: 1, Flags: PUBLIC, URGENT
+    UNIT_FIELD_AURASTATE                                   = OBJECT_END + 0x05F, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_BASEATTACKTIME                              = OBJECT_END + 0x060, // Size: 2, Flags: PUBLIC
+    UNIT_FIELD_RANGEDATTACKTIME                            = OBJECT_END + 0x062, // Size: 1, Flags: PRIVATE
+    UNIT_FIELD_BOUNDINGRADIUS                              = OBJECT_END + 0x063, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_COMBATREACH                                 = OBJECT_END + 0x064, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_DISPLAYID                                   = OBJECT_END + 0x065, // Size: 1, Flags: DYNAMIC, URGENT
+    UNIT_FIELD_DISPLAY_SCALE                               = OBJECT_END + 0x066, // Size: 1, Flags: DYNAMIC, URGENT
+    UNIT_FIELD_NATIVEDISPLAYID                             = OBJECT_END + 0x067, // Size: 1, Flags: PUBLIC, URGENT
+    UNIT_FIELD_NATIVE_X_DISPLAY_SCALE                      = OBJECT_END + 0x068, // Size: 1, Flags: PUBLIC, URGENT
+    UNIT_FIELD_MOUNTDISPLAYID                              = OBJECT_END + 0x069, // Size: 1, Flags: PUBLIC, URGENT
+    UNIT_FIELD_MINDAMAGE                                   = OBJECT_END + 0x06A, // Size: 1, Flags: PRIVATE, OWNER, SPECIAL_INFO
+    UNIT_FIELD_MAXDAMAGE                                   = OBJECT_END + 0x06B, // Size: 1, Flags: PRIVATE, OWNER, SPECIAL_INFO
+    UNIT_FIELD_MINOFFHANDDAMAGE                            = OBJECT_END + 0x06C, // Size: 1, Flags: PRIVATE, OWNER, SPECIAL_INFO
+    UNIT_FIELD_MAXOFFHANDDAMAGE                            = OBJECT_END + 0x06D, // Size: 1, Flags: PRIVATE, OWNER, SPECIAL_INFO
+    UNIT_FIELD_BYTES_1                                     = OBJECT_END + 0x06E, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_PETNUMBER                                   = OBJECT_END + 0x06F, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_PET_NAME_TIMESTAMP                          = OBJECT_END + 0x070, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_PETEXPERIENCE                               = OBJECT_END + 0x071, // Size: 1, Flags: OWNER
+    UNIT_FIELD_PETNEXTLEVELEXP                             = OBJECT_END + 0x072, // Size: 1, Flags: OWNER
+    UNIT_MOD_CAST_SPEED                                    = OBJECT_END + 0x073, // Size: 1, Flags: PUBLIC
+    UNIT_MOD_CAST_HASTE                                    = OBJECT_END + 0x074, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_MOD_HASTE                                   = OBJECT_END + 0x075, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_MOD_RANGED_HASTE                            = OBJECT_END + 0x076, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_MOD_HASTE_REGEN                             = OBJECT_END + 0x077, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_MOD_TIME_RATE                               = OBJECT_END + 0x078, // Size: 1, Flags: PUBLIC
+    UNIT_CREATED_BY_SPELL                                  = OBJECT_END + 0x079, // Size: 1, Flags: PUBLIC
+    UNIT_NPC_FLAGS                                         = OBJECT_END + 0x07A, // Size: 2, Flags: PUBLIC, DYNAMIC
+    UNIT_NPC_EMOTESTATE                                    = OBJECT_END + 0x07C, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_STAT                                        = OBJECT_END + 0x07D, // Size: 4, Flags: PRIVATE, OWNER
+    UNIT_FIELD_POSSTAT                                     = OBJECT_END + 0x081, // Size: 4, Flags: PRIVATE, OWNER
+    UNIT_FIELD_NEGSTAT                                     = OBJECT_END + 0x085, // Size: 4, Flags: PRIVATE, OWNER
+    UNIT_FIELD_RESISTANCES                                 = OBJECT_END + 0x089, // Size: 7, Flags: PRIVATE, OWNER, SPECIAL_INFO
+    UNIT_FIELD_BONUS_RESISTANCE_MODS                       = OBJECT_END + 0x090, // Size: 7, Flags: PRIVATE, OWNER
+    UNIT_FIELD_BASE_MANA                                   = OBJECT_END + 0x097, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_BASE_HEALTH                                 = OBJECT_END + 0x098, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_BYTES_2                                     = OBJECT_END + 0x099, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_ATTACK_POWER                                = OBJECT_END + 0x09A, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_ATTACK_POWER_MOD_POS                        = OBJECT_END + 0x09B, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_ATTACK_POWER_MOD_NEG                        = OBJECT_END + 0x09C, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_ATTACK_POWER_MULTIPLIER                     = OBJECT_END + 0x09D, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_RANGED_ATTACK_POWER                         = OBJECT_END + 0x09E, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_RANGED_ATTACK_POWER_MOD_POS                 = OBJECT_END + 0x09F, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_RANGED_ATTACK_POWER_MOD_NEG                 = OBJECT_END + 0x0A0, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER              = OBJECT_END + 0x0A1, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_MAIN_HAND_WEAPON_ATTACK_POWER               = OBJECT_END + 0x0A2, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_OFF_HAND_WEAPON_ATTACK_POWER                = OBJECT_END + 0x0A3, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_RANGED_HAND_WEAPON_ATTACK_POWER             = OBJECT_END + 0x0A4, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_ATTACK_SPEED_AURA                           = OBJECT_END + 0x0A5, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_LIFESTEAL                                   = OBJECT_END + 0x0A6, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_MINRANGEDDAMAGE                             = OBJECT_END + 0x0A7, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_MAXRANGEDDAMAGE                             = OBJECT_END + 0x0A8, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_POWER_COST_MODIFIER                         = OBJECT_END + 0x0A9, // Size: 7, Flags: PRIVATE, OWNER
+    UNIT_FIELD_POWER_COST_MULTIPLIER                       = OBJECT_END + 0x0B0, // Size: 7, Flags: PRIVATE, OWNER
+    UNIT_FIELD_MAXHEALTHMODIFIER                           = OBJECT_END + 0x0B7, // Size: 1, Flags: PRIVATE, OWNER
+    UNIT_FIELD_HOVERHEIGHT                                 = OBJECT_END + 0x0B8, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_MIN_ITEM_LEVEL_CUTOFF                       = OBJECT_END + 0x0B9, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_MIN_ITEM_LEVEL                              = OBJECT_END + 0x0BA, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_MAXITEMLEVEL                                = OBJECT_END + 0x0BB, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_WILD_BATTLEPET_LEVEL                        = OBJECT_END + 0x0BC, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_BATTLEPET_COMPANION_NAME_TIMESTAMP          = OBJECT_END + 0x0BD, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_INTERACT_SPELLID                            = OBJECT_END + 0x0BE, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_STATE_SPELL_VISUAL_ID                       = OBJECT_END + 0x0BF, // Size: 1, Flags: DYNAMIC, URGENT
+    UNIT_FIELD_STATE_ANIM_ID                               = OBJECT_END + 0x0C0, // Size: 1, Flags: DYNAMIC, URGENT
+    UNIT_FIELD_STATE_ANIM_KIT_ID                           = OBJECT_END + 0x0C1, // Size: 1, Flags: DYNAMIC, URGENT
+    UNIT_FIELD_STATE_WORLD_EFFECT_ID                       = OBJECT_END + 0x0C2, // Size: 4, Flags: DYNAMIC, URGENT
+    UNIT_FIELD_SCALE_DURATION                              = OBJECT_END + 0x0C6, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_LOOKS_LIKE_MOUNT_ID                         = OBJECT_END + 0x0C7, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_LOOKS_LIKE_CREATURE_ID                      = OBJECT_END + 0x0C8, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_LOOK_AT_CONTROLLER_ID                       = OBJECT_END + 0x0C9, // Size: 1, Flags: PUBLIC
+    UNIT_FIELD_GUILD_GUID                                  = OBJECT_END + 0x0CA, // Size: 4, Flags: PUBLIC
+    UNIT_END                                               = OBJECT_END + 0x0CE,
 };
 
 enum UnitDynamicFields
@@ -209,141 +240,152 @@ enum PlayerFields
     PLAYER_BYTES_4                                         = UNIT_END + 0x014, // Size: 1, Flags: PUBLIC
     PLAYER_DUEL_TEAM                                       = UNIT_END + 0x015, // Size: 1, Flags: PUBLIC
     PLAYER_GUILD_TIMESTAMP                                 = UNIT_END + 0x016, // Size: 1, Flags: PUBLIC
-    PLAYER_QUEST_LOG                                       = UNIT_END + 0x017, // Size: 800, Flags: PARTY_MEMBER
-    PLAYER_VISIBLE_ITEM                                    = UNIT_END + 0x337, // Size: 38, Flags: PUBLIC
-    PLAYER_CHOSEN_TITLE                                    = UNIT_END + 0x35D, // Size: 1, Flags: PUBLIC
-    PLAYER_FAKE_INEBRIATION                                = UNIT_END + 0x35E, // Size: 1, Flags: PUBLIC
-    PLAYER_FIELD_VIRTUAL_PLAYER_REALM                      = UNIT_END + 0x35F, // Size: 1, Flags: PUBLIC
-    PLAYER_FIELD_CURRENT_SPEC_ID                           = UNIT_END + 0x360, // Size: 1, Flags: PUBLIC
-    PLAYER_FIELD_TAXI_MOUNT_ANIM_KIT_ID                    = UNIT_END + 0x361, // Size: 1, Flags: PUBLIC
-    PLAYER_FIELD_AVG_ITEM_LEVEL                            = UNIT_END + 0x362, // Size: 4, Flags: PUBLIC
-    PLAYER_FIELD_CURRENT_BATTLE_PET_BREED_QUALITY          = UNIT_END + 0x366, // Size: 1, Flags: PUBLIC
-    PLAYER_FIELD_PRESTIGE                                  = UNIT_END + 0x367, // Size: 1, Flags: PUBLIC
-    PLAYER_FIELD_HONOR_LEVEL                               = UNIT_END + 0x368, // Size: 1, Flags: PUBLIC
-    PLAYER_FIELD_INV_SLOT_HEAD                             = UNIT_END + 0x369, // Size: 780, Flags: PRIVATE
-    PLAYER_FIELD_END_NOT_SELF                              = UNIT_END + 0x369,
-    PLAYER_FARSIGHT                                        = UNIT_END + 0x675, // Size: 4, Flags: PRIVATE
-    PLAYER_FIELD_SUMMONED_BATTLE_PET_ID                    = UNIT_END + 0x679, // Size: 4, Flags: PRIVATE
-    PLAYER__FIELD_KNOWN_TITLES                             = UNIT_END + 0x67D, // Size: 12, Flags: PRIVATE
-    PLAYER_FIELD_COINAGE                                   = UNIT_END + 0x689, // Size: 2, Flags: PRIVATE
-    PLAYER_XP                                              = UNIT_END + 0x68B, // Size: 1, Flags: PRIVATE
-    PLAYER_NEXT_LEVEL_XP                                   = UNIT_END + 0x68C, // Size: 1, Flags: PRIVATE
-    PLAYER_TRIAL_XP                                        = UNIT_END + 0x68D, // Size: 1, Flags: PRIVATE
-    PLAYER_SKILL_LINEID                                    = UNIT_END + 0x68E, // Size: 448, Flags: PRIVATE
-    PLAYER_CHARACTER_POINTS                                = UNIT_END + 0x84E, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_MAX_TALENT_TIERS                          = UNIT_END + 0x84F, // Size: 1, Flags: PRIVATE
-    PLAYER_TRACK_CREATURES                                 = UNIT_END + 0x850, // Size: 1, Flags: PRIVATE
-    PLAYER_TRACK_RESOURCES                                 = UNIT_END + 0x851, // Size: 1, Flags: PRIVATE
-    PLAYER_EXPERTISE                                       = UNIT_END + 0x852, // Size: 1, Flags: PRIVATE
-    PLAYER_OFFHAND_EXPERTISE                               = UNIT_END + 0x853, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_RANGED_EXPERTISE                          = UNIT_END + 0x854, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_COMBAT_RATING_EXPERTISE                   = UNIT_END + 0x855, // Size: 1, Flags: PRIVATE
-    PLAYER_BLOCK_PERCENTAGE                                = UNIT_END + 0x856, // Size: 1, Flags: PRIVATE
-    PLAYER_DODGE_PERCENTAGE                                = UNIT_END + 0x857, // Size: 1, Flags: PRIVATE
-    PLAYER_DODGE_PERCENTAGE_FROM_ATTRIBUTE                 = UNIT_END + 0x858, // Size: 1, Flags: PRIVATE
-    PLAYER_PARRY_PERCENTAGE                                = UNIT_END + 0x859, // Size: 1, Flags: PRIVATE
-    PLAYER_PARRY_PERCENTAGE_FROM_ATTRIBUTE                 = UNIT_END + 0x85A, // Size: 1, Flags: PRIVATE
-    PLAYER_CRIT_PERCENTAGE                                 = UNIT_END + 0x85B, // Size: 1, Flags: PRIVATE
-    PLAYER_RANGED_CRIT_PERCENTAGE                          = UNIT_END + 0x85C, // Size: 1, Flags: PRIVATE
-    PLAYER_OFFHAND_CRIT_PERCENTAGE                         = UNIT_END + 0x85D, // Size: 1, Flags: PRIVATE
-    PLAYER_SPELL_CRIT_PERCENTAGE1                          = UNIT_END + 0x85E, // Size: 1, Flags: PRIVATE
-    PLAYER_SHIELD_BLOCK                                    = UNIT_END + 0x85F, // Size: 1, Flags: PRIVATE
-    PLAYER_SHIELD_BLOCK_CRIT_PERCENTAGE                    = UNIT_END + 0x860, // Size: 1, Flags: PRIVATE
-    PLAYER_MASTERY                                         = UNIT_END + 0x861, // Size: 1, Flags: PRIVATE
-    PLAYER_SPEED                                           = UNIT_END + 0x862, // Size: 1, Flags: PRIVATE
-    PLAYER_LIFESTEAL                                       = UNIT_END + 0x863, // Size: 1, Flags: PRIVATE
-    PLAYER_AVOIDANCE                                       = UNIT_END + 0x864, // Size: 1, Flags: PRIVATE
-    PLAYER_STURDINESS                                      = UNIT_END + 0x865, // Size: 1, Flags: PRIVATE
-    PLAYER_VERSATILITY                                     = UNIT_END + 0x866, // Size: 1, Flags: PRIVATE
-    PLAYER_VERSATILITY_BONUS                               = UNIT_END + 0x867, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_PVP_POWER_DAMAGE                          = UNIT_END + 0x868, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_PVP_POWER_HEALING                         = UNIT_END + 0x869, // Size: 1, Flags: PRIVATE
-    PLAYER_EXPLORED_ZONES_1                                = UNIT_END + 0x86A, // Size: 320, Flags: PRIVATE
-    PLAYER_FIELD_REST_INFO                                 = UNIT_END + 0x9AA, // Size: 4, Flags: PRIVATE
-    PLAYER_FIELD_MOD_DAMAGE_DONE_POS                       = UNIT_END + 0x9AE, // Size: 7, Flags: PRIVATE
-    PLAYER_FIELD_MOD_DAMAGE_DONE_NEG                       = UNIT_END + 0x9B5, // Size: 7, Flags: PRIVATE
-    PLAYER_FIELD_MOD_DAMAGE_DONE_PCT                       = UNIT_END + 0x9BC, // Size: 7, Flags: PRIVATE
-    PLAYER_FIELD_MOD_HEALING_DONE_POS                      = UNIT_END + 0x9C3, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_MOD_HEALING_PCT                           = UNIT_END + 0x9C4, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_MOD_HEALING_DONE_PCT                      = UNIT_END + 0x9C5, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_MOD_PERIODIC_HEALING_DONE_PERCENT         = UNIT_END + 0x9C6, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS                    = UNIT_END + 0x9C7, // Size: 3, Flags: PRIVATE
-    PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS              = UNIT_END + 0x9CA, // Size: 3, Flags: PRIVATE
-    PLAYER_FIELD_MOD_SPELL_POWER_PCT                       = UNIT_END + 0x9CD, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_MOD_RESILIENCE_PERCENT                    = UNIT_END + 0x9CE, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT            = UNIT_END + 0x9CF, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT        = UNIT_END + 0x9D0, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_MOD_TARGET_RESISTANCE                     = UNIT_END + 0x9D1, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE            = UNIT_END + 0x9D2, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_LOCAL_FLAGS                               = UNIT_END + 0x9D3, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_BYTES                                     = UNIT_END + 0x9D4, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_PVP_MEDALS                                = UNIT_END + 0x9D5, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_BUYBACK_PRICE_1                           = UNIT_END + 0x9D6, // Size: 12, Flags: PRIVATE
-    PLAYER_FIELD_BUYBACK_TIMESTAMP_1                       = UNIT_END + 0x9E2, // Size: 12, Flags: PRIVATE
-    PLAYER_FIELD_KILLS                                     = UNIT_END + 0x9EE, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_LIFETIME_HONORABLE_KILLS                  = UNIT_END + 0x9EF, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_WATCHED_FACTION_INDEX                     = UNIT_END + 0x9F0, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_COMBAT_RATING_1                           = UNIT_END + 0x9F1, // Size: 32, Flags: PRIVATE
-    PLAYER_FIELD_ARENA_TEAM_INFO_1_1                       = UNIT_END + 0xA11, // Size: 42, Flags: PRIVATE
-    PLAYER_FIELD_MAX_LEVEL                                 = UNIT_END + 0xA3B, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA                = UNIT_END + 0xA3C, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_MAX_CREATURE_SCALING_LEVEL                = UNIT_END + 0xA3D, // Size: 1, Flags: PRIVATE
-    PLAYER_NO_REAGENT_COST_1                               = UNIT_END + 0xA3E, // Size: 4, Flags: PRIVATE
-    PLAYER_PET_SPELL_POWER                                 = UNIT_END + 0xA42, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_RESEARCHING_1                             = UNIT_END + 0xA43, // Size: 10, Flags: PRIVATE
-    PLAYER_PROFESSION_SKILL_LINE_1                         = UNIT_END + 0xA4D, // Size: 2, Flags: PRIVATE
-    PLAYER_FIELD_UI_HIT_MODIFIER                           = UNIT_END + 0xA4F, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_UI_SPELL_HIT_MODIFIER                     = UNIT_END + 0xA50, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_HOME_REALM_TIME_OFFSET                    = UNIT_END + 0xA51, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_MOD_PET_HASTE                             = UNIT_END + 0xA52, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_BYTES2                                    = UNIT_END + 0xA53, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_BYTES3                                    = UNIT_END + 0xA54, // Size: 1, Flags: PRIVATE, URGENT_SELF_ONLY
-    PLAYER_FIELD_LFG_BONUS_FACTION_ID                      = UNIT_END + 0xA55, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_LOOT_SPEC_ID                              = UNIT_END + 0xA56, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_OVERRIDE_ZONE_PVP_TYPE                    = UNIT_END + 0xA57, // Size: 1, Flags: PRIVATE, URGENT_SELF_ONLY
-    PLAYER_FIELD_BAG_SLOT_FLAGS                            = UNIT_END + 0xA58, // Size: 4, Flags: PRIVATE
-    PLAYER_FIELD_BANK_BAG_SLOT_FLAGS                       = UNIT_END + 0xA5C, // Size: 7, Flags: PRIVATE
-    PLAYER_FIELD_INSERT_ITEMS_LEFT_TO_RIGHT                = UNIT_END + 0xA63, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_QUEST_COMPLETED                           = UNIT_END + 0xA64, // Size: 1750, Flags: PRIVATE
-    PLAYER_FIELD_HONOR                                     = UNIT_END + 0x113A, // Size: 1, Flags: PRIVATE
-    PLAYER_FIELD_HONOR_NEXT_LEVEL                          = UNIT_END + 0x113B, // Size: 1, Flags: PRIVATE
-    PLAYER_END                                             = UNIT_END + 0x113C,
+    PLAYER_QUEST_LOG                                       = UNIT_END + 0x017, // Size: 1600, Flags: PARTY_MEMBER
+    PLAYER_VISIBLE_ITEM                                    = UNIT_END + 0x657, // Size: 38, Flags: PUBLIC
+    PLAYER_CHOSEN_TITLE                                    = UNIT_END + 0x67D, // Size: 1, Flags: PUBLIC
+    PLAYER_FAKE_INEBRIATION                                = UNIT_END + 0x67E, // Size: 1, Flags: PUBLIC
+    PLAYER_FIELD_VIRTUAL_PLAYER_REALM                      = UNIT_END + 0x67F, // Size: 1, Flags: PUBLIC
+    PLAYER_FIELD_CURRENT_SPEC_ID                           = UNIT_END + 0x680, // Size: 1, Flags: PUBLIC
+    PLAYER_FIELD_TAXI_MOUNT_ANIM_KIT_ID                    = UNIT_END + 0x681, // Size: 1, Flags: PUBLIC
+    PLAYER_FIELD_AVG_ITEM_LEVEL                            = UNIT_END + 0x682, // Size: 4, Flags: PUBLIC
+    PLAYER_FIELD_CURRENT_BATTLE_PET_BREED_QUALITY          = UNIT_END + 0x686, // Size: 1, Flags: PUBLIC
+    PLAYER_FIELD_HONOR_LEVEL                               = UNIT_END + 0x687, // Size: 1, Flags: PUBLIC
+    PLAYER_END                                             = UNIT_END + 0x688,
 };
 
 enum PlayerDynamicFields
 {
-    PLAYER_DYNAMIC_FIELD_RESERACH_SITE                     = UNIT_DYNAMIC_END + 0x000, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_RESEARCH_SITE_PROGRESS            = UNIT_DYNAMIC_END + 0x001, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_DAILY_QUESTS                      = UNIT_DYNAMIC_END + 0x002, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_AVAILABLE_QUEST_LINE_X_QUEST_ID   = UNIT_DYNAMIC_END + 0x003, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_HEIRLOOMS                         = UNIT_DYNAMIC_END + 0x004, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS                    = UNIT_DYNAMIC_END + 0x005, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_TOYS                              = UNIT_DYNAMIC_END + 0x006, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_TRANSMOG                          = UNIT_DYNAMIC_END + 0x007, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG              = UNIT_DYNAMIC_END + 0x008, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS                   = UNIT_DYNAMIC_END + 0x009, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_CHARACTER_RESTRICTIONS            = UNIT_DYNAMIC_END + 0x00A, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_SPELL_PCT_MOD_BY_LABEL            = UNIT_DYNAMIC_END + 0x00B, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_SPELL_FLAT_MOD_BY_LABEL           = UNIT_DYNAMIC_END + 0x00C, // Flags: PRIVATE
-    PLAYER_DYNAMIC_FIELD_ARENA_COOLDOWNS                   = UNIT_DYNAMIC_END + 0x00D, // Flags: PUBLIC
-    PLAYER_DYNAMIC_END                                     = UNIT_DYNAMIC_END + 0x00E,
+    PLAYER_DYNAMIC_FIELD_ARENA_COOLDOWNS                   = UNIT_DYNAMIC_END + 0x000, // Flags: PUBLIC
+    PLAYER_DYNAMIC_END                                     = UNIT_DYNAMIC_END + 0x001,
+};
+
+enum ActivePlayerField
+{
+    ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD                      = PLAYER_END + 0x000, // Size: 780, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_FARSIGHT                           = PLAYER_END + 0x30C, // Size: 4, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID             = PLAYER_END + 0x310, // Size: 4, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_KNOWN_TITLES                       = PLAYER_END + 0x314, // Size: 12, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_COINAGE                            = PLAYER_END + 0x320, // Size: 2, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_XP                                 = PLAYER_END + 0x322, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_NEXT_LEVEL_XP                      = PLAYER_END + 0x323, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_TRIAL_XP                           = PLAYER_END + 0x324, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_SKILL_LINEID                       = PLAYER_END + 0x325, // Size: 896, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_CHARACTER_POINTS                   = PLAYER_END + 0x6A5, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MAX_TALENT_TIERS                   = PLAYER_END + 0x6A6, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_TRACK_CREATURES                    = PLAYER_END + 0x6A7, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_TRACK_RESOURCES                    = PLAYER_END + 0x6A8, // Size: 2, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_EXPERTISE                          = PLAYER_END + 0x6AA, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_OFFHAND_EXPERTISE                  = PLAYER_END + 0x6AB, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_RANGED_EXPERTISE                   = PLAYER_END + 0x6AC, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_COMBAT_RATING_EXPERTISE            = PLAYER_END + 0x6AD, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_BLOCK_PERCENTAGE                   = PLAYER_END + 0x6AE, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_DODGE_PERCENTAGE                   = PLAYER_END + 0x6AF, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_DODGE_PERCENTAGE_FROM_ATTRIBUTE    = PLAYER_END + 0x6B0, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_PARRY_PERCENTAGE                   = PLAYER_END + 0x6B1, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_PARRY_PERCENTAGE_FROM_ATTRIBUTE    = PLAYER_END + 0x6B2, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_CRIT_PERCENTAGE                    = PLAYER_END + 0x6B3, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_RANGED_CRIT_PERCENTAGE             = PLAYER_END + 0x6B4, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_OFFHAND_CRIT_PERCENTAGE            = PLAYER_END + 0x6B5, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_SPELL_CRIT_PERCENTAGE1             = PLAYER_END + 0x6B6, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_SHIELD_BLOCK                       = PLAYER_END + 0x6B7, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_SHIELD_BLOCK_CRIT_PERCENTAGE       = PLAYER_END + 0x6B8, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MASTERY                            = PLAYER_END + 0x6B9, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_SPEED                              = PLAYER_END + 0x6BA, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_AVOIDANCE                          = PLAYER_END + 0x6BB, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_STURDINESS                         = PLAYER_END + 0x6BC, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_VERSATILITY                        = PLAYER_END + 0x6BD, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_VERSATILITY_BONUS                  = PLAYER_END + 0x6BE, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_PVP_POWER_DAMAGE                   = PLAYER_END + 0x6BF, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_PVP_POWER_HEALING                  = PLAYER_END + 0x6C0, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_EXPLORED_ZONES                     = PLAYER_END + 0x6C1, // Size: 320, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_REST_INFO                          = PLAYER_END + 0x801, // Size: 4, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS                = PLAYER_END + 0x805, // Size: 7, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG                = PLAYER_END + 0x80C, // Size: 7, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT                = PLAYER_END + 0x813, // Size: 7, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_POS               = PLAYER_END + 0x81A, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_HEALING_PCT                    = PLAYER_END + 0x81B, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_PCT               = PLAYER_END + 0x81C, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_PERIODIC_HEALING_DONE_PERCENT  = PLAYER_END + 0x81D, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS             = PLAYER_END + 0x81E, // Size: 3, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS       = PLAYER_END + 0x821, // Size: 3, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_SPELL_POWER_PCT                = PLAYER_END + 0x824, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_RESILIENCE_PERCENT             = PLAYER_END + 0x825, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT     = PLAYER_END + 0x826, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT = PLAYER_END + 0x827, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_TARGET_RESISTANCE              = PLAYER_END + 0x828, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE     = PLAYER_END + 0x829, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_LOCAL_FLAGS                        = PLAYER_END + 0x82A, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_BYTES                              = PLAYER_END + 0x82B, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_PVP_MEDALS                         = PLAYER_END + 0x82C, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_BUYBACK_PRICE                      = PLAYER_END + 0x82D, // Size: 12, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP                  = PLAYER_END + 0x839, // Size: 12, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_KILLS                              = PLAYER_END + 0x845, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS           = PLAYER_END + 0x846, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_WATCHED_FACTION_INDEX              = PLAYER_END + 0x847, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_COMBAT_RATING                      = PLAYER_END + 0x848, // Size: 32, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO                    = PLAYER_END + 0x868, // Size: 54, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MAX_LEVEL                          = PLAYER_END + 0x89E, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA         = PLAYER_END + 0x89F, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MAX_CREATURE_SCALING_LEVEL         = PLAYER_END + 0x8A0, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_NO_REAGENT_COST                    = PLAYER_END + 0x8A1, // Size: 4, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_PET_SPELL_POWER                    = PLAYER_END + 0x8A5, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE              = PLAYER_END + 0x8A6, // Size: 2, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_UI_HIT_MODIFIER                    = PLAYER_END + 0x8A8, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_UI_SPELL_HIT_MODIFIER              = PLAYER_END + 0x8A9, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_HOME_REALM_TIME_OFFSET             = PLAYER_END + 0x8AA, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_MOD_PET_HASTE                      = PLAYER_END + 0x8AB, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_BYTES2                             = PLAYER_END + 0x8AC, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_BYTES3                             = PLAYER_END + 0x8AD, // Size: 1, Flags: PUBLIC, URGENT_SELF_ONLY
+    ACTIVE_PLAYER_FIELD_LFG_BONUS_FACTION_ID               = PLAYER_END + 0x8AE, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_LOOT_SPEC_ID                       = PLAYER_END + 0x8AF, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_OVERRIDE_ZONE_PVP_TYPE             = PLAYER_END + 0x8B0, // Size: 1, Flags: PUBLIC, URGENT_SELF_ONLY
+    ACTIVE_PLAYER_FIELD_BAG_SLOT_FLAGS                     = PLAYER_END + 0x8B1, // Size: 4, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_BANK_BAG_SLOT_FLAGS                = PLAYER_END + 0x8B5, // Size: 7, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_INSERT_ITEMS_LEFT_TO_RIGHT         = PLAYER_END + 0x8BC, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_QUEST_COMPLETED                    = PLAYER_END + 0x8BD, // Size: 1750, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_HONOR                              = PLAYER_END + 0xF93, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_HONOR_NEXT_LEVEL                   = PLAYER_END + 0xF94, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_PVP_TIER_MAX_FROM_WINS             = PLAYER_END + 0xF95, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_FIELD_PVP_LAST_WEEKS_TIER_MAX_FROM_WINS  = PLAYER_END + 0xF96, // Size: 1, Flags: PUBLIC
+    ACTIVE_PLAYER_END                                      = PLAYER_END + 0xF97,
+};
+
+enum ActivePlayerDynamicField
+{
+    ACTIVE_PLAYER_DYNAMIC_FIELD_RESERACH_SITE              = PLAYER_DYNAMIC_END + 0x000, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_RESEARCH_SITE_PROGRESS     = PLAYER_DYNAMIC_END + 0x001, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS               = PLAYER_DYNAMIC_END + 0x002, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_AVAILABLE_QUEST_LINE_X_QUEST_ID = PLAYER_DYNAMIC_END + 0x003, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOMS                  = PLAYER_DYNAMIC_END + 0x005, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS             = PLAYER_DYNAMIC_END + 0x006, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_TOYS                       = PLAYER_DYNAMIC_END + 0x007, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_TRANSMOG                   = PLAYER_DYNAMIC_END + 0x008, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG       = PLAYER_DYNAMIC_END + 0x009, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS            = PLAYER_DYNAMIC_END + 0x00A, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_CHARACTER_RESTRICTIONS     = PLAYER_DYNAMIC_END + 0x00B, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_SPELL_PCT_MOD_BY_LABEL     = PLAYER_DYNAMIC_END + 0x00C, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_SPELL_FLAT_MOD_BY_LABEL    = PLAYER_DYNAMIC_END + 0x00D, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_FIELD_RESERACH                   = PLAYER_DYNAMIC_END + 0x00E, // Flags: PUBLIC
+    ACTIVE_PLAYER_DYNAMIC_END                              = PLAYER_DYNAMIC_END + 0x00F,
 };
 
 enum GameObjectFields
 {
     GAMEOBJECT_FIELD_CREATED_BY                            = OBJECT_END + 0x000, // Size: 4, Flags: PUBLIC
-    GAMEOBJECT_DISPLAYID                                   = OBJECT_END + 0x004, // Size: 1, Flags: DYNAMIC, URGENT
-    GAMEOBJECT_FLAGS                                       = OBJECT_END + 0x005, // Size: 1, Flags: PUBLIC, URGENT
-    GAMEOBJECT_PARENTROTATION                              = OBJECT_END + 0x006, // Size: 4, Flags: PUBLIC
-    GAMEOBJECT_FACTION                                     = OBJECT_END + 0x00A, // Size: 1, Flags: PUBLIC
-    GAMEOBJECT_LEVEL                                       = OBJECT_END + 0x00B, // Size: 1, Flags: PUBLIC
-    GAMEOBJECT_BYTES_1                                     = OBJECT_END + 0x00C, // Size: 1, Flags: PUBLIC, URGENT
-    GAMEOBJECT_SPELL_VISUAL_ID                             = OBJECT_END + 0x00D, // Size: 1, Flags: PUBLIC, DYNAMIC, URGENT
-    GAMEOBJECT_STATE_SPELL_VISUAL_ID                       = OBJECT_END + 0x00E, // Size: 1, Flags: DYNAMIC, URGENT
-    GAMEOBJECT_STATE_ANIM_ID                               = OBJECT_END + 0x00F, // Size: 1, Flags: DYNAMIC, URGENT
-    GAMEOBJECT_STATE_ANIM_KIT_ID                           = OBJECT_END + 0x010, // Size: 1, Flags: DYNAMIC, URGENT
-    GAMEOBJECT_STATE_WORLD_EFFECT_ID                       = OBJECT_END + 0x011, // Size: 4, Flags: DYNAMIC, URGENT
-    GAMEOBJECT_END                                         = OBJECT_END + 0x015,
+    GAMEOBJECT_FIELD_GUILD_GUID                            = OBJECT_END + 0x004, // Size: 4, Flags: PUBLIC
+    GAMEOBJECT_DISPLAYID                                   = OBJECT_END + 0x008, // Size: 1, Flags: DYNAMIC, URGENT
+    GAMEOBJECT_FLAGS                                       = OBJECT_END + 0x009, // Size: 1, Flags: PUBLIC, URGENT
+    GAMEOBJECT_PARENTROTATION                              = OBJECT_END + 0x00A, // Size: 4, Flags: PUBLIC
+    GAMEOBJECT_FACTION                                     = OBJECT_END + 0x00E, // Size: 1, Flags: PUBLIC
+    GAMEOBJECT_LEVEL                                       = OBJECT_END + 0x00F, // Size: 1, Flags: PUBLIC
+    GAMEOBJECT_BYTES_1                                     = OBJECT_END + 0x010, // Size: 1, Flags: PUBLIC, URGENT
+    GAMEOBJECT_SPELL_VISUAL_ID                             = OBJECT_END + 0x011, // Size: 1, Flags: PUBLIC, DYNAMIC, URGENT
+    GAMEOBJECT_STATE_SPELL_VISUAL_ID                       = OBJECT_END + 0x012, // Size: 1, Flags: DYNAMIC, URGENT
+    GAMEOBJECT_STATE_ANIM_ID                               = OBJECT_END + 0x013, // Size: 1, Flags: DYNAMIC, URGENT
+    GAMEOBJECT_STATE_ANIM_KIT_ID                           = OBJECT_END + 0x014, // Size: 1, Flags: DYNAMIC, URGENT
+    GAMEOBJECT_STATE_WORLD_EFFECT_ID                       = OBJECT_END + 0x015, // Size: 4, Flags: DYNAMIC, URGENT
+    GAMEOBJECT_FIELD_CUSTOM_PARAM                          = OBJECT_END + 0x019, // Size: 1, Flags: PUBLIC, URGENT
+    GAMEOBJECT_END                                         = OBJECT_END + 0x01A,
 };
 
 enum GameObjectDynamicFields
@@ -372,15 +414,16 @@ enum CorpseFields
 {
     CORPSE_FIELD_OWNER                                     = OBJECT_END + 0x000, // Size: 4, Flags: PUBLIC
     CORPSE_FIELD_PARTY                                     = OBJECT_END + 0x004, // Size: 4, Flags: PUBLIC
-    CORPSE_FIELD_DISPLAY_ID                                = OBJECT_END + 0x008, // Size: 1, Flags: PUBLIC
-    CORPSE_FIELD_ITEM                                      = OBJECT_END + 0x009, // Size: 19, Flags: PUBLIC
-    CORPSE_FIELD_BYTES_1                                   = OBJECT_END + 0x01C, // Size: 1, Flags: PUBLIC
-    CORPSE_FIELD_BYTES_2                                   = OBJECT_END + 0x01D, // Size: 1, Flags: PUBLIC
-    CORPSE_FIELD_FLAGS                                     = OBJECT_END + 0x01E, // Size: 1, Flags: PUBLIC
-    CORPSE_FIELD_DYNAMIC_FLAGS                             = OBJECT_END + 0x01F, // Size: 1, Flags: DYNAMIC
-    CORPSE_FIELD_FACTIONTEMPLATE                           = OBJECT_END + 0x020, // Size: 1, Flags: PUBLIC
-    CORPSE_FIELD_CUSTOM_DISPLAY_OPTION                     = OBJECT_END + 0x021, // Size: 1, Flags: PUBLIC
-    CORPSE_END                                             = OBJECT_END + 0x022,
+    CORPSE_FIELD_GUILD_GUID                                = OBJECT_END + 0x008, // Size: 4, Flags: PUBLIC
+    CORPSE_FIELD_DISPLAY_ID                                = OBJECT_END + 0x00C, // Size: 1, Flags: PUBLIC
+    CORPSE_FIELD_ITEM                                      = OBJECT_END + 0x00D, // Size: 19, Flags: PUBLIC
+    CORPSE_FIELD_BYTES_1                                   = OBJECT_END + 0x020, // Size: 1, Flags: PUBLIC
+    CORPSE_FIELD_BYTES_2                                   = OBJECT_END + 0x021, // Size: 1, Flags: PUBLIC
+    CORPSE_FIELD_FLAGS                                     = OBJECT_END + 0x022, // Size: 1, Flags: PUBLIC
+    CORPSE_FIELD_DYNAMIC_FLAGS                             = OBJECT_END + 0x023, // Size: 1, Flags: DYNAMIC
+    CORPSE_FIELD_FACTIONTEMPLATE                           = OBJECT_END + 0x024, // Size: 1, Flags: PUBLIC
+    CORPSE_FIELD_CUSTOM_DISPLAY_OPTION                     = OBJECT_END + 0x025, // Size: 1, Flags: PUBLIC
+    CORPSE_END                                             = OBJECT_END + 0x026,
 };
 
 enum CorpseDynamicFields
diff --git a/src/server/game/Entities/Pet/Pet.cpp b/src/server/game/Entities/Pet/Pet.cpp
index aae4cbcb09b..f16f234ef2a 100644
--- a/src/server/game/Entities/Pet/Pet.cpp
+++ b/src/server/game/Entities/Pet/Pet.cpp
@@ -891,7 +891,7 @@ bool Guardian::InitStatsForLevel(uint8 petlevel)
         SetPowerType(POWER_ENERGY);
     else if (IsPetImp() || IsPetFelhunter() || IsPetVoidwalker() || IsPetSuccubus() || IsPetDoomguard() || IsPetFelguard()) // Warlock pets have energy (since 5.x)
         SetPowerType(POWER_ENERGY);
-    else 
+    else
         SetPowerType(POWER_MANA);
 
     // Damage
@@ -901,8 +901,8 @@ bool Guardian::InitStatsForLevel(uint8 petlevel)
         case SUMMON_PET:
         {
             // the damage bonus used for pets is either fire or shadow damage, whatever is higher
-            int32 fire = GetOwner()->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE);
-            int32 shadow = GetOwner()->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW);
+            int32 fire = GetOwner()->GetUInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE);
+            int32 shadow = GetOwner()->GetUInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW);
             int32 val = (fire > shadow) ? fire : shadow;
             if (val < 0)
                 val = 0;
@@ -1780,9 +1780,9 @@ Player* Pet::GetOwner() const
     return Minion::GetOwner()->ToPlayer();
 }
 
-void Pet::SetDisplayId(uint32 modelId)
+void Pet::SetDisplayId(uint32 modelId, float displayScale /*= 1.f*/)
 {
-    Guardian::SetDisplayId(modelId);
+    Guardian::SetDisplayId(modelId, displayScale);
 
     if (!isControlled())
         return;
diff --git a/src/server/game/Entities/Pet/Pet.h b/src/server/game/Entities/Pet/Pet.h
index e411d2251af..f82c88e6b44 100644
--- a/src/server/game/Entities/Pet/Pet.h
+++ b/src/server/game/Entities/Pet/Pet.h
@@ -52,7 +52,7 @@ class TC_GAME_API Pet : public Guardian
         void AddToWorld() override;
         void RemoveFromWorld() override;
 
-        void SetDisplayId(uint32 modelId) override;
+        void SetDisplayId(uint32 modelId, float displayScale = 1.f) override;
 
         PetType getPetType() const { return m_petType; }
         void setPetType(PetType type) { m_petType = type; }
diff --git a/src/server/game/Entities/Player/CollectionMgr.cpp b/src/server/game/Entities/Player/CollectionMgr.cpp
index eb4834967ba..6aff0ca300a 100644
--- a/src/server/game/Entities/Player/CollectionMgr.cpp
+++ b/src/server/game/Entities/Player/CollectionMgr.cpp
@@ -81,14 +81,14 @@ CollectionMgr::~CollectionMgr()
 void CollectionMgr::LoadToys()
 {
     for (auto const& t : _toys)
-        _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_TOYS, t.first);
+        _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_TOYS, t.first);
 }
 
 bool CollectionMgr::AddToy(uint32 itemId, bool isFavourite /*= false*/)
 {
     if (UpdateAccountToys(itemId, isFavourite))
     {
-        _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_TOYS, itemId);
+        _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_TOYS, itemId);
         return true;
     }
 
@@ -204,8 +204,8 @@ void CollectionMgr::LoadHeirlooms()
 {
     for (auto const& item : _heirlooms)
     {
-        _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_HEIRLOOMS, item.first);
-        _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS, item.second.flags);
+        _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOMS, item.first);
+        _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS, item.second.flags);
     }
 }
 
@@ -213,8 +213,8 @@ void CollectionMgr::AddHeirloom(uint32 itemId, uint32 flags)
 {
     if (UpdateAccountHeirlooms(itemId, flags))
     {
-        _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_HEIRLOOMS, itemId);
-        _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS, flags);
+        _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOMS, itemId);
+        _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS, flags);
     }
 }
 
@@ -255,10 +255,10 @@ void CollectionMgr::UpgradeHeirloom(uint32 itemId, int32 castItem)
         item->AddBonuses(bonusId);
 
     // Get heirloom offset to update only one part of dynamic field
-    std::vector<uint32> const& fields = player->GetDynamicValues(PLAYER_DYNAMIC_FIELD_HEIRLOOMS);
+    std::vector<uint32> const& fields = player->GetDynamicValues(ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOMS);
     uint16 offset = uint16(std::find(fields.begin(), fields.end(), itemId) - fields.begin());
 
-    player->SetDynamicValue(PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS, offset, flags);
+    player->SetDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS, offset, flags);
     itr->second.flags = flags;
     itr->second.bonusId = bonusId;
 }
@@ -295,11 +295,11 @@ void CollectionMgr::CheckHeirloomUpgrades(Item* item)
 
         if (newItemId)
         {
-            std::vector<uint32> const& fields = player->GetDynamicValues(PLAYER_DYNAMIC_FIELD_HEIRLOOMS);
+            std::vector<uint32> const& fields = player->GetDynamicValues(ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOMS);
             uint16 offset = uint16(std::find(fields.begin(), fields.end(), itr->first) - fields.begin());
 
-            player->SetDynamicValue(PLAYER_DYNAMIC_FIELD_HEIRLOOMS, offset, newItemId);
-            player->SetDynamicValue(PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS, offset, 0);
+            player->SetDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOMS, offset, newItemId);
+            player->SetDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_HEIRLOOM_FLAGS, offset, 0);
 
             _heirlooms.erase(itr);
             _heirlooms[newItemId] = 0;
@@ -460,11 +460,11 @@ void CollectionMgr::LoadItemAppearances()
 {
     boost::to_block_range(*_appearances, DynamicBitsetBlockOutputIterator([this](uint32 blockValue)
     {
-        _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_TRANSMOG, blockValue);
+        _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_TRANSMOG, blockValue);
     }));
 
     for (auto itr = _temporaryAppearances.begin(); itr != _temporaryAppearances.end(); ++itr)
-        _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG, itr->first);
+        _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG, itr->first);
 }
 
 void CollectionMgr::LoadAccountItemAppearances(PreparedQueryResult knownAppearances, PreparedQueryResult favoriteAppearances)
@@ -738,18 +738,18 @@ void CollectionMgr::AddItemAppearance(ItemModifiedAppearanceEntry const* itemMod
         _appearances->resize(itemModifiedAppearance->ID + 1);
         numBlocks = _appearances->num_blocks() - numBlocks;
         while (numBlocks--)
-            _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_TRANSMOG, 0);
+            _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_TRANSMOG, 0);
     }
 
     _appearances->set(itemModifiedAppearance->ID);
     uint32 blockIndex = itemModifiedAppearance->ID / 32;
     uint32 bitIndex = itemModifiedAppearance->ID % 32;
-    uint32 currentMask = _owner->GetPlayer()->GetDynamicValue(PLAYER_DYNAMIC_FIELD_TRANSMOG, blockIndex);
-    _owner->GetPlayer()->SetDynamicValue(PLAYER_DYNAMIC_FIELD_TRANSMOG, blockIndex, currentMask | (1 << bitIndex));
+    uint32 currentMask = _owner->GetPlayer()->GetDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_TRANSMOG, blockIndex);
+    _owner->GetPlayer()->SetDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_TRANSMOG, blockIndex, currentMask | (1 << bitIndex));
     auto temporaryAppearance = _temporaryAppearances.find(itemModifiedAppearance->ID);
     if (temporaryAppearance != _temporaryAppearances.end())
     {
-        _owner->GetPlayer()->RemoveDynamicValue(PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG, itemModifiedAppearance->ID);
+        _owner->GetPlayer()->RemoveDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG, itemModifiedAppearance->ID);
         _temporaryAppearances.erase(temporaryAppearance);
     }
 
@@ -770,7 +770,7 @@ void CollectionMgr::AddTemporaryAppearance(ObjectGuid const& itemGuid, ItemModif
 {
     std::unordered_set<ObjectGuid>& itemsWithAppearance = _temporaryAppearances[itemModifiedAppearance->ID];
     if (itemsWithAppearance.empty())
-        _owner->GetPlayer()->AddDynamicValue(PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG, itemModifiedAppearance->ID);
+        _owner->GetPlayer()->AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG, itemModifiedAppearance->ID);
 
     itemsWithAppearance.insert(itemGuid);
 }
@@ -788,7 +788,7 @@ void CollectionMgr::RemoveTemporaryAppearance(Item* item)
     itr->second.erase(item->GetGUID());
     if (itr->second.empty())
     {
-        _owner->GetPlayer()->RemoveDynamicValue(PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG, itemModifiedAppearance->ID);
+        _owner->GetPlayer()->RemoveDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_CONDITIONAL_TRANSMOG, itemModifiedAppearance->ID);
         _temporaryAppearances.erase(itr);
     }
 }
diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp
index 5ec2a72d2ad..f32bfb5d3e2 100644
--- a/src/server/game/Entities/Player/Player.cpp
+++ b/src/server/game/Entities/Player/Player.cpp
@@ -140,8 +140,8 @@ Player::Player(WorldSession* session) : Unit(true), m_sceneMgr(this)
     m_objectType |= TYPEMASK_PLAYER;
     m_objectTypeId = TYPEID_PLAYER;
 
-    m_valuesCount = PLAYER_END;
-    _dynamicValuesCount = PLAYER_DYNAMIC_END;
+    m_valuesCount = ACTIVE_PLAYER_END;
+    _dynamicValuesCount = ACTIVE_PLAYER_DYNAMIC_END;
 
     m_session = session;
 
@@ -469,7 +469,7 @@ bool Player::Create(ObjectGuid::LowType guidlow, WorldPackets::Character::Charac
     SetFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_REGENERATE_POWER);
     SetFloatValue(UNIT_FIELD_HOVERHEIGHT, 1.0f);            // default for players in 3.0.3
 
-    SetInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, uint32(-1));  // -1 is default value
+    SetInt32Value(ACTIVE_PLAYER_FIELD_WATCHED_FACTION_INDEX, uint32(-1));  // -1 is default value
 
     SetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID, createInfo->Skin);
     SetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_FACE_ID, createInfo->Face);
@@ -478,23 +478,23 @@ bool Player::Create(ObjectGuid::LowType guidlow, WorldPackets::Character::Charac
     SetByteValue(PLAYER_BYTES_2, PLAYER_BYTES_2_OFFSET_FACIAL_STYLE, createInfo->FacialHairStyle);
     for (uint32 i = 0; i < PLAYER_CUSTOM_DISPLAY_SIZE; ++i)
         SetByteValue(PLAYER_BYTES_2, PLAYER_BYTES_2_OFFSET_CUSTOM_DISPLAY_OPTION + i, createInfo->CustomDisplay[i]);
-    SetUInt32Value(PLAYER_FIELD_REST_INFO + REST_STATE_XP, (GetSession()->IsARecruiter() || GetSession()->GetRecruiterId() != 0) ? REST_STATE_RAF_LINKED : REST_STATE_NOT_RAF_LINKED);
-    SetUInt32Value(PLAYER_FIELD_REST_INFO + REST_STATE_HONOR, REST_STATE_NOT_RAF_LINKED);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + REST_STATE_XP, (GetSession()->IsARecruiter() || GetSession()->GetRecruiterId() != 0) ? REST_STATE_RAF_LINKED : REST_STATE_NOT_RAF_LINKED);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + REST_STATE_HONOR, REST_STATE_NOT_RAF_LINKED);
     SetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER, createInfo->Sex);
     SetByteValue(PLAYER_BYTES_4, PLAYER_BYTES_4_OFFSET_ARENA_FACTION, 0);
     SetInventorySlotCount(INVENTORY_DEFAULT_SIZE);
 
-    SetGuidValue(OBJECT_FIELD_DATA, ObjectGuid::Empty);
+    SetGuidValue(UNIT_FIELD_GUILD_GUID, ObjectGuid::Empty);
     SetUInt32Value(PLAYER_GUILDRANK, 0);
     SetGuildLevel(0);
     SetUInt32Value(PLAYER_GUILD_TIMESTAMP, 0);
 
     for (int i = 0; i < KNOWN_TITLES_SIZE; ++i)
-        SetUInt64Value(PLAYER__FIELD_KNOWN_TITLES + i, 0);  // 0=disabled
+        SetUInt64Value(ACTIVE_PLAYER_FIELD_KNOWN_TITLES + i, 0);  // 0=disabled
     SetUInt32Value(PLAYER_CHOSEN_TITLE, 0);
 
-    SetUInt32Value(PLAYER_FIELD_KILLS, 0);
-    SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, 0);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_KILLS, 0);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, 0);
 
     // set starting level
     uint32 start_level = sWorld->getIntConfig(CONFIG_START_PLAYER_LEVEL);
@@ -528,7 +528,7 @@ bool Player::Create(ObjectGuid::LowType guidlow, WorldPackets::Character::Charac
 
     InitRunes();
 
-    SetUInt64Value(PLAYER_FIELD_COINAGE, sWorld->getIntConfig(CONFIG_START_PLAYER_MONEY));
+    SetUInt64Value(ACTIVE_PLAYER_FIELD_COINAGE, sWorld->getIntConfig(CONFIG_START_PLAYER_MONEY));
     SetCurrency(CURRENCY_TYPE_APEXIS_CRYSTALS, sWorld->getIntConfig(CONFIG_CURRENCY_START_APEXIS_CRYSTALS));
     SetCurrency(CURRENCY_TYPE_JUSTICE_POINTS, sWorld->getIntConfig(CONFIG_CURRENCY_START_JUSTICE_POINTS));
 
@@ -536,7 +536,7 @@ bool Player::Create(ObjectGuid::LowType guidlow, WorldPackets::Character::Charac
     if (sWorld->getBoolConfig(CONFIG_START_ALL_EXPLORED))
     {
         for (uint16 i=0; i<PLAYER_EXPLORED_ZONES_SIZE; i++)
-            SetFlag(PLAYER_EXPLORED_ZONES_1+i, 0xFFFFFFFF);
+            SetFlag(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES+i, 0xFFFFFFFF);
     }
 
     //Reputations if "StartAllReputation" is enabled, -- @todo Fix this in a better way
@@ -1404,7 +1404,7 @@ void Player::setDeathState(DeathState s)
 
     if (IsAlive() && !oldIsAlive)
         //clear aura case after resurrection by another way (spells will be applied before next death)
-        ClearDynamicValue(PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS);
+        ClearDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS);
 }
 
 void Player::ToggleAFK()
@@ -2331,15 +2331,15 @@ void Player::RemoveFromGroup(Group* group, ObjectGuid guid, RemoveMethod method
 
 void Player::SetXP(uint32 xp)
 {
-    SetUInt32Value(PLAYER_XP, xp);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_XP, xp);
 
     int32 playerLevelDelta = 0;
 
     // If XP < 50%, player should see scaling creature with -1 level except for level max
-    if (getLevel() < MAX_LEVEL && xp < (GetUInt32Value(PLAYER_NEXT_LEVEL_XP) / 2))
+    if (getLevel() < MAX_LEVEL && xp < (GetUInt32Value(ACTIVE_PLAYER_FIELD_NEXT_LEVEL_XP) / 2))
         playerLevelDelta = -1;
 
-    SetInt32Value(PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA, playerLevelDelta);
+    SetInt32Value(ACTIVE_PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA, playerLevelDelta);
 }
 
 void Player::GiveXP(uint32 xp, Unit* victim, float group_rate)
@@ -2382,8 +2382,8 @@ void Player::GiveXP(uint32 xp, Unit* victim, float group_rate)
     packet.ReferAFriendBonusType = recruitAFriend ? 1 : 0;
     GetSession()->SendPacket(packet.Write());
 
-    uint32 curXP = GetUInt32Value(PLAYER_XP);
-    uint32 nextLvlXP = GetUInt32Value(PLAYER_NEXT_LEVEL_XP);
+    uint32 curXP = GetUInt32Value(ACTIVE_PLAYER_FIELD_XP);
+    uint32 nextLvlXP = GetUInt32Value(ACTIVE_PLAYER_FIELD_NEXT_LEVEL_XP);
     uint32 newXP = curXP + xp + bonus_xp;
 
     while (newXP >= nextLvlXP && level < sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
@@ -2394,7 +2394,7 @@ void Player::GiveXP(uint32 xp, Unit* victim, float group_rate)
             GiveLevel(level + 1);
 
         level = getLevel();
-        nextLvlXP = GetUInt32Value(PLAYER_NEXT_LEVEL_XP);
+        nextLvlXP = GetUInt32Value(ACTIVE_PLAYER_FIELD_NEXT_LEVEL_XP);
     }
 
     SetXP(newXP);
@@ -2433,13 +2433,12 @@ void Player::GiveLevel(uint8 level)
     for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i)
         packet.StatDelta[i] = int32(info.stats[i]) - GetCreateStat(Stats(i));
 
-    uint32 const* rowLevels = (getClass() != CLASS_DEATH_KNIGHT) ? DefaultTalentRowLevels : DKTalentRowLevels;
-
-    packet.Cp = std::find(rowLevels, rowLevels + MAX_TALENT_TIERS, level) != (rowLevels + MAX_TALENT_TIERS);
+    packet.NumNewTalents = DB2Manager::GetNumTalentsAtLevel(level, Classes(getClass())) - DB2Manager::GetNumTalentsAtLevel(oldLevel, Classes(getClass()));
+    packet.NumNewPvpTalentSlots = sDB2Manager.GetPvpTalentNumSlotsAtLevel(level, Classes(getClass())) - sDB2Manager.GetPvpTalentNumSlotsAtLevel(oldLevel, Classes(getClass()));
 
     GetSession()->SendPacket(packet.Write());
 
-    SetUInt32Value(PLAYER_NEXT_LEVEL_XP, sObjectMgr->GetXPForLevel(level));
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_NEXT_LEVEL_XP, sObjectMgr->GetXPForLevel(level));
 
     //update level, max level of skills
     m_Played_time[PLAYED_TIME_LEVEL] = 0;                   // Level Played Time reset
@@ -2503,8 +2502,8 @@ void Player::GiveLevel(uint8 level)
             {
                 ++m_grantableLevels;
 
-                if (!HasByteFlag(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_RAF_GRANTABLE_LEVEL, 0x01))
-                    SetByteFlag(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_RAF_GRANTABLE_LEVEL, 0x01);
+                if (!HasByteFlag(ACTIVE_PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_RAF_GRANTABLE_LEVEL, 0x01))
+                    SetByteFlag(ACTIVE_PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_RAF_GRANTABLE_LEVEL, 0x01);
             }
         }
     }
@@ -2519,7 +2518,7 @@ void Player::InitTalentForLevel()
     if (level < MIN_SPECIALIZATION_LEVEL)
         ResetTalentSpecialization();
 
-    uint32 talentTiers = CalculateTalentsTiers();
+    uint32 talentTiers = DB2Manager::GetNumTalentsAtLevel(level, Classes(getClass()));
     if (level < 15)
     {
         // Remove all talent points
@@ -2534,7 +2533,7 @@ void Player::InitTalentForLevel()
                         RemoveTalent(talent);
     }
 
-    SetUInt32Value(PLAYER_FIELD_MAX_TALENT_TIERS, talentTiers);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_MAX_TALENT_TIERS, talentTiers);
 
     if (!GetSession()->PlayerLoading())
         SendTalentsInfoData(); // update at client
@@ -2551,8 +2550,8 @@ void Player::InitStatsForLevel(bool reapplyMods)
     PlayerLevelInfo info;
     sObjectMgr->GetPlayerLevelInfo(getRace(), getClass(), getLevel(), &info);
 
-    SetUInt32Value(PLAYER_FIELD_MAX_LEVEL, sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL));
-    SetUInt32Value(PLAYER_NEXT_LEVEL_XP, sObjectMgr->GetXPForLevel(getLevel()));
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_MAX_LEVEL, sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL));
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_NEXT_LEVEL_XP, sObjectMgr->GetXPForLevel(getLevel()));
 
     // reset before any aura state sources (health set/aura apply)
     SetUInt32Value(UNIT_FIELD_AURASTATE, 0);
@@ -2582,26 +2581,26 @@ void Player::InitStatsForLevel(bool reapplyMods)
     //set create powers
     SetCreateMana(basemana);
 
-    SetArmor(int32(m_createStats[STAT_AGILITY]*2));
+    SetArmor(int32(m_createStats[STAT_AGILITY]*2), 0);
 
     InitStatBuffMods();
 
     //reset rating fields values
-    for (uint16 index = PLAYER_FIELD_COMBAT_RATING_1; index < PLAYER_FIELD_COMBAT_RATING_1 + MAX_COMBAT_RATING; ++index)
-        SetUInt32Value(index, 0);
+    for (uint16 index = 0; index < MAX_COMBAT_RATING; ++index)
+        SetUInt32Value(ACTIVE_PLAYER_FIELD_COMBAT_RATING + index, 0);
 
-    SetUInt32Value(PLAYER_FIELD_MOD_HEALING_DONE_POS, 0);
-    SetFloatValue(PLAYER_FIELD_MOD_HEALING_PCT, 1.0f);
-    SetFloatValue(PLAYER_FIELD_MOD_HEALING_DONE_PCT, 1.0f);
-    SetFloatValue(PLAYER_FIELD_MOD_PERIODIC_HEALING_DONE_PERCENT, 1.0f);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_POS, 0);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_MOD_HEALING_PCT, 1.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_PCT, 1.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_MOD_PERIODIC_HEALING_DONE_PERCENT, 1.0f);
     for (uint8 i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
     {
-        SetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + i, 0);
-        SetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i, 0);
-        SetFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i, 1.00f);
+        SetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + i, 0);
+        SetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i, 0);
+        SetFloatValue(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i, 1.00f);
     }
 
-    SetFloatValue(PLAYER_FIELD_MOD_SPELL_POWER_PCT, 1.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_MOD_SPELL_POWER_PCT, 1.0f);
 
     //reset attack power, damage and attack speed fields
     for (uint8 i = BASE_ATTACK; i < MAX_ATTACK; ++i)
@@ -2615,8 +2614,8 @@ void Player::InitStatsForLevel(bool reapplyMods)
     SetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE, 0.0f);
     for (uint16 i = 0; i < 3; ++i)
     {
-        SetFloatValue(PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS + i, 1.0f);
-        SetFloatValue(PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS + i, 1.0f);
+        SetFloatValue(ACTIVE_PLAYER_FIELD_WEAPON_DMG_MULTIPLIERS + i, 1.0f);
+        SetFloatValue(ACTIVE_PLAYER_FIELD_WEAPON_ATK_SPEED_MULTIPLIERS + i, 1.0f);
     }
 
     SetInt32Value(UNIT_FIELD_ATTACK_POWER,            0);
@@ -2625,44 +2624,42 @@ void Player::InitStatsForLevel(bool reapplyMods)
     SetFloatValue(UNIT_FIELD_RANGED_ATTACK_POWER_MULTIPLIER, 0.0f);
 
     // Base crit values (will be recalculated in UpdateAllStats() at loading and in _ApplyAllStatBonuses() at reset
-    SetFloatValue(PLAYER_CRIT_PERCENTAGE, 0.0f);
-    SetFloatValue(PLAYER_OFFHAND_CRIT_PERCENTAGE, 0.0f);
-    SetFloatValue(PLAYER_RANGED_CRIT_PERCENTAGE, 0.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_CRIT_PERCENTAGE, 0.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_OFFHAND_CRIT_PERCENTAGE, 0.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_RANGED_CRIT_PERCENTAGE, 0.0f);
 
     // Init spell schools (will be recalculated in UpdateAllStats() at loading and in _ApplyAllStatBonuses() at reset
-    SetFloatValue(PLAYER_SPELL_CRIT_PERCENTAGE1, 0.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_SPELL_CRIT_PERCENTAGE1, 0.0f);
 
-    SetFloatValue(PLAYER_PARRY_PERCENTAGE, 0.0f);
-    SetFloatValue(PLAYER_BLOCK_PERCENTAGE, 0.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_PARRY_PERCENTAGE, 0.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_BLOCK_PERCENTAGE, 0.0f);
 
     // Static 30% damage blocked
-    SetUInt32Value(PLAYER_SHIELD_BLOCK, 30);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_SHIELD_BLOCK, 30);
 
     // Dodge percentage
-    SetFloatValue(PLAYER_DODGE_PERCENTAGE, 0.0f);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_DODGE_PERCENTAGE, 0.0f);
 
     // set armor (resistance 0) to original value (create_agility*2)
-    SetArmor(int32(m_createStats[STAT_AGILITY]*2));
-    SetResistanceBuffMods(SPELL_SCHOOL_NORMAL, true, 0.0f);
-    SetResistanceBuffMods(SPELL_SCHOOL_NORMAL, false, 0.0f);
+    SetArmor(int32(m_createStats[STAT_AGILITY]*2), 0);
+    SetBonusResistanceMod(SPELL_SCHOOL_NORMAL, 0);
     // set other resistance to original value (0)
     for (uint8 i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
     {
         SetResistance(SpellSchools(i), 0);
-        SetResistanceBuffMods(SpellSchools(i), true, 0.0f);
-        SetResistanceBuffMods(SpellSchools(i), false, 0.0f);
+        SetBonusResistanceMod(SpellSchools(i), 0);
     }
 
-    SetUInt32Value(PLAYER_FIELD_MOD_TARGET_RESISTANCE, 0);
-    SetUInt32Value(PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE, 0);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_MOD_TARGET_RESISTANCE, 0);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE, 0);
     for (uint8 i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
     {
         SetUInt32Value(UNIT_FIELD_POWER_COST_MODIFIER + i, 0);
         SetFloatValue(UNIT_FIELD_POWER_COST_MULTIPLIER + i, 0.0f);
     }
     // Reset no reagent cost field
-    for (uint8 i = 0; i < 3; ++i)
-        SetUInt32Value(PLAYER_NO_REAGENT_COST_1 + i, 0);
+    for (uint8 i = 0; i < 4; ++i)
+        SetUInt32Value(ACTIVE_PLAYER_FIELD_NO_REAGENT_COST + i, 0);
     // Init data for form but skip reapply item mods for form
     InitDataForForm(reapplyMods);
 
@@ -2694,9 +2691,9 @@ void Player::InitStatsForLevel(bool reapplyMods)
     RemoveByteFlag(UNIT_FIELD_BYTES_2, UNIT_BYTES_2_OFFSET_PVP_FLAG, UNIT_BYTE2_FLAG_FFA_PVP | UNIT_BYTE2_FLAG_SANCTUARY);
 
     // restore if need some important flags
-    SetByteValue(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_IGNORE_POWER_REGEN_PREDICTION_MASK, 0);
-    SetByteValue(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, 0);
-    SetByteValue(PLAYER_FIELD_BYTES2, 3, 0);
+    SetByteValue(ACTIVE_PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_IGNORE_POWER_REGEN_PREDICTION_MASK, 0);
+    SetByteValue(ACTIVE_PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, 0);
+    SetByteValue(ACTIVE_PLAYER_FIELD_BYTES2, 3, 0);
 
     if (reapplyMods)                                        // reapply stats values only on .reset stats (level) command
         _ApplyAllStatBonuses();
@@ -3579,9 +3576,6 @@ void Player::ResetPvpTalents()
         if (!talentInfo)
             continue;
 
-        if (talentInfo->ClassID && talentInfo->ClassID != getClass())
-            continue;
-
         RemovePvpTalent(talentInfo);
     }
 
@@ -4316,7 +4310,7 @@ void Player::KillPlayer()
     //SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_IN_PVP);
 
     SetUInt32Value(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_NONE);
-    ApplyModFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER, !sMapStore.LookupEntry(GetMapId())->Instanceable() && !HasAuraType(SPELL_AURA_PREVENT_RESURRECTION));
+    ApplyModFlag(ACTIVE_PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER, !sMapStore.LookupEntry(GetMapId())->Instanceable() && !HasAuraType(SPELL_AURA_PREVENT_RESURRECTION));
 
     // 6 minutes until repop at graveyard
     m_deathTimer = 6 * MINUTE * IN_MILLISECONDS;
@@ -5011,7 +5005,7 @@ float Player::GetRatingMultiplier(CombatRating cr) const
 
 float Player::GetRatingBonusValue(CombatRating cr) const
 {
-    float baseResult = float(GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + cr)) * GetRatingMultiplier(cr);
+    float baseResult = float(GetUInt32Value(ACTIVE_PLAYER_FIELD_COMBAT_RATING + cr)) * GetRatingMultiplier(cr);
     if (cr != CR_RESILIENCE_PLAYER_DAMAGE)
         return baseResult;
     return float(1.0f - pow(0.99f, baseResult)) * 100.0f;
@@ -5023,9 +5017,9 @@ float Player::GetExpertiseDodgeOrParryReduction(WeaponAttackType attType) const
     switch (attType)
     {
         case BASE_ATTACK:
-            return baseExpertise + GetUInt32Value(PLAYER_EXPERTISE) / 4.0f;
+            return baseExpertise + GetUInt32Value(ACTIVE_PLAYER_FIELD_EXPERTISE) / 4.0f;
         case OFF_ATTACK:
-            return baseExpertise + GetUInt32Value(PLAYER_OFFHAND_EXPERTISE) / 4.0f;
+            return baseExpertise + GetUInt32Value(ACTIVE_PLAYER_FIELD_OFFHAND_EXPERTISE) / 4.0f;
         default:
             break;
     }
@@ -5056,8 +5050,8 @@ void Player::UpdateRating(CombatRating cr)
     if (amount < 0)
         amount = 0;
 
-    uint32 oldRating = GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + cr);
-    SetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + cr, uint32(amount));
+    uint32 oldRating = GetUInt32Value(ACTIVE_PLAYER_FIELD_COMBAT_RATING + cr);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_COMBAT_RATING + cr, uint32(amount));
 
     bool affectStats = CanModifyStats();
 
@@ -5192,43 +5186,6 @@ void Player::SetRegularAttackTime()
     }
 }
 
-//skill+step, checking for max value
-bool Player::UpdateSkill(uint32 skill_id, uint32 step)
-{
-    if (!skill_id)
-        return false;
-
-    SkillStatusMap::iterator itr = mSkillStatus.find(skill_id);
-    if (itr == mSkillStatus.end() || itr->second.uState == SKILL_DELETED)
-        return false;
-
-    uint16 field = itr->second.pos / 2;
-    uint8 offset = itr->second.pos & 1; // itr->second.pos % 2
-
-    uint16 value = GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset);
-    uint16 max = GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
-
-    if (!max || !value || value >= max)
-        return false;
-
-    if (value < max)
-    {
-        uint32 new_value = value + step;
-        if (new_value > max)
-            new_value = max;
-
-        SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, new_value);
-        if (itr->second.uState != SKILL_NEW)
-            itr->second.uState = SKILL_CHANGED;
-
-        UpdateSkillEnchantments(skill_id, value, new_value);
-        UpdateCriteria(CRITERIA_TYPE_REACH_SKILL_LEVEL, skill_id);
-        return true;
-    }
-
-    return false;
-}
-
 inline int SkillGainChance(uint32 SkillValue, uint32 GrayLevel, uint32 GreenLevel, uint32 YellowLevel)
 {
     if (SkillValue >= GrayLevel)
@@ -5249,21 +5206,21 @@ bool Player::UpdateCraftSkill(uint32 spellid)
 
     for (SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx)
     {
-        if (_spell_idx->second->SkillLine)
+        if (_spell_idx->second->SkillupSkillLineID)
         {
-            uint32 SkillValue = GetPureSkillValue(_spell_idx->second->SkillLine);
+            uint32 SkillValue = GetPureSkillValue(_spell_idx->second->SkillupSkillLineID);
 
             // Alchemy Discoveries here
             SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(spellid);
             if (spellEntry && spellEntry->Mechanic == MECHANIC_DISCOVERY)
             {
-                if (uint32 discoveredSpell = GetSkillDiscoverySpell(_spell_idx->second->SkillLine, spellid, this))
+                if (uint32 discoveredSpell = GetSkillDiscoverySpell(_spell_idx->second->SkillupSkillLineID, spellid, this))
                     LearnSpell(discoveredSpell, false);
             }
 
             uint32 craft_skill_gain = _spell_idx->second->NumSkillUps * sWorld->getIntConfig(CONFIG_SKILL_GAIN_CRAFTING);
 
-            return UpdateSkillPro(_spell_idx->second->SkillLine, SkillGainChance(SkillValue,
+            return UpdateSkillPro(_spell_idx->second->SkillupSkillLineID, SkillGainChance(SkillValue,
                 _spell_idx->second->TrivialSkillLineRankHigh,
                 (_spell_idx->second->TrivialSkillLineRankHigh + _spell_idx->second->TrivialSkillLineRankLow)/2,
                 _spell_idx->second->TrivialSkillLineRankLow),
@@ -5284,15 +5241,39 @@ bool Player::UpdateGatherSkill(uint32 SkillId, uint32 SkillValue, uint32 RedLeve
     switch (SkillId)
     {
         case SKILL_HERBALISM:
+        case SKILL_HERBALISM_2:
+        case SKILL_OUTLAND_HERBALISM:
+        case SKILL_NORTHREND_HERBALISM:
+        case SKILL_CATACLYSM_HERBALISM:
+        case SKILL_PANDARIA_HERBALISM:
+        case SKILL_DRAENOR_HERBALISM:
+        case SKILL_LEGION_HERBALISM:
+        case SKILL_KUL_TIRAN_HERBALISM:
         case SKILL_JEWELCRAFTING:
         case SKILL_INSCRIPTION:
             return UpdateSkillPro(SkillId, SkillGainChance(SkillValue, RedLevel+100, RedLevel+50, RedLevel+25)*Multiplicator, gathering_skill_gain);
         case SKILL_SKINNING:
+        case SKILL_SKINNING_2:
+        case SKILL_OUTLAND_SKINNING:
+        case SKILL_NORTHREND_SKINNING:
+        case SKILL_CATACLYSM_SKINNING:
+        case SKILL_PANDARIA_SKINNING:
+        case SKILL_DRAENOR_SKINNING:
+        case SKILL_LEGION_SKINNING:
+        case SKILL_KUL_TIRAN_SKINNING:
             if (sWorld->getIntConfig(CONFIG_SKILL_CHANCE_SKINNING_STEPS) == 0)
                 return UpdateSkillPro(SkillId, SkillGainChance(SkillValue, RedLevel+100, RedLevel+50, RedLevel+25)*Multiplicator, gathering_skill_gain);
             else
                 return UpdateSkillPro(SkillId, (SkillGainChance(SkillValue, RedLevel+100, RedLevel+50, RedLevel+25)*Multiplicator) >> (SkillValue/sWorld->getIntConfig(CONFIG_SKILL_CHANCE_SKINNING_STEPS)), gathering_skill_gain);
         case SKILL_MINING:
+        case SKILL_MINING_2:
+        case SKILL_OUTLAND_MINING:
+        case SKILL_NORTHREND_MINING:
+        case SKILL_CATACLYSM_MINING:
+        case SKILL_PANDARIA_MINING:
+        case SKILL_DRAENOR_MINING:
+        case SKILL_LEGION_MINING:
+        case SKILL_KUL_TIRAN_MINING:
             if (sWorld->getIntConfig(CONFIG_SKILL_CHANCE_MINING_STEPS) == 0)
                 return UpdateSkillPro(SkillId, SkillGainChance(SkillValue, RedLevel+100, RedLevel+50, RedLevel+25)*Multiplicator, gathering_skill_gain);
             else
@@ -5341,8 +5322,7 @@ bool Player::UpdateSkillPro(uint16 skillId, int32 chance, uint32 step)
     // levels sync. with spell requirement for skill levels to learn
     // bonus abilities in sSkillLineAbilityStore
     // Used only to avoid scan DBC at each skill grow
-    static uint32 bonusSkillLevels[] = { 75, 150, 225, 300, 375, 450, 525 };
-    static const size_t bonusSkillLevelsSize = sizeof(bonusSkillLevels) / sizeof(uint32);
+    uint32 const bonusSkillLevels[] = { 75, 150, 225, 300, 375, 450, 525, 600, 700, 850 };
 
     TC_LOG_DEBUG("entities.player.skills", "Player::UpdateSkillPro: Player '%s' (%s), SkillID: %u, Chance: %3.1f%%)",
         GetName().c_str(), GetGUID().ToString().c_str(), skillId, chance / 10.0f);
@@ -5363,8 +5343,8 @@ bool Player::UpdateSkillPro(uint16 skillId, int32 chance, uint32 step)
     uint16 field = itr->second.pos / 2;
     uint8 offset = itr->second.pos & 1; // itr->second.pos % 2
 
-    uint16 value = GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset);
-    uint16 max = GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
+    uint16 value = GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset);
+    uint16 max = GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
 
     if (!max || !value || value >= max)
         return false;
@@ -5380,13 +5360,12 @@ bool Player::UpdateSkillPro(uint16 skillId, int32 chance, uint32 step)
     if (new_value > max)
         new_value = max;
 
-    SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, new_value);
+    SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, new_value);
     if (itr->second.uState != SKILL_NEW)
         itr->second.uState = SKILL_CHANGED;
 
-    for (size_t i = 0; i < bonusSkillLevelsSize; ++i)
+    for (uint32 bsl : bonusSkillLevels)
     {
-        uint32 bsl = bonusSkillLevels[i];
         if (value < bsl && new_value >= bsl)
         {
             LearnSkillRewardedSpells(skillId, new_value);
@@ -5407,7 +5386,7 @@ void Player::ModifySkillBonus(uint32 skillid, int32 val, bool talent)
     if (itr == mSkillStatus.end() || itr->second.uState == SKILL_DELETED)
         return;
 
-    uint16 field = itr->second.pos / 2 + (talent ? PLAYER_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET : PLAYER_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET);
+    uint16 field = itr->second.pos / 2 + (talent ? ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET : ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET);
     uint8 offset = itr->second.pos & 1; // itr->second.pos % 2
 
     uint16 bonus = GetUInt16Value(field, offset);
@@ -5436,13 +5415,13 @@ void Player::UpdateSkillsForLevel()
         {
             if (!IsWeaponSkill(rcEntry->SkillID))
             {
-                uint16 max = GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
+                uint16 max = GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
 
                 /// update only level dependent max skill values
                 if (max != 1)
                 {
-                    SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, maxSkill);
-                    SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, maxSkill);
+                    SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, maxSkill);
+                    SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, maxSkill);
                     if (itr->second.uState != SKILL_NEW)
                         itr->second.uState = SKILL_CHANGED;
                 }
@@ -5450,7 +5429,7 @@ void Player::UpdateSkillsForLevel()
         }
 
         // Update level dependent skillline spells
-        LearnSkillRewardedSpells(rcEntry->SkillID, GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset));
+        LearnSkillRewardedSpells(rcEntry->SkillID, GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset));
     }
 }
 
@@ -5475,11 +5454,11 @@ void Player::UpdateSkillsToMaxSkillsForLevel()
         uint16 field = itr->second.pos / 2;
         uint8 offset = itr->second.pos & 1; // itr->second.pos % 2
 
-        uint16 max = GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
+        uint16 max = GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
 
         if (max > 1)
         {
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, max);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, max);
 
             if (itr->second.uState != SKILL_NEW)
                 itr->second.uState = SKILL_CHANGED;
@@ -5502,7 +5481,7 @@ void Player::SetSkill(uint16 id, uint16 step, uint16 newVal, uint16 maxVal)
     {
         uint16 field = itr->second.pos / 2;
         uint8 offset = itr->second.pos & 1; // itr->second.pos % 2
-        currVal = GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset);
+        currVal = GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset);
         if (newVal)
         {
             // if skill value is going down, update enchantments before setting the new value
@@ -5510,10 +5489,10 @@ void Player::SetSkill(uint16 id, uint16 step, uint16 newVal, uint16 maxVal)
                 UpdateSkillEnchantments(id, currVal, newVal);
 
             // update step
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, step);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, step);
             // update value
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, newVal);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, maxVal);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, newVal);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, maxVal);
 
             if (itr->second.uState != SKILL_NEW)
                 itr->second.uState = SKILL_CHANGED;
@@ -5531,12 +5510,12 @@ void Player::SetSkill(uint16 id, uint16 step, uint16 newVal, uint16 maxVal)
             //remove enchantments needing this skill
             UpdateSkillEnchantments(id, currVal, 0);
             // clear skill fields
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_ID_OFFSET + field, offset, 0);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, 0);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, 0);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, 0);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset, 0);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset, 0);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_ID_OFFSET + field, offset, 0);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, 0);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, 0);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, 0);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset, 0);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset, 0);
 
             // mark as deleted or simply remove from map if not saved yet
             if (itr->second.uState != SKILL_NEW)
@@ -5545,16 +5524,19 @@ void Player::SetSkill(uint16 id, uint16 step, uint16 newVal, uint16 maxVal)
                 mSkillStatus.erase(itr);
 
             // remove all spells that related to this skill
-            for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
-                if (SkillLineAbilityEntry const* pAbility = sSkillLineAbilityStore.LookupEntry(j))
-                    if (pAbility->SkillLine == id)
-                        RemoveSpell(sSpellMgr->GetFirstSpellInChain(pAbility->Spell));
+            if (std::vector<SkillLineAbilityEntry const*> const* skillLineAbilities = sDB2Manager.GetSkillLineAbilitiesBySkill(id))
+                for (SkillLineAbilityEntry const* skillLineAbility : *skillLineAbilities)
+                    RemoveSpell(sSpellMgr->GetFirstSpellInChain(skillLineAbility->Spell));
+
+            for (SkillLineEntry const* childSkillLine : sSkillLineStore)
+                if (childSkillLine->ParentSkillLineID == id)
+                    SetSkill(childSkillLine->ID, 0, 0, 0);
 
             // Clear profession lines
-            if (GetUInt32Value(PLAYER_PROFESSION_SKILL_LINE_1) == id)
-                SetUInt32Value(PLAYER_PROFESSION_SKILL_LINE_1, 0);
-            else if (GetUInt32Value(PLAYER_PROFESSION_SKILL_LINE_1 + 1) == id)
-                SetUInt32Value(PLAYER_PROFESSION_SKILL_LINE_1 + 1, 0);
+            if (GetUInt32Value(ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE) == id)
+                SetUInt32Value(ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE, 0);
+            else if (GetUInt32Value(ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE + 1) == id)
+                SetUInt32Value(ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE + 1, 0);
         }
     }
     else if (newVal)                                        //add
@@ -5565,7 +5547,7 @@ void Player::SetSkill(uint16 id, uint16 step, uint16 newVal, uint16 maxVal)
             uint16 field = i / 2;
             uint8 offset = i & 1; // i % 2
 
-            if (!GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_ID_OFFSET + field, offset))
+            if (!GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_ID_OFFSET + field, offset))
             {
                 SkillLineEntry const* skillEntry = sSkillLineStore.LookupEntry(id);
                 if (!skillEntry)
@@ -5575,18 +5557,30 @@ void Player::SetSkill(uint16 id, uint16 step, uint16 newVal, uint16 maxVal)
                     return;
                 }
 
-                SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_ID_OFFSET + field, offset, id);
-                if (skillEntry->CategoryID == SKILL_CATEGORY_PROFESSION)
+                if (skillEntry->ParentSkillLineID && skillEntry->ParentTierIndex > 0)
                 {
-                    if (!GetUInt32Value(PLAYER_PROFESSION_SKILL_LINE_1))
-                        SetUInt32Value(PLAYER_PROFESSION_SKILL_LINE_1, id);
-                    else if (!GetUInt32Value(PLAYER_PROFESSION_SKILL_LINE_1 + 1))
-                        SetUInt32Value(PLAYER_PROFESSION_SKILL_LINE_1 + 1, id);
+                    if (SkillRaceClassInfoEntry const* rcEntry = sDB2Manager.GetSkillRaceClassInfo(skillEntry->ParentSkillLineID, getRace(), getClass()))
+                    {
+                        if (SkillTiersEntry const* tier = sObjectMgr->GetSkillTier(rcEntry->SkillTierID))
+                        {
+                            uint16 skillval = GetPureSkillValue(skillEntry->ParentSkillLineID);
+                            SetSkill(skillEntry->ParentSkillLineID, skillEntry->ParentTierIndex, std::max<uint16>(skillval, 1), tier->Value[skillEntry->ParentTierIndex - 1]);
+                        }
+                    }
+
+                    if (skillEntry->CategoryID == SKILL_CATEGORY_PROFESSION)
+                    {
+                        int32 freeProfessionSlot = FindProfessionSlotFor(id);
+                        if (freeProfessionSlot != -1)
+                            SetUInt32Value(ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE + freeProfessionSlot, id);
+                    }
                 }
 
-                SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, step);
-                SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, newVal);
-                SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, maxVal);
+                SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_ID_OFFSET + field, offset, id);
+
+                SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, step);
+                SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, newVal);
+                SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, maxVal);
 
                 UpdateSkillEnchantments(id, currVal, newVal);
                 UpdateCriteria(CRITERIA_TYPE_REACH_SKILL_LEVEL, id);
@@ -5602,8 +5596,8 @@ void Player::SetSkill(uint16 id, uint16 step, uint16 newVal, uint16 maxVal)
                     mSkillStatus.insert(SkillStatusMap::value_type(id, SkillStatusData(i, SKILL_NEW)));
 
                 // apply skill bonuses
-                SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset, 0);
-                SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset, 0);
+                SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset, 0);
+                SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset, 0);
                 // temporary bonuses
                 AuraEffectList const& mModSkill = GetAuraEffectsByType(SPELL_AURA_MOD_SKILL);
                 for (AuraEffectList::const_iterator j = mModSkill.begin(); j != mModSkill.end(); ++j)
@@ -5646,7 +5640,7 @@ uint16 Player::GetSkillStep(uint16 skill) const
     if (itr == mSkillStatus.end() || itr->second.uState == SKILL_DELETED)
         return 0;
 
-    return GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_STEP_OFFSET + itr->second.pos / 2, itr->second.pos & 1);
+    return GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_STEP_OFFSET + itr->second.pos / 2, itr->second.pos & 1);
 }
 
 uint16 Player::GetSkillValue(uint32 skill) const
@@ -5661,9 +5655,9 @@ uint16 Player::GetSkillValue(uint32 skill) const
     uint16 field = itr->second.pos / 2;
     uint8 offset = itr->second.pos & 1;
 
-    int32 result = int32(GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset));
-    result += int32(GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset));
-    result += int32(GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset));
+    int32 result = int32(GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset));
+    result += int32(GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset));
+    result += int32(GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset));
     return result < 0 ? 0 : result;
 }
 
@@ -5679,9 +5673,9 @@ uint16 Player::GetMaxSkillValue(uint32 skill) const
     uint16 field = itr->second.pos / 2;
     uint8 offset = itr->second.pos & 1;
 
-    int32 result = int32(GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset));
-    result += int32(GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset));
-    result += int32(GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset));
+    int32 result = int32(GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset));
+    result += int32(GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset));
+    result += int32(GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset));
     return result < 0 ? 0 : result;
 }
 
@@ -5697,7 +5691,7 @@ uint16 Player::GetPureMaxSkillValue(uint32 skill) const
     uint16 field = itr->second.pos / 2;
     uint8 offset = itr->second.pos & 1;
 
-    return GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
+    return GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
 }
 
 uint16 Player::GetBaseSkillValue(uint32 skill) const
@@ -5712,8 +5706,8 @@ uint16 Player::GetBaseSkillValue(uint32 skill) const
     uint16 field = itr->second.pos / 2;
     uint8 offset = itr->second.pos & 1;
 
-    int32 result = int32(GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset));
-    result += int32(GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset));
+    int32 result = int32(GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset));
+    result += int32(GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset));
     return result < 0 ? 0 : result;
 }
 
@@ -5729,7 +5723,7 @@ uint16 Player::GetPureSkillValue(uint32 skill) const
     uint16 field = itr->second.pos / 2;
     uint8 offset = itr->second.pos & 1;
 
-    return GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset);
+    return GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset);
 }
 
 int16 Player::GetSkillPermBonusValue(uint32 skill) const
@@ -5744,7 +5738,7 @@ int16 Player::GetSkillPermBonusValue(uint32 skill) const
     uint16 field = itr->second.pos / 2;
     uint8 offset = itr->second.pos & 1;
 
-    return GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset);
+    return GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset);
 }
 
 int16 Player::GetSkillTempBonusValue(uint32 skill) const
@@ -5759,7 +5753,7 @@ int16 Player::GetSkillTempBonusValue(uint32 skill) const
     uint16 field = itr->second.pos / 2;
     uint8 offset = itr->second.pos & 1;
 
-    return GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset);
+    return GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset);
 }
 
 void Player::SendActionButtons(uint32 state) const
@@ -5993,11 +5987,11 @@ void Player::CheckAreaExploreAndOutdoor()
     }
 
     uint32 val = (uint32)(1 << (areaEntry->AreaBit % 32));
-    uint32 currFields = GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
+    uint32 currFields = GetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + offset);
 
     if (!(currFields & val))
     {
-        SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, (uint32)(currFields | val));
+        SetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + offset, (uint32)(currFields | val));
 
         UpdateCriteria(CRITERIA_TYPE_EXPLORE_AREA);
 
@@ -6272,14 +6266,14 @@ void Player::UpdateHonorFields()
         if (m_lastHonorUpdateTime >= yesterday)
         {
             // this is the first update today, reset today's contribution
-            uint16 killsToday = GetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS);
-            SetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS, 0);
-            SetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS, killsToday);
+            uint16 killsToday = GetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS, 0);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS, killsToday);
         }
         else
         {
             // no honor/kills yesterday or today, reset
-            SetUInt32Value(PLAYER_FIELD_KILLS, 0);
+            SetUInt32Value(ACTIVE_PLAYER_FIELD_KILLS, 0);
         }
     }
 
@@ -6363,9 +6357,9 @@ bool Player::RewardHonor(Unit* victim, uint32 groupsize, int32 honor, bool pvpto
             honor_f = std::ceil(Trinity::Honor::hk_honor_at_level_f(k_level) * (v_level - k_grey) / (k_level - k_grey));
 
             // count the number of playerkills in one day
-            ApplyModUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS, 1, true);
+            ApplyModUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS, 1, true);
             // and those in a lifetime
-            ApplyModUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, 1, true);
+            ApplyModUInt32Value(ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, 1, true);
             UpdateCriteria(CRITERIA_TYPE_EARN_HONORABLE_KILL);
             UpdateCriteria(CRITERIA_TYPE_HK_CLASS, victim->getClass());
             UpdateCriteria(CRITERIA_TYPE_HK_RACE, victim->getRace());
@@ -6443,15 +6437,12 @@ bool Player::RewardHonor(Unit* victim, uint32 groupsize, int32 honor, bool pvpto
     return true;
 }
 
-void Player::_InitHonorLevelOnLoadFromDB(uint32 honor, uint32 honorLevel, uint32 prestigeLevel)
+void Player::_InitHonorLevelOnLoadFromDB(uint32 honor, uint32 honorLevel)
 {
     SetUInt32Value(PLAYER_FIELD_HONOR_LEVEL, honorLevel);
-    SetUInt32Value(PLAYER_FIELD_PRESTIGE, prestigeLevel);
     UpdateHonorNextLevel();
 
     AddHonorXP(honor);
-    if (CanPrestige())
-        Prestige();
 }
 
 void Player::RewardPlayerWithRewardPack(uint32 rewardPackID)
@@ -6480,12 +6471,12 @@ void Player::RewardPlayerWithRewardPack(RewardPackEntry const* rewardPackEntry)
 
 void Player::AddHonorXP(uint32 xp)
 {
-    uint32 currentHonorXP = GetUInt32Value(PLAYER_FIELD_HONOR);
-    uint32 nextHonorLevelXP = GetUInt32Value(PLAYER_FIELD_HONOR_NEXT_LEVEL);
+    uint32 currentHonorXP = GetUInt32Value(ACTIVE_PLAYER_FIELD_HONOR);
+    uint32 nextHonorLevelXP = GetUInt32Value(ACTIVE_PLAYER_FIELD_HONOR_NEXT_LEVEL);
     uint32 newHonorXP = currentHonorXP + xp;
     uint32 honorLevel = GetHonorLevel();
 
-    if (xp < 1 || getLevel() < PLAYER_LEVEL_MIN_HONOR || IsMaxHonorLevelAndPrestige())
+    if (xp < 1 || getLevel() < PLAYER_LEVEL_MIN_HONOR || IsMaxHonorLevel())
         return;
 
     while (newHonorXP >= nextHonorLevelXP)
@@ -6496,67 +6487,30 @@ void Player::AddHonorXP(uint32 xp)
             SetHonorLevel(honorLevel + 1);
 
         honorLevel = GetHonorLevel();
-        nextHonorLevelXP = GetUInt32Value(PLAYER_FIELD_HONOR_NEXT_LEVEL);
+        nextHonorLevelXP = GetUInt32Value(ACTIVE_PLAYER_FIELD_HONOR_NEXT_LEVEL);
     }
 
-    SetUInt32Value(PLAYER_FIELD_HONOR, IsMaxHonorLevelAndPrestige() ? 0 : newHonorXP);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_HONOR, IsMaxHonorLevel() ? 0 : newHonorXP);
 }
 
 void Player::SetHonorLevel(uint8 level)
 {
     uint8 oldHonorLevel = GetHonorLevel();
-    uint8 prestige = GetPrestigeLevel();
     if (level == oldHonorLevel)
         return;
 
-    uint32 rewardPackID = sDB2Manager.GetRewardPackIDForPvpRewardByHonorLevelAndPrestige(level, prestige);
-    RewardPlayerWithRewardPack(rewardPackID);
-
     SetUInt32Value(PLAYER_FIELD_HONOR_LEVEL, level);
     UpdateHonorNextLevel();
 
     UpdateCriteria(CRITERIA_TYPE_HONOR_LEVEL_REACHED);
-
-    // This code is here because no link was found between those items and this reward condition in the db2 files.
-    // Interesting CriteriaTree found: Tree ids: 51140, 51156 (criteria id 31773, modifier tree id 37759)
-    if (level == 50 && prestige == 1)
-    {
-        if (GetTeam() == ALLIANCE)
-            AddItem(138992, 1);
-        else
-            AddItem(138996, 1);
-    }
-
-    if (CanPrestige())
-        Prestige();
-}
-
-void Player::Prestige()
-{
-    SetUInt32Value(PLAYER_FIELD_PRESTIGE, GetPrestigeLevel() + 1);
-    SetUInt32Value(PLAYER_FIELD_HONOR_LEVEL, 1);
-    UpdateHonorNextLevel();
-
-    UpdateCriteria(CRITERIA_TYPE_PRESTIGE_REACHED);
-}
-
-bool Player::CanPrestige() const
-{
-    if (GetSession()->GetExpansion() >= EXPANSION_LEGION && getLevel() >= PLAYER_LEVEL_MIN_HONOR && GetHonorLevel() >= PLAYER_MAX_HONOR_LEVEL && GetPrestigeLevel() < sDB2Manager.GetMaxPrestige())
-        return true;
-
-    return false;
-}
-
-bool Player::IsMaxPrestige() const
-{
-    return GetPrestigeLevel() == sDB2Manager.GetMaxPrestige();
 }
 
 void Player::UpdateHonorNextLevel()
 {
-    uint32 prestige = std::min(static_cast<uint32>(PRESTIGE_COLUMN_COUNT - 1), GetPrestigeLevel());
-    SetUInt32Value(PLAYER_FIELD_HONOR_NEXT_LEVEL, sHonorLevelGameTable.GetRow(GetHonorLevel())->Prestige[prestige]);
+    // 5500 at honor level 1
+    // no idea what between here
+    // 8800 at honor level ~14 (never goes above 8800)
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_HONOR_NEXT_LEVEL, 8800);
 }
 
 void Player::_LoadCurrency(PreparedQueryResult result)
@@ -6897,12 +6851,11 @@ uint32 Player::GetCurrencyTotalCap(CurrencyTypesEntry const* currency) const
 void Player::SetInGuild(ObjectGuid::LowType guildId)
 {
     if (guildId)
-        SetGuidValue(OBJECT_FIELD_DATA, ObjectGuid::Create<HighGuid::Guild>(guildId));
+        SetGuidValue(UNIT_FIELD_GUILD_GUID, ObjectGuid::Create<HighGuid::Guild>(guildId));
     else
-        SetGuidValue(OBJECT_FIELD_DATA, ObjectGuid::Empty);
+        SetGuidValue(UNIT_FIELD_GUILD_GUID, ObjectGuid::Empty);
 
     ApplyModFlag(PLAYER_FLAGS, PLAYER_FLAGS_GUILD_LEVEL_ENABLED, guildId != 0);
-    SetUInt16Value(OBJECT_FIELD_TYPE, 1, guildId != 0);
 }
 
 ObjectGuid::LowType Player::GetGuildIdFromDB(ObjectGuid guid)
@@ -6927,7 +6880,7 @@ uint8 Player::GetRankFromDB(ObjectGuid guid)
 
 void Player::SetArenaTeamInfoField(uint8 slot, ArenaTeamInfoType type, uint32 value)
 {
-    SetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (slot * ARENA_TEAM_END) + type, value);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO + (slot * ARENA_TEAM_END) + type, value);
 }
 
 void Player::SetInArenaTeam(uint32 ArenaTeamId, uint8 slot, uint8 type)
@@ -7516,6 +7469,9 @@ void Player::_ApplyItemBonuses(Item* item, uint8 slot, bool apply)
             case ITEM_MOD_MASTERY_RATING:
                 ApplyRatingMod(CR_MASTERY, int32(val * combatRatingMultiplier), apply);
                 break;
+            case ITEM_MOD_EXTRA_ARMOR:
+                HandleStatModifier(UNIT_MOD_ARMOR, TOTAL_VALUE, float(val), apply);
+                break;
             case ITEM_MOD_FIRE_RESISTANCE:
                 HandleStatModifier(UNIT_MOD_RESISTANCE_FIRE, BASE_VALUE, float(val), apply);
                 break;
@@ -7597,29 +7553,7 @@ void Player::_ApplyItemBonuses(Item* item, uint8 slot, bool apply)
     }
 
     if (uint32 armor = item->GetArmor(this))
-    {
-        UnitModifierType modType = TOTAL_VALUE;
-        if (proto->GetClass() == ITEM_CLASS_ARMOR)
-        {
-            switch (proto->GetSubClass())
-            {
-                case ITEM_SUBCLASS_ARMOR_CLOTH:
-                case ITEM_SUBCLASS_ARMOR_LEATHER:
-                case ITEM_SUBCLASS_ARMOR_MAIL:
-                case ITEM_SUBCLASS_ARMOR_PLATE:
-                case ITEM_SUBCLASS_ARMOR_SHIELD:
-                    modType = BASE_VALUE;
-                break;
-            }
-        }
-
-        HandleStatModifier(UNIT_MOD_ARMOR, modType, float(armor), apply);
-    }
-
-    /*
-    if (proto->GetArmorDamageModifier() > 0)
-        HandleStatModifier(UNIT_MOD_ARMOR, TOTAL_VALUE, float(proto->GetArmorDamageModifier()), apply);
-    */
+        HandleStatModifier(UNIT_MOD_ARMOR, BASE_VALUE, float(armor), apply);
 
     WeaponAttackType attType = BASE_ATTACK;
 
@@ -9989,7 +9923,7 @@ void Player::SetInventorySlotCount(uint8 slots)
         }
     }
 
-    SetByteValue(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_NUM_BACKPACK_SLOTS, slots);
+    SetByteValue(ACTIVE_PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_NUM_BACKPACK_SLOTS, slots);
 }
 
 bool Player::HasItemCount(uint32 item, uint32 count, bool inBankAlso) const
@@ -11883,7 +11817,7 @@ Item* Player::_StoreItem(uint16 pos, Item* pItem, uint32 count, bool clone, bool
         if (!pBag)
         {
             m_items[slot] = pItem;
-            SetGuidValue(PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), pItem->GetGUID());
+            SetGuidValue(ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), pItem->GetGUID());
             pItem->SetGuidValue(ITEM_FIELD_CONTAINED, GetGUID());
             pItem->SetOwnerGUID(GetGUID());
 
@@ -12230,7 +12164,7 @@ void Player::VisualizeItem(uint8 slot, Item* pItem)
         GetName().c_str(), GetGUID().ToString().c_str(), slot, pItem->GetEntry());
 
     m_items[slot] = pItem;
-    SetGuidValue(PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), pItem->GetGUID());
+    SetGuidValue(ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), pItem->GetGUID());
     pItem->SetGuidValue(ITEM_FIELD_CONTAINED, GetGUID());
     pItem->SetOwnerGUID(GetGUID());
     pItem->SetSlot(slot);
@@ -12310,7 +12244,7 @@ void Player::RemoveItem(uint8 bag, uint8 slot, bool update)
             }
 
             m_items[slot] = nullptr;
-            SetGuidValue(PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), ObjectGuid::Empty);
+            SetGuidValue(ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), ObjectGuid::Empty);
 
             if (slot < EQUIPMENT_SLOT_END)
             {
@@ -12412,7 +12346,7 @@ void Player::DestroyItem(uint8 bag, uint8 slot, bool update)
 
         if (bag == INVENTORY_SLOT_BAG_0)
         {
-            SetGuidValue(PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), ObjectGuid::Empty);
+            SetGuidValue(ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), ObjectGuid::Empty);
 
             // equipment and equipped bags can have applied bonuses
             if (slot < INVENTORY_SLOT_BAG_END)
@@ -13381,7 +13315,7 @@ void Player::AddItemToBuyBackSlot(Item* pItem)
         // if current back slot non-empty search oldest or free
         if (m_items[slot])
         {
-            uint32 oldest_time = GetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP_1);
+            uint32 oldest_time = GetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP);
             uint32 oldest_slot = BUYBACK_SLOT_START;
 
             for (uint32 i = BUYBACK_SLOT_START+1; i < BUYBACK_SLOT_END; ++i)
@@ -13393,7 +13327,7 @@ void Player::AddItemToBuyBackSlot(Item* pItem)
                     break;
                 }
 
-                uint32 i_time = GetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP_1 + i - BUYBACK_SLOT_START);
+                uint32 i_time = GetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP + i - BUYBACK_SLOT_START);
 
                 if (oldest_time > i_time)
                 {
@@ -13415,13 +13349,13 @@ void Player::AddItemToBuyBackSlot(Item* pItem)
         uint32 etime = uint32(base - m_logintime + (30 * 3600));
         uint32 eslot = slot - BUYBACK_SLOT_START;
 
-        SetGuidValue(PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), pItem->GetGUID());
+        SetGuidValue(ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), pItem->GetGUID());
         if (ItemTemplate const* proto = pItem->GetTemplate())
-            SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + eslot, proto->GetSellPrice() * pItem->GetCount());
+            SetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_PRICE + eslot, proto->GetSellPrice() * pItem->GetCount());
         else
-            SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + eslot, 0);
+            SetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_PRICE + eslot, 0);
 
-        SetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP_1 + eslot, (uint32)etime);
+        SetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP + eslot, (uint32)etime);
 
         // move to next (for non filled list is move most optimized choice)
         if (m_currentBuybackSlot < BUYBACK_SLOT_END - 1)
@@ -13455,9 +13389,9 @@ void Player::RemoveItemFromBuyBackSlot(uint32 slot, bool del)
         m_items[slot] = nullptr;
 
         uint32 eslot = slot - BUYBACK_SLOT_START;
-        SetGuidValue(PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), ObjectGuid::Empty);
-        SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + eslot, 0);
-        SetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP_1 + eslot, 0);
+        SetGuidValue(ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), ObjectGuid::Empty);
+        SetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_PRICE + eslot, 0);
+        SetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP + eslot, 0);
 
         // if current backslot is filled set to now free slot
         if (m_items[m_currentBuybackSlot])
@@ -14648,6 +14582,38 @@ uint32 Player::GetDefaultGossipMenuForSource(WorldObject* source)
 /***                    QUEST SYSTEM                   ***/
 /*********************************************************/
 
+int32 Player::GetQuestMinLevel(Quest const* quest) const
+{
+    if (quest->GetQuestLevel() == -1 && quest->GetQuestScalingFactionGroup())
+    {
+        ChrRacesEntry const* race = sChrRacesStore.AssertEntry(getRace());
+        FactionTemplateEntry const* raceFaction = sFactionTemplateStore.LookupEntry(race->FactionID);
+        if (!raceFaction || raceFaction->FactionGroup != quest->GetQuestScalingFactionGroup())
+            return quest->GetQuestMaxScalingLevel();
+    }
+
+    return quest->GetMinLevel();
+}
+
+int32 Player::GetQuestLevel(Quest const* quest) const
+{
+    if (!quest)
+        return 0;
+
+    if (quest->GetQuestLevel() == -1)
+    {
+        int32 minLevel = GetQuestMinLevel(quest);
+        int32 maxLevel = quest->GetQuestMaxScalingLevel();
+        int32 level = getLevel();
+        if (level >= minLevel)
+            return std::min(level, maxLevel);
+
+        return minLevel;
+    }
+
+    return quest->GetQuestLevel();
+}
+
 void Player::PrepareQuestMenu(ObjectGuid guid)
 {
     QuestRelationBounds objectQR;
@@ -14815,7 +14781,7 @@ bool Player::CanSeeStartQuest(Quest const* quest)
         SatisfyQuestPrevChain(quest, false) && SatisfyQuestDay(quest, false) && SatisfyQuestWeek(quest, false) &&
         SatisfyQuestMonth(quest, false) && SatisfyQuestSeasonal(quest, false))
     {
-        return int32(getLevel() + sWorld->getIntConfig(CONFIG_QUEST_HIGH_LEVEL_HIDE_DIFF)) >= quest->GetMinLevel();
+        return int32(getLevel() + sWorld->getIntConfig(CONFIG_QUEST_HIGH_LEVEL_HIDE_DIFF)) >= GetQuestMinLevel(quest);
     }
 
     return false;
@@ -15241,7 +15207,7 @@ void Player::IncompleteQuest(uint32 quest_id)
 
 uint32 Player::GetQuestMoneyReward(Quest const* quest) const
 {
-    return quest->MoneyValue(getLevel()) * sWorld->getRate(RATE_MONEY_QUEST);
+    return quest->MoneyValue(this) * sWorld->getRate(RATE_MONEY_QUEST);
 }
 
 uint32 Player::GetQuestXPReward(Quest const* quest)
@@ -15252,7 +15218,7 @@ uint32 Player::GetQuestXPReward(Quest const* quest)
     if (rewarded && !quest->IsDFQuest())
         return 0;
 
-    uint32 XP = quest->XPValue(getLevel()) * sWorld->getRate(RATE_XP_QUEST);
+    uint32 XP = quest->XPValue(this) * sWorld->getRate(RATE_XP_QUEST);
 
     // handle SPELL_AURA_MOD_XP_QUEST_PCT auras
     Unit::AuraEffectList const& ModXPPctAuras = GetAuraEffectsByType(SPELL_AURA_MOD_XP_QUEST_PCT);
@@ -15648,7 +15614,7 @@ bool Player::SatisfyQuestSkill(Quest const* qInfo, bool msg) const
 
 bool Player::SatisfyQuestLevel(Quest const* qInfo, bool msg) const
 {
-    if (getLevel() < qInfo->GetMinLevel())
+    if (getLevel() < GetQuestMinLevel(qInfo))
     {
         if (msg)
         {
@@ -16039,7 +16005,7 @@ bool Player::SatisfyQuestDay(Quest const* qInfo, bool /*msg*/) const
         return true;
     }
 
-    std::vector<uint32> const& dailies = GetDynamicValues(PLAYER_DYNAMIC_FIELD_DAILY_QUESTS);
+    std::vector<uint32> const& dailies = GetDynamicValues(ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS);
     for (uint32 dailyQuestId : dailies)
         if (dailyQuestId == qInfo->GetQuestId())
             return false;
@@ -16473,7 +16439,7 @@ void Player::SetQuestCompletedBit(uint32 questBit, bool completed)
     if (fieldOffset >= QUESTS_COMPLETED_BITS_SIZE)
         return;
 
-    ApplyModFlag(PLAYER_FIELD_QUEST_COMPLETED + ((questBit - 1) >> 5), 1 << ((questBit - 1) & 31), completed);
+    ApplyModFlag(ACTIVE_PLAYER_FIELD_QUEST_COMPLETED + ((questBit - 1) >> 5), 1 << ((questBit - 1) & 31), completed);
 }
 
 void Player::AreaExploredOrEventHappens(uint32 questId)
@@ -17377,7 +17343,7 @@ void Player::_LoadDeclinedNames(PreparedQueryResult result)
 void Player::_LoadArenaTeamInfo(PreparedQueryResult result)
 {
     // arenateamid, played_week, played_season, personal_rating
-    memset((void*)&m_uint32Values[PLAYER_FIELD_ARENA_TEAM_INFO_1_1], 0, sizeof(uint32) * MAX_ARENA_SLOT * ARENA_TEAM_END);
+    memset((void*)&m_uint32Values[ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO], 0, sizeof(uint32) * MAX_ARENA_SLOT * ARENA_TEAM_END);
 
     uint16 personalRatingCache[] = {0, 0, 0};
 
@@ -17664,8 +17630,8 @@ bool Player::LoadFromDB(ObjectGuid guid, SQLQueryHolder *holder)
     SetUInt32Value(UNIT_FIELD_LEVEL, fields[6].GetUInt8());
     SetXP(fields[7].GetUInt32());
 
-    _LoadIntoDataField(fields[66].GetString(), PLAYER_EXPLORED_ZONES_1, PLAYER_EXPLORED_ZONES_SIZE);
-    _LoadIntoDataField(fields[67].GetString(), PLAYER__FIELD_KNOWN_TITLES, KNOWN_TITLES_SIZE * 2);
+    _LoadIntoDataField(fields[66].GetString(), ACTIVE_PLAYER_FIELD_EXPLORED_ZONES, PLAYER_EXPLORED_ZONES_SIZE);
+    _LoadIntoDataField(fields[67].GetString(), ACTIVE_PLAYER_FIELD_KNOWN_TITLES, KNOWN_TITLES_SIZE * 2);
 
     SetObjectScale(1.0f);
     SetFloatValue(UNIT_FIELD_HOVERHEIGHT, 1.0f);
@@ -17697,7 +17663,7 @@ bool Player::LoadFromDB(ObjectGuid guid, SQLQueryHolder *holder)
     SetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_INEBRIATION, fields[55].GetUInt8());
     SetUInt32Value(PLAYER_FLAGS, fields[20].GetUInt32());
     SetUInt32Value(PLAYER_FLAGS_EX, fields[21].GetUInt32());
-    SetInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, fields[54].GetUInt32());
+    SetInt32Value(ACTIVE_PLAYER_FIELD_WATCHED_FACTION_INDEX, fields[54].GetUInt32());
 
     if (!ValidateAppearance(
         fields[3].GetUInt8(), // race
@@ -17715,7 +17681,7 @@ bool Player::LoadFromDB(ObjectGuid guid, SQLQueryHolder *holder)
     }
 
     // set which actionbars the client has active - DO NOT REMOVE EVER AGAIN (can be changed though, if it does change fieldwise)
-    SetByteValue(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_ACTION_BAR_TOGGLES, fields[68].GetUInt8());
+    SetByteValue(ACTIVE_PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_ACTION_BAR_TOGGLES, fields[68].GetUInt8());
 
     m_fishingSteps = fields[72].GetUInt8();
 
@@ -17724,7 +17690,7 @@ bool Player::LoadFromDB(ObjectGuid guid, SQLQueryHolder *holder)
     // cleanup inventory related item value fields (it will be filled correctly in _LoadInventory)
     for (uint8 slot = EQUIPMENT_SLOT_START; slot < EQUIPMENT_SLOT_END; ++slot)
     {
-        SetGuidValue(PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), ObjectGuid::Empty);
+        SetGuidValue(ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD + (slot * 4), ObjectGuid::Empty);
         SetVisibleItemSlot(slot, nullptr);
 
         delete m_items[slot];
@@ -17781,9 +17747,9 @@ bool Player::LoadFromDB(ObjectGuid guid, SQLQueryHolder *holder)
     }
 
     _LoadCurrency(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_CURRENCY));
-    SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, fields[50].GetUInt32());
-    SetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS, fields[51].GetUInt16());
-    SetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS, fields[52].GetUInt16());
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, fields[50].GetUInt32());
+    SetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS, fields[51].GetUInt16());
+    SetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS, fields[52].GetUInt16());
 
     _LoadBoundInstances(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_BOUND_INSTANCES));
     _LoadInstanceTimeRestrictions(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_INSTANCE_LOCK_TIMES));
@@ -18113,14 +18079,14 @@ bool Player::LoadFromDB(ObjectGuid guid, SQLQueryHolder *holder)
     SetGuidValue(UNIT_FIELD_CHARMEDBY, ObjectGuid::Empty);
     SetGuidValue(UNIT_FIELD_CHARM, ObjectGuid::Empty);
     SetGuidValue(UNIT_FIELD_SUMMON, ObjectGuid::Empty);
-    SetGuidValue(PLAYER_FARSIGHT, ObjectGuid::Empty);
+    SetGuidValue(ACTIVE_PLAYER_FIELD_FARSIGHT, ObjectGuid::Empty);
     SetCreatorGUID(ObjectGuid::Empty);
 
     RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FORCE_MOVEMENT);
 
     // reset some aura modifiers before aura apply
-    SetUInt32Value(PLAYER_TRACK_CREATURES, 0);
-    SetUInt32Value(PLAYER_TRACK_RESOURCES, 0);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_TRACK_CREATURES, 0);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_TRACK_RESOURCES, 0);
 
     // make sure the unit is considered out of combat for proper loading
     ClearInCombat();
@@ -18322,7 +18288,7 @@ bool Player::LoadFromDB(ObjectGuid guid, SQLQueryHolder *holder)
         SetFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_REFER_A_FRIEND);
 
     if (m_grantableLevels > 0)
-        SetByteValue(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_RAF_GRANTABLE_LEVEL, 0x01);
+        SetByteValue(ACTIVE_PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_RAF_GRANTABLE_LEVEL, 0x01);
 
     _LoadDeclinedNames(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_DECLINED_NAMES));
 
@@ -18339,9 +18305,9 @@ bool Player::LoadFromDB(ObjectGuid guid, SQLQueryHolder *holder)
         holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_GARRISON_FOLLOWER_ABILITIES)))
         _garrison = std::move(garrison);
 
-    _InitHonorLevelOnLoadFromDB(fields[73].GetUInt32(), fields[74].GetUInt32(), fields[75].GetUInt32());
+    _InitHonorLevelOnLoadFromDB(fields[73].GetUInt32(), fields[74].GetUInt32());
 
-    _restMgr->LoadRestBonus(REST_TYPE_HONOR, PlayerRestState(fields[76].GetUInt8()), fields[77].GetFloat());
+    _restMgr->LoadRestBonus(REST_TYPE_HONOR, PlayerRestState(fields[75].GetUInt8()), fields[76].GetFloat());
     if (time_diff > 0)
     {
         //speed collect rest bonus in offline, in logout, far from tavern, city (section/in hour)
@@ -18582,7 +18548,7 @@ void Player::LoadCorpse(PreparedQueryResult result)
         {
             Field* fields = result->Fetch();
             _corpseLocation.WorldRelocate(fields[0].GetUInt16(), fields[1].GetFloat(), fields[2].GetFloat(), fields[3].GetFloat(), fields[4].GetFloat());
-            ApplyModFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER, !sMapStore.LookupEntry(_corpseLocation.GetMapId())->Instanceable());
+            ApplyModFlag(ACTIVE_PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER, !sMapStore.LookupEntry(_corpseLocation.GetMapId())->Instanceable());
         }
         else
             ResurrectPlayer(0.5f);
@@ -19307,7 +19273,7 @@ void Player::_LoadDailyQuestStatus(PreparedQueryResult result)
             if (!quest)
                 continue;
 
-            AddDynamicValue(PLAYER_DYNAMIC_FIELD_DAILY_QUESTS, quest_id);
+            AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS, quest_id);
             if (uint32 questBit = sDB2Manager.GetQuestUniqueBitFlag(quest_id))
                 SetQuestCompletedBit(questBit, true);
 
@@ -19703,7 +19669,7 @@ void Player::SendRaidInfo()
             {
                 InstanceSave* save = itr->second.save;
 
-                WorldPackets::Instance::InstanceLockInfos lockInfos;
+                WorldPackets::Instance::InstanceLock lockInfos;
 
                 lockInfos.InstanceID = save->GetInstanceId();
                 lockInfos.MapID = save->GetMapId();
@@ -19985,7 +19951,7 @@ void Player::SaveToDB(bool create /*=false*/)
         stmt->setUInt8(index++, getClass());
         stmt->setUInt8(index++, GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER));   // save gender from PLAYER_BYTES_3, UNIT_BYTES_0 changes with every transform effect
         stmt->setUInt8(index++, getLevel());
-        stmt->setUInt32(index++, GetUInt32Value(PLAYER_XP));
+        stmt->setUInt32(index++, GetUInt32Value(ACTIVE_PLAYER_FIELD_XP));
         stmt->setUInt64(index++, GetMoney());
         stmt->setUInt8(index++, GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID));
         stmt->setUInt8(index++, GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_FACE_ID));
@@ -19996,7 +19962,7 @@ void Player::SaveToDB(bool create /*=false*/)
             stmt->setUInt8(index++, GetByteValue(PLAYER_BYTES_2, PLAYER_BYTES_2_OFFSET_CUSTOM_DISPLAY_OPTION + i));
         stmt->setUInt8(index++, GetInventorySlotCount());
         stmt->setUInt8(index++, GetBankBagSlotCount());
-        stmt->setUInt8(index++, uint8(GetUInt32Value(PLAYER_FIELD_REST_INFO + REST_STATE_XP)));
+        stmt->setUInt8(index++, uint8(GetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + REST_STATE_XP)));
         stmt->setUInt32(index++, GetUInt32Value(PLAYER_FLAGS));
         stmt->setUInt32(index++, GetUInt32Value(PLAYER_FLAGS_EX));
         stmt->setUInt16(index++, (uint16)GetMapId());
@@ -20041,11 +20007,11 @@ void Player::SaveToDB(bool create /*=false*/)
         ss << m_taxi.SaveTaxiDestinationsToString();
 
         stmt->setString(index++, ss.str());
-        stmt->setUInt32(index++, GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS));
-        stmt->setUInt16(index++, GetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS));
-        stmt->setUInt16(index++, GetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS));
+        stmt->setUInt32(index++, GetUInt32Value(ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS));
+        stmt->setUInt16(index++, GetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS));
+        stmt->setUInt16(index++, GetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS));
         stmt->setUInt32(index++, GetUInt32Value(PLAYER_CHOSEN_TITLE));
-        stmt->setUInt32(index++, GetUInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX));
+        stmt->setUInt32(index++, GetUInt32Value(ACTIVE_PLAYER_FIELD_WATCHED_FACTION_INDEX));
         stmt->setUInt8(index++, GetDrunkValue());
         stmt->setUInt32(index++, GetHealth());
 
@@ -20071,7 +20037,7 @@ void Player::SaveToDB(bool create /*=false*/)
 
         ss.str("");
         for (uint32 i = 0; i < PLAYER_EXPLORED_ZONES_SIZE; ++i)
-            ss << GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + i) << ' ';
+            ss << GetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + i) << ' ';
         stmt->setString(index++, ss.str());
 
         ss.str("");
@@ -20096,10 +20062,10 @@ void Player::SaveToDB(bool create /*=false*/)
 
         ss.str("");
         for (uint32 i = 0; i < KNOWN_TITLES_SIZE * 2; ++i)
-            ss << GetUInt32Value(PLAYER__FIELD_KNOWN_TITLES + i) << ' ';
+            ss << GetUInt32Value(ACTIVE_PLAYER_FIELD_KNOWN_TITLES + i) << ' ';
         stmt->setString(index++, ss.str());
 
-        stmt->setUInt8(index++, GetByteValue(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_ACTION_BAR_TOGGLES));
+        stmt->setUInt8(index++, GetByteValue(ACTIVE_PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_ACTION_BAR_TOGGLES));
         stmt->setUInt32(index++, m_grantableLevels);
         stmt->setUInt32(index++, realm.Build);
     }
@@ -20112,7 +20078,7 @@ void Player::SaveToDB(bool create /*=false*/)
         stmt->setUInt8(index++, getClass());
         stmt->setUInt8(index++, GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_GENDER));   // save gender from PLAYER_BYTES_3, UNIT_BYTES_0 changes with every transform effect
         stmt->setUInt8(index++, getLevel());
-        stmt->setUInt32(index++, GetUInt32Value(PLAYER_XP));
+        stmt->setUInt32(index++, GetUInt32Value(ACTIVE_PLAYER_FIELD_XP));
         stmt->setUInt64(index++, GetMoney());
         stmt->setUInt8(index++, GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_SKIN_ID));
         stmt->setUInt8(index++, GetByteValue(PLAYER_BYTES, PLAYER_BYTES_OFFSET_FACE_ID));
@@ -20123,7 +20089,7 @@ void Player::SaveToDB(bool create /*=false*/)
             stmt->setUInt8(index++, GetByteValue(PLAYER_BYTES_2, PLAYER_BYTES_2_OFFSET_CUSTOM_DISPLAY_OPTION + i));
         stmt->setUInt8(index++, GetInventorySlotCount());
         stmt->setUInt8(index++, GetBankBagSlotCount());
-        stmt->setUInt8(index++, uint8(GetUInt32Value(PLAYER_FIELD_REST_INFO + REST_STATE_XP)));
+        stmt->setUInt8(index++, uint8(GetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + REST_STATE_XP)));
         stmt->setUInt32(index++, GetUInt32Value(PLAYER_FLAGS));
         stmt->setUInt32(index++, GetUInt32Value(PLAYER_FLAGS_EX));
 
@@ -20185,11 +20151,11 @@ void Player::SaveToDB(bool create /*=false*/)
         ss << m_taxi.SaveTaxiDestinationsToString();
 
         stmt->setString(index++, ss.str());
-        stmt->setUInt32(index++, GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS));
-        stmt->setUInt16(index++, GetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS));
-        stmt->setUInt16(index++, GetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS));
+        stmt->setUInt32(index++, GetUInt32Value(ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS));
+        stmt->setUInt16(index++, GetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS));
+        stmt->setUInt16(index++, GetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS));
         stmt->setUInt32(index++, GetUInt32Value(PLAYER_CHOSEN_TITLE));
-        stmt->setUInt32(index++, GetUInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX));
+        stmt->setUInt32(index++, GetUInt32Value(ACTIVE_PLAYER_FIELD_WATCHED_FACTION_INDEX));
         stmt->setUInt8(index++, GetDrunkValue());
         stmt->setUInt32(index++, GetHealth());
 
@@ -20215,7 +20181,7 @@ void Player::SaveToDB(bool create /*=false*/)
 
         ss.str("");
         for (uint32 i = 0; i < PLAYER_EXPLORED_ZONES_SIZE; ++i)
-            ss << GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + i) << ' ';
+            ss << GetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + i) << ' ';
         stmt->setString(index++, ss.str());
 
         ss.str("");
@@ -20240,17 +20206,16 @@ void Player::SaveToDB(bool create /*=false*/)
 
         ss.str("");
         for (uint32 i = 0; i < KNOWN_TITLES_SIZE*2; ++i)
-            ss << GetUInt32Value(PLAYER__FIELD_KNOWN_TITLES + i) << ' ';
+            ss << GetUInt32Value(ACTIVE_PLAYER_FIELD_KNOWN_TITLES + i) << ' ';
 
         stmt->setString(index++, ss.str());
-        stmt->setUInt8(index++, GetByteValue(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_ACTION_BAR_TOGGLES));
+        stmt->setUInt8(index++, GetByteValue(ACTIVE_PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_ACTION_BAR_TOGGLES));
         stmt->setUInt32(index++, m_grantableLevels);
 
         stmt->setUInt8(index++, IsInWorld() && !GetSession()->PlayerLogout() ? 1 : 0);
-        stmt->setUInt32(index++, GetUInt32Value(PLAYER_FIELD_HONOR));
+        stmt->setUInt32(index++, GetUInt32Value(ACTIVE_PLAYER_FIELD_HONOR));
         stmt->setUInt32(index++, GetHonorLevel());
-        stmt->setUInt32(index++, GetPrestigeLevel());
-        stmt->setUInt8(index++, uint8(GetUInt32Value(PLAYER_FIELD_REST_INFO + REST_STATE_HONOR)));
+        stmt->setUInt8(index++, uint8(GetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + REST_STATE_HONOR)));
         stmt->setFloat(index++, finiteAlways(_restMgr->GetRestBonus(REST_TYPE_HONOR)));
         stmt->setUInt32(index++, realm.Build);
 
@@ -20821,7 +20786,7 @@ void Player::_SaveDailyQuestStatus(SQLTransaction& trans)
     stmt->setUInt64(0, GetGUID().GetCounter());
     trans->Append(stmt);
 
-    std::vector<uint32> const& dailies = GetDynamicValues(PLAYER_DYNAMIC_FIELD_DAILY_QUESTS);
+    std::vector<uint32> const& dailies = GetDynamicValues(ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS);
     for (uint32 questId : dailies)
     {
         stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHARACTER_QUESTSTATUS_DAILY);
@@ -20945,8 +20910,8 @@ void Player::_SaveSkills(SQLTransaction& trans)
         uint16 field = itr->second.pos / 2;
         uint8 offset = itr->second.pos & 1;
 
-        uint16 value = GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset);
-        uint16 max = GetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
+        uint16 value = GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset);
+        uint16 max = GetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset);
 
         switch (itr->second.uState)
         {
@@ -21040,18 +21005,18 @@ void Player::_SaveStats(SQLTransaction& trans) const
         stmt->setUInt32(index++, GetStat(Stats(i)));
 
     for (int i = 0; i < MAX_SPELL_SCHOOL; ++i)
-        stmt->setUInt32(index++, GetResistance(SpellSchools(i)));
-
-    stmt->setFloat(index++, GetFloatValue(PLAYER_BLOCK_PERCENTAGE));
-    stmt->setFloat(index++, GetFloatValue(PLAYER_DODGE_PERCENTAGE));
-    stmt->setFloat(index++, GetFloatValue(PLAYER_PARRY_PERCENTAGE));
-    stmt->setFloat(index++, GetFloatValue(PLAYER_CRIT_PERCENTAGE));
-    stmt->setFloat(index++, GetFloatValue(PLAYER_RANGED_CRIT_PERCENTAGE));
-    stmt->setFloat(index++, GetFloatValue(PLAYER_SPELL_CRIT_PERCENTAGE1));
+        stmt->setUInt32(index++, GetResistance(SpellSchools(i)) + GetBonusResistanceMod(SpellSchools(i)));
+
+    stmt->setFloat(index++, GetFloatValue(ACTIVE_PLAYER_FIELD_BLOCK_PERCENTAGE));
+    stmt->setFloat(index++, GetFloatValue(ACTIVE_PLAYER_FIELD_DODGE_PERCENTAGE));
+    stmt->setFloat(index++, GetFloatValue(ACTIVE_PLAYER_FIELD_PARRY_PERCENTAGE));
+    stmt->setFloat(index++, GetFloatValue(ACTIVE_PLAYER_FIELD_CRIT_PERCENTAGE));
+    stmt->setFloat(index++, GetFloatValue(ACTIVE_PLAYER_FIELD_RANGED_CRIT_PERCENTAGE));
+    stmt->setFloat(index++, GetFloatValue(ACTIVE_PLAYER_FIELD_SPELL_CRIT_PERCENTAGE1));
     stmt->setUInt32(index++, GetUInt32Value(UNIT_FIELD_ATTACK_POWER));
     stmt->setUInt32(index++, GetUInt32Value(UNIT_FIELD_RANGED_ATTACK_POWER));
     stmt->setUInt32(index++, GetBaseSpellPowerBonus());
-    stmt->setUInt32(index, GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + CR_RESILIENCE_PLAYER_DAMAGE));
+    stmt->setUInt32(index, GetUInt32Value(ACTIVE_PLAYER_FIELD_COMBAT_RATING + CR_RESILIENCE_PLAYER_DAMAGE));
 
     trans->Append(stmt);
 }
@@ -21065,10 +21030,10 @@ void Player::outDebugValues() const
     TC_LOG_DEBUG("entities.unit", "AGILITY is: \t\t%f\t\tSTRENGTH is: \t\t%f", GetStat(STAT_AGILITY), GetStat(STAT_STRENGTH));
     TC_LOG_DEBUG("entities.unit", "INTELLECT is: \t\t%f", GetStat(STAT_INTELLECT));
     TC_LOG_DEBUG("entities.unit", "STAMINA is: \t\t%f", GetStat(STAT_STAMINA));
-    TC_LOG_DEBUG("entities.unit", "Armor is: \t\t%u\t\tBlock is: \t\t%f", GetArmor(), GetFloatValue(PLAYER_BLOCK_PERCENTAGE));
-    TC_LOG_DEBUG("entities.unit", "HolyRes is: \t\t%u\t\tFireRes is: \t\t%u", GetResistance(SPELL_SCHOOL_HOLY), GetResistance(SPELL_SCHOOL_FIRE));
-    TC_LOG_DEBUG("entities.unit", "NatureRes is: \t\t%u\t\tFrostRes is: \t\t%u", GetResistance(SPELL_SCHOOL_NATURE), GetResistance(SPELL_SCHOOL_FROST));
-    TC_LOG_DEBUG("entities.unit", "ShadowRes is: \t\t%u\t\tArcaneRes is: \t\t%u", GetResistance(SPELL_SCHOOL_SHADOW), GetResistance(SPELL_SCHOOL_ARCANE));
+    TC_LOG_DEBUG("entities.unit", "Armor is: \t\t%u\t\tBlock is: \t\t%f", GetArmor(), GetFloatValue(ACTIVE_PLAYER_FIELD_BLOCK_PERCENTAGE));
+    TC_LOG_DEBUG("entities.unit", "HolyRes is: \t\t%u\t\tFireRes is: \t\t%u", GetResistance(SPELL_SCHOOL_MASK_HOLY), GetResistance(SPELL_SCHOOL_MASK_FIRE));
+    TC_LOG_DEBUG("entities.unit", "NatureRes is: \t\t%u\t\tFrostRes is: \t\t%u", GetResistance(SPELL_SCHOOL_MASK_NATURE), GetResistance(SPELL_SCHOOL_MASK_FROST));
+    TC_LOG_DEBUG("entities.unit", "ShadowRes is: \t\t%u\t\tArcaneRes is: \t\t%u", GetResistance(SPELL_SCHOOL_MASK_SHADOW), GetResistance(SPELL_SCHOOL_MASK_ARCANE));
     TC_LOG_DEBUG("entities.unit", "MIN_DAMAGE is: \t\t%f\tMAX_DAMAGE is: \t\t%f", GetFloatValue(UNIT_FIELD_MINDAMAGE), GetFloatValue(UNIT_FIELD_MAXDAMAGE));
     TC_LOG_DEBUG("entities.unit", "MIN_OFFHAND_DAMAGE is: \t%f\tMAX_OFFHAND_DAMAGE is: \t%f", GetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE), GetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE));
     TC_LOG_DEBUG("entities.unit", "MIN_RANGED_DAMAGE is: \t%f\tMAX_RANGED_DAMAGE is: \t%f", GetFloatValue(UNIT_FIELD_MINRANGEDDAMAGE), GetFloatValue(UNIT_FIELD_MAXRANGEDDAMAGE));
@@ -22392,6 +22357,8 @@ void Player::InitDisplayIds()
         default:
             TC_LOG_ERROR("entities.player", "Player::InitDisplayIds: Player '%s' (%s) has invalid gender %u", GetName().c_str(), GetGUID().ToString().c_str(), gender);
     }
+
+    SetUInt32Value(UNIT_FIELD_STATE_ANIM_ID, sAnimationDataStore.GetNumRows());
 }
 
 inline bool Player::_StoreOrEquipNewItem(uint32 vendorslot, uint32 item, uint8 count, uint8 bag, uint8 slot, int64 price, ItemTemplate const* pProto, Creature* pVendor, VendorItem const* crItem, bool bStore)
@@ -23303,7 +23270,7 @@ bool Player::CanAlwaysSee(WorldObject const* obj) const
     if (m_unitMovedByMe == obj)
         return true;
 
-    ObjectGuid guid = GetGuidValue(PLAYER_FARSIGHT);
+    ObjectGuid guid = GetGuidValue(ACTIVE_PLAYER_FIELD_FARSIGHT);
     if (!guid.IsEmpty())
         if (obj->GetGUID() == guid)
             return true;
@@ -23575,7 +23542,7 @@ bool Player::HasEnoughMoney(int64 amount) const
 
 void Player::SetMoney(uint64 value)
 {
-    SetUInt64Value(PLAYER_FIELD_COINAGE, value);
+    SetUInt64Value(ACTIVE_PLAYER_FIELD_COINAGE, value);
     MoneyChanged(value);
     UpdateCriteria(CRITERIA_TYPE_HIGHEST_GOLD_VALUE_OWNED);
 }
@@ -24063,19 +24030,15 @@ void Player::LearnDefaultSkill(SkillRaceClassInfoEntry const* rcInfo)
             break;
         case SKILL_RANGE_RANK:
         {
-            uint16 rank = 1;
-            if (getClass() == CLASS_DEATH_KNIGHT && skillId == SKILL_FIRST_AID)
-                rank = 4;
-
             SkillTiersEntry const* tier = sObjectMgr->GetSkillTier(rcInfo->SkillTierID);
-            uint16 maxValue = tier->Value[std::max<int32>(rank - 1, 0)];
+            uint16 maxValue = tier->Value[0];
             uint16 skillValue = 1;
             if (rcInfo->Flags & SKILL_FLAG_ALWAYS_MAX_VALUE)
                 skillValue = maxValue;
             else if (getClass() == CLASS_DEATH_KNIGHT)
                 skillValue = std::min(std::max(uint16(1), uint16((getLevel() - 1) * 5)), maxValue);
 
-            SetSkill(skillId, rank, skillValue, maxValue);
+            SetSkill(skillId, 1, skillValue, maxValue);
             break;
         }
         default:
@@ -24154,12 +24117,12 @@ void Player::LearnSkillRewardedSpells(uint32 skillId, uint32 skillValue)
 {
     uint64 raceMask  = getRaceMask();
     uint32 classMask = getClassMask();
-    for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
-    {
-        SkillLineAbilityEntry const* ability = sSkillLineAbilityStore.LookupEntry(j);
-        if (!ability || ability->SkillLine != int32(skillId))
-            continue;
+    std::vector<SkillLineAbilityEntry const*> const* skillLineAbilities = sDB2Manager.GetSkillLineAbilitiesBySkill(skillId);
+    if (!skillLineAbilities)
+        return;
 
+    for (SkillLineAbilityEntry const* ability : *skillLineAbilities)
+    {
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(ability->Spell);
         if (!spellInfo)
             continue;
@@ -24194,6 +24157,42 @@ void Player::LearnSkillRewardedSpells(uint32 skillId, uint32 skillValue)
     }
 }
 
+int32 Player::FindProfessionSlotFor(uint32 skillId) const
+{
+    SkillLineEntry const* skillEntry = sSkillLineStore.LookupEntry(skillId);
+    if (!skillEntry)
+        return -1;
+
+    uint32 constexpr professionSlots = 2;
+    uint32 const* professionsBegin = &m_uint32Values[ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE];
+    uint32 const* professionsEnd = professionsBegin + professionSlots;
+
+    // both free, return first slot
+    if (std::none_of(professionsBegin, professionsEnd, [](uint32 slot) { return slot != 0; }))
+        return 0;
+
+    // when any slot is filled we need to check both - one of them might be earlier step of the same profession
+    auto sameProfessionSlot = std::find_if(professionsBegin, professionsEnd, [&](uint32 slot)
+    {
+        if (SkillLineEntry const* slotProfession = sSkillLineStore.LookupEntry(slot))
+            if (slotProfession->ParentSkillLineID == skillEntry->ParentSkillLineID)
+                return true;
+        return false;
+    });
+
+    if (sameProfessionSlot != professionsEnd)
+    {
+        if (sSkillLineStore.AssertEntry(*sameProfessionSlot)->ParentTierIndex < skillEntry->ParentTierIndex)
+            return std::distance(professionsBegin, sameProfessionSlot);
+
+        return -1;
+    }
+
+    // if there is no same profession, find any free slot
+    auto freeSlot = std::find(professionsBegin, professionsEnd, 0u);
+    return freeSlot != professionsEnd ? std::distance(professionsBegin, freeSlot) : -1;
+}
+
 void Player::SendAurasForTarget(Unit* target) const
 {
     if (!target || target->GetVisibleAuras().empty())                  // speedup things
@@ -24222,7 +24221,7 @@ void Player::SetDailyQuestStatus(uint32 quest_id)
     {
         if (!qQuest->IsDFQuest())
         {
-            AddDynamicValue(PLAYER_DYNAMIC_FIELD_DAILY_QUESTS, quest_id);
+            AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS, quest_id);
             m_lastDailyQuestTime = time(nullptr);              // last daily quest time
             m_DailyQuestChanged = true;
         }
@@ -24240,7 +24239,7 @@ bool Player::IsDailyQuestDone(uint32 quest_id)
     bool found = false;
     if (sObjectMgr->GetQuestTemplate(quest_id))
     {
-        std::vector<uint32> const& dailies = GetDynamicValues(PLAYER_DYNAMIC_FIELD_DAILY_QUESTS);
+        std::vector<uint32> const& dailies = GetDynamicValues(ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS);
         for (uint32 dailyQuestId : dailies)
         {
             if (dailyQuestId == quest_id)
@@ -24278,15 +24277,15 @@ void Player::SetMonthlyQuestStatus(uint32 quest_id)
 
 void Player::DailyReset()
 {
-    for (uint32 questId : GetDynamicValues(PLAYER_DYNAMIC_FIELD_DAILY_QUESTS))
+    for (uint32 questId : GetDynamicValues(ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS))
         if (uint32 questBit = sDB2Manager.GetQuestUniqueBitFlag(questId))
             SetQuestCompletedBit(questBit, false);
 
     WorldPackets::Quest::DailyQuestsReset dailyQuestsReset;
-    dailyQuestsReset.Count = int32(GetDynamicValues(PLAYER_DYNAMIC_FIELD_DAILY_QUESTS).size());
+    dailyQuestsReset.Count = int32(GetDynamicValues(ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS).size());
     SendDirectMessage(dailyQuestsReset.Write());
 
-    ClearDynamicValue(PLAYER_DYNAMIC_FIELD_DAILY_QUESTS);
+    ClearDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_DAILY_QUESTS);
 
     m_DFQuests.clear(); // Dungeon Finder Quests.
 
@@ -24506,7 +24505,7 @@ Player* Player::GetTrader() const
 
 bool Player::IsSpellFitByClassAndRace(uint32 spell_id) const
 {
-    uint32 racemask  = getRaceMask();
+    uint64 racemask  = getRaceMask();
     uint32 classmask = getClassMask();
 
     SkillLineAbilityMapBounds bounds = sSpellMgr->GetSkillLineAbilityMapBounds(spell_id);
@@ -24801,10 +24800,10 @@ bool Player::CanNoReagentCast(SpellInfo const* spellInfo) const
 
     // Check no reagent use mask
     flag128 noReagentMask;
-    noReagentMask[0] = GetUInt32Value(PLAYER_NO_REAGENT_COST_1);
-    noReagentMask[1] = GetUInt32Value(PLAYER_NO_REAGENT_COST_1 + 1);
-    noReagentMask[2] = GetUInt32Value(PLAYER_NO_REAGENT_COST_1 + 2);
-    noReagentMask[3] = GetUInt32Value(PLAYER_NO_REAGENT_COST_1 + 3);
+    noReagentMask[0] = GetUInt32Value(ACTIVE_PLAYER_FIELD_NO_REAGENT_COST);
+    noReagentMask[1] = GetUInt32Value(ACTIVE_PLAYER_FIELD_NO_REAGENT_COST + 1);
+    noReagentMask[2] = GetUInt32Value(ACTIVE_PLAYER_FIELD_NO_REAGENT_COST + 2);
+    noReagentMask[3] = GetUInt32Value(ACTIVE_PLAYER_FIELD_NO_REAGENT_COST + 3);
     if (spellInfo->SpellFamilyFlags  & noReagentMask)
         return true;
 
@@ -24845,7 +24844,7 @@ void Player::RemoveItemDependentAurasAndCasts(Item* pItem)
 
 void Player::InitializeSelfResurrectionSpells()
 {
-    ClearDynamicValue(PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS);
+    ClearDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS);
 
     uint32 spells[3] = { };
 
@@ -24866,7 +24865,7 @@ void Player::InitializeSelfResurrectionSpells()
 
     for (uint32 selfResSpell : spells)
         if (selfResSpell)
-            AddDynamicValue(PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS, selfResSpell);
+            AddDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS, selfResSpell);
 }
 
 // Used in triggers for check "Only to targets that grant experience or honor" req
@@ -25439,7 +25438,7 @@ void Player::SetViewpoint(WorldObject* target, bool apply)
         TC_LOG_DEBUG("maps", "Player::CreateViewpoint: Player '%s' (%s) creates seer (Entry: %u, TypeId: %u).",
             GetName().c_str(), GetGUID().ToString().c_str(), target->GetEntry(), target->GetTypeId());
 
-        if (!AddGuidValue(PLAYER_FARSIGHT, target->GetGUID()))
+        if (!AddGuidValue(ACTIVE_PLAYER_FIELD_FARSIGHT, target->GetGUID()))
         {
             TC_LOG_FATAL("entities.player", "Player::CreateViewpoint: Player '%s' (%s) cannot add new viewpoint!", GetName().c_str(), GetGUID().ToString().c_str());
             return;
@@ -25456,7 +25455,7 @@ void Player::SetViewpoint(WorldObject* target, bool apply)
     {
         TC_LOG_DEBUG("maps", "Player::CreateViewpoint: Player %s removed seer", GetName().c_str());
 
-        if (!RemoveGuidValue(PLAYER_FARSIGHT, target->GetGUID()))
+        if (!RemoveGuidValue(ACTIVE_PLAYER_FIELD_FARSIGHT, target->GetGUID()))
         {
             TC_LOG_FATAL("entities.player", "Player::CreateViewpoint: Player '%s' (%s) cannot remove current viewpoint!", GetName().c_str(), GetGUID().ToString().c_str());
             return;
@@ -25475,7 +25474,7 @@ void Player::SetViewpoint(WorldObject* target, bool apply)
 
 WorldObject* Player::GetViewpoint() const
 {
-    ObjectGuid guid = GetGuidValue(PLAYER_FARSIGHT);
+    ObjectGuid guid = GetGuidValue(ACTIVE_PLAYER_FIELD_FARSIGHT);
     if (!guid.IsEmpty())
         return static_cast<WorldObject*>(ObjectAccessor::GetObjectByTypeMask(*this, guid, TYPEMASK_SEER));
     return nullptr;
@@ -25577,7 +25576,7 @@ bool Player::HasTitle(uint32 bitIndex) const
 
     uint32 fieldIndexOffset = bitIndex / 32;
     uint32 flag = 1 << (bitIndex % 32);
-    return HasFlag(PLAYER__FIELD_KNOWN_TITLES + fieldIndexOffset, flag);
+    return HasFlag(ACTIVE_PLAYER_FIELD_KNOWN_TITLES + fieldIndexOffset, flag);
 }
 
 bool Player::HasTitle(CharTitlesEntry const* title) const
@@ -25592,17 +25591,17 @@ void Player::SetTitle(CharTitlesEntry const* title, bool lost)
 
     if (lost)
     {
-        if (!HasFlag(PLAYER__FIELD_KNOWN_TITLES + fieldIndexOffset, flag))
+        if (!HasFlag(ACTIVE_PLAYER_FIELD_KNOWN_TITLES + fieldIndexOffset, flag))
             return;
 
-        RemoveFlag(PLAYER__FIELD_KNOWN_TITLES + fieldIndexOffset, flag);
+        RemoveFlag(ACTIVE_PLAYER_FIELD_KNOWN_TITLES + fieldIndexOffset, flag);
     }
     else
     {
-        if (HasFlag(PLAYER__FIELD_KNOWN_TITLES + fieldIndexOffset, flag))
+        if (HasFlag(ACTIVE_PLAYER_FIELD_KNOWN_TITLES + fieldIndexOffset, flag))
             return;
 
-        SetFlag(PLAYER__FIELD_KNOWN_TITLES + fieldIndexOffset, flag);
+        SetFlag(ACTIVE_PLAYER_FIELD_KNOWN_TITLES + fieldIndexOffset, flag);
     }
 
     WorldPackets::Character::TitleEarned packet(lost ? SMSG_TITLE_LOST : SMSG_TITLE_EARNED);
@@ -25834,7 +25833,6 @@ void Player::_LoadSkills(PreparedQueryResult result)
     // SetPQuery(PLAYER_LOGIN_QUERY_LOADSKILLS,          "SELECT skill, value, max FROM character_skills WHERE guid = '%u'", GUID_LOPART(m_guid));
 
     uint32 count = 0;
-    uint8 professionCount = 0;
     std::unordered_map<uint32, uint32> loadedSkillValues;
     if (result)
     {
@@ -25888,7 +25886,7 @@ void Player::_LoadSkills(PreparedQueryResult result)
             uint16 field = count / 2;
             uint8 offset = count & 1;
 
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_ID_OFFSET + field, offset, skill);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_ID_OFFSET + field, offset, skill);
             uint16 step = 0;
 
             SkillLineEntry const* skillLine = sSkillLineStore.LookupEntry(rcEntry->SkillID);
@@ -25901,16 +25899,20 @@ void Player::_LoadSkills(PreparedQueryResult result)
                 {
                     step = max / 75;
 
-                    if (professionCount < 2)
-                        SetUInt32Value(PLAYER_PROFESSION_SKILL_LINE_1 + professionCount++, skill);
+                    if (skillLine->ParentSkillLineID && skillLine->ParentTierIndex)
+                    {
+                        int32 professionSlot = FindProfessionSlotFor(skill);
+                        if (professionSlot != -1)
+                            SetUInt32Value(ACTIVE_PLAYER_FIELD_PROFESSION_SKILL_LINE + professionSlot, skill);
+                    }
                 }
             }
 
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, step);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, value);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, max);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset, 0);
-            SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset, 0);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, step);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, value);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, max);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset, 0);
+            SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset, 0);
 
             mSkillStatus.insert(SkillStatusMap::value_type(skill, SkillStatusData(count, SKILL_UNCHANGED)));
             loadedSkillValues[skill] = value;
@@ -25939,12 +25941,12 @@ void Player::_LoadSkills(PreparedQueryResult result)
         uint16 field = count / 2;
         uint8 offset = count & 1;
 
-        SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_ID_OFFSET + field, offset, 0);
-        SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, 0);
-        SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, 0);
-        SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, 0);
-        SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset, 0);
-        SetUInt16Value(PLAYER_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset, 0);
+        SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_ID_OFFSET + field, offset, 0);
+        SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_STEP_OFFSET + field, offset, 0);
+        SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_RANK_OFFSET + field, offset, 0);
+        SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_MAX_RANK_OFFSET + field, offset, 0);
+        SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_TEMP_BONUS_OFFSET + field, offset, 0);
+        SetUInt16Value(ACTIVE_PLAYER_FIELD_SKILL_LINEID + SKILL_PERM_BONUS_OFFSET + field, offset, 0);
     }
 }
 
@@ -26151,7 +26153,7 @@ TalentLearnResult Player::LearnTalent(uint32 talentId, int32* spellOnCooldown)
         return TALENT_FAILED_UNKNOWN;
 
     // check if we have enough talent points
-    if (talentInfo->TierID >= GetUInt32Value(PLAYER_FIELD_MAX_TALENT_TIERS))
+    if (talentInfo->TierID >= GetUInt32Value(ACTIVE_PLAYER_FIELD_MAX_TALENT_TIERS))
         return TALENT_FAILED_UNKNOWN;
 
     // TODO: prevent changing talents that are on cooldown
@@ -26243,62 +26245,59 @@ void Player::ResetTalentSpecialization()
     UpdateItemSetAuras(false);
 }
 
-TalentLearnResult Player::LearnPvpTalent(uint32 talentID, int32* spellOnCooldown)
+TalentLearnResult Player::LearnPvpTalent(uint32 talentID, uint8 slot, int32* spellOnCooldown)
 {
+    if (slot >= MAX_PVP_TALENT_SLOTS)
+        return TALENT_FAILED_UNKNOWN;
+
     if (IsInCombat())
         return TALENT_FAILED_AFFECTING_COMBAT;
 
-    if (getLevel() < PLAYER_LEVEL_MIN_HONOR)
-        return TALENT_FAILED_UNKNOWN;
+    if (isDead())
+        return TALENT_FAILED_CANT_DO_THAT_RIGHT_NOW;
 
     PvpTalentEntry const* talentInfo = sPvpTalentStore.LookupEntry(talentID);
     if (!talentInfo)
         return TALENT_FAILED_UNKNOWN;
 
-    if (talentInfo->SpecID)
-    {
-        if (talentInfo->SpecID != GetInt32Value(PLAYER_FIELD_CURRENT_SPEC_ID))
-            return TALENT_FAILED_UNKNOWN;
-    }
-    else if (talentInfo->Role >= 0)
-    {
-        if (talentInfo->Role != sChrSpecializationStore.AssertEntry(GetUInt32Value(PLAYER_FIELD_CURRENT_SPEC_ID))->Role)
-            return TALENT_FAILED_UNKNOWN;
-    }
+    if (talentInfo->SpecID != GetInt32Value(PLAYER_FIELD_CURRENT_SPEC_ID))
+        return TALENT_FAILED_UNKNOWN;
 
-    // prevent learn talent for different class (cheating)
-    if (talentInfo->ClassID && talentInfo->ClassID != getClass())
+    if (talentInfo->LevelRequired > getLevel())
+        return TALENT_FAILED_UNKNOWN;
+
+    if (sDB2Manager.GetRequiredLevelForPvpTalentSlot(slot, Classes(getClass())) > getLevel())
         return TALENT_FAILED_UNKNOWN;
 
-    if (!GetPrestigeLevel())
-        if (sDB2Manager.GetRequiredHonorLevelForPvpTalent(talentInfo) > GetHonorLevel())
+    if (PvpTalentCategoryEntry const* talentCategory = sPvpTalentCategoryStore.LookupEntry(talentInfo->PvpTalentCategoryID))
+        if (!(talentCategory->TalentSlotMask & (1 << slot)))
             return TALENT_FAILED_UNKNOWN;
 
-    // Check if player doesn't have any talent in current tier
-    for (uint32 c = 0; c < MAX_PVP_TALENT_COLUMNS; ++c)
-    {
-        for (PvpTalentEntry const* talent : sDB2Manager.GetPvpTalentsByPosition(getClass(), talentInfo->TierID, c))
-        {
-            if (HasPvpTalent(talent->ID, GetActiveTalentGroup()) && !HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_RESTING) && HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC))
-                return TALENT_FAILED_REST_AREA;
+    // Check if player doesn't have this talent in other slot
+    if (HasPvpTalent(talentID, GetActiveTalentGroup()))
+        return TALENT_FAILED_UNKNOWN;
 
-            if (GetSpellHistory()->HasCooldown(talent->SpellID))
-            {
-                *spellOnCooldown = talent->SpellID;
-                return TALENT_FAILED_CANT_REMOVE_TALENT;
-            }
+    if (PvpTalentEntry const* talent = sPvpTalentStore.LookupEntry(GetPvpTalentMap(GetActiveTalentGroup())[slot]))
+    {
+        if (!HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_RESTING) && !HasFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_ALLOW_CHANGING_TALENTS))
+            return TALENT_FAILED_REST_AREA;
 
-            RemovePvpTalent(talent);
+        if (GetSpellHistory()->HasCooldown(talent->SpellID))
+        {
+            *spellOnCooldown = talent->SpellID;
+            return TALENT_FAILED_CANT_REMOVE_TALENT;
         }
+
+        RemovePvpTalent(talent);
     }
 
-    if (!AddPvpTalent(talentInfo, GetActiveTalentGroup(), true))
+    if (!AddPvpTalent(talentInfo, GetActiveTalentGroup(), slot))
         return TALENT_FAILED_UNKNOWN;
 
     return TALENT_LEARN_OK;
 }
 
-bool Player::AddPvpTalent(PvpTalentEntry const* talent, uint8 activeTalentGroup, bool learning)
+bool Player::AddPvpTalent(PvpTalentEntry const* talent, uint8 activeTalentGroup, uint8 slot)
 {
     ASSERT(talent);
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(talent->SpellID);
@@ -26321,11 +26320,7 @@ bool Player::AddPvpTalent(PvpTalentEntry const* talent, uint8 activeTalentGroup,
     if (talent->OverridesSpellID)
         AddOverrideSpell(talent->OverridesSpellID, talent->SpellID);
 
-    PlayerTalentMap::iterator itr = GetPvpTalentMap(activeTalentGroup)->find(talent->ID);
-    if (itr != GetPvpTalentMap(activeTalentGroup)->end())
-        itr->second = PLAYERSPELL_UNCHANGED;
-    else
-        (*GetPvpTalentMap(activeTalentGroup))[talent->ID] = learning ? PLAYERSPELL_NEW : PLAYERSPELL_UNCHANGED;
+    GetPvpTalentMap(activeTalentGroup)[slot] = talent->ID;
 
     return true;
 }
@@ -26343,28 +26338,29 @@ void Player::RemovePvpTalent(PvpTalentEntry const* talent)
         RemoveOverrideSpell(talent->OverridesSpellID, talent->SpellID);
 
     // if this talent rank can be found in the PlayerTalentMap, mark the talent as removed so it gets deleted
-    PlayerTalentMap::iterator plrPvpTalent = GetPvpTalentMap(GetActiveTalentGroup())->find(talent->ID);
-    if (plrPvpTalent != GetPvpTalentMap(GetActiveTalentGroup())->end())
-        plrPvpTalent->second = PLAYERSPELL_REMOVED;
+    auto plrPvpTalent = std::find(GetPvpTalentMap(GetActiveTalentGroup()).begin(), GetPvpTalentMap(GetActiveTalentGroup()).end(), talent->ID);
+    if (plrPvpTalent != GetPvpTalentMap(GetActiveTalentGroup()).end())
+        *plrPvpTalent = 0;
 }
 
 void Player::TogglePvpTalents(bool enable)
 {
-    PlayerTalentMap const* pvpTalents = GetPvpTalentMap(GetActiveTalentGroup());
-    for (PlayerTalentMap::value_type const& v : *pvpTalents)
+    PlayerPvpTalentMap const& pvpTalents = GetPvpTalentMap(GetActiveTalentGroup());
+    for (uint32 pvpTalentId : pvpTalents)
     {
-        PvpTalentEntry const* pvpTalentInfo = sPvpTalentStore.AssertEntry(v.first);
-        if (enable && v.second != PLAYERSPELL_REMOVED)
-            LearnSpell(pvpTalentInfo->SpellID, false);
-        else
-            RemoveSpell(pvpTalentInfo->SpellID, true);
+        if (PvpTalentEntry const* pvpTalentInfo = sPvpTalentStore.LookupEntry(pvpTalentId))
+        {
+            if (enable)
+                LearnSpell(pvpTalentInfo->SpellID, false);
+            else
+                RemoveSpell(pvpTalentInfo->SpellID, true);
+        }
     }
 }
 
 bool Player::HasPvpTalent(uint32 talentID, uint8 activeTalentGroup) const
 {
-    PlayerTalentMap::const_iterator itr = GetPvpTalentMap(activeTalentGroup)->find(talentID);
-    return (itr != GetPvpTalentMap(activeTalentGroup)->end() && itr->second != PLAYERSPELL_REMOVED);
+    return std::find(GetPvpTalentMap(activeTalentGroup).begin(), GetPvpTalentMap(activeTalentGroup).end(), talentID) != GetPvpTalentMap(activeTalentGroup).end();
 }
 
 void Player::EnablePvpRules(bool dueToCombat /*= false*/)
@@ -26522,12 +26518,11 @@ void Player::SendTalentsInfoData()
             continue;
 
         PlayerTalentMap* talents = GetTalentMap(i);
-        PlayerTalentMap* pvpTalents = GetPvpTalentMap(i);
+        PlayerPvpTalentMap const& pvpTalents = GetPvpTalentMap(i);
 
         WorldPackets::Talent::TalentGroupInfo groupInfoPkt;
         groupInfoPkt.SpecID = spec->ID;
         groupInfoPkt.TalentIDs.reserve(talents->size());
-        groupInfoPkt.PvPTalentIDs.reserve(pvpTalents->size());
 
         for (PlayerTalentMap::const_iterator itr = talents->begin(); itr != talents->end(); ++itr)
         {
@@ -26542,9 +26537,6 @@ void Player::SendTalentsInfoData()
                 continue;
             }
 
-            if (talentInfo->ClassID != getClass())
-                continue;
-
             SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(talentInfo->SpellID);
             if (!spellEntry)
             {
@@ -26556,22 +26548,19 @@ void Player::SendTalentsInfoData()
             groupInfoPkt.TalentIDs.push_back(uint16(itr->first));
         }
 
-        for (PlayerTalentMap::const_iterator itr = pvpTalents->begin(); itr != pvpTalents->end(); ++itr)
+        for (std::size_t slot = 0; slot < MAX_PVP_TALENT_SLOTS; ++slot)
         {
-            if (itr->second == PLAYERSPELL_REMOVED)
+            if (!pvpTalents[slot])
                 continue;
 
-            PvpTalentEntry const* talentInfo = sPvpTalentStore.LookupEntry(itr->first);
+            PvpTalentEntry const* talentInfo = sPvpTalentStore.LookupEntry(pvpTalents[slot]);
             if (!talentInfo)
             {
                 TC_LOG_ERROR("entities.player", "Player::SendTalentsInfoData: Player '%s' (%s) has unknown pvp talent id: %u",
-                    GetName().c_str(), GetGUID().ToString().c_str(), itr->first);
+                    GetName().c_str(), GetGUID().ToString().c_str(), pvpTalents[slot]);
                 continue;
             }
 
-            if (talentInfo->ClassID && talentInfo->ClassID != getClass())
-                continue;
-
             SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(talentInfo->SpellID);
             if (!spellEntry)
             {
@@ -26580,7 +26569,10 @@ void Player::SendTalentsInfoData()
                 continue;
             }
 
-            groupInfoPkt.PvPTalentIDs.push_back(uint16(itr->first));
+            groupInfoPkt.PvPTalents.emplace_back();
+            WorldPackets::Talent::PvPTalent& pvpTalent = groupInfoPkt.PvPTalents.back();
+            pvpTalent.PvPTalentID = pvpTalents[slot];
+            pvpTalent.Slot = slot;
         }
 
         packet.Info.TalentGroups.push_back(groupInfoPkt);
@@ -26859,12 +26851,13 @@ void Player::_LoadTalents(PreparedQueryResult result)
 
 void Player::_LoadPvpTalents(PreparedQueryResult result)
 {
-    // "SELECT TalentID, TalentGroup FROM character_pvp_talent WHERE guid = ?"
+    // "SELECT talentID0, talentID1, talentID2, talentID3, talentGroup FROM character_pvp_talent WHERE guid = ?"
     if (result)
     {
         do
-            if (PvpTalentEntry const* talent = sPvpTalentStore.LookupEntry((*result)[0].GetUInt32()))
-                AddPvpTalent(talent, (*result)[1].GetUInt8(), false);
+            for (uint8 slot = 0; slot < MAX_PVP_TALENT_SLOTS; ++slot)
+                if (PvpTalentEntry const* talent = sPvpTalentStore.LookupEntry((*result)[slot].GetUInt32()))
+                    AddPvpTalent(talent, (*result)[4].GetUInt8(), slot);
         while (result->NextRow());
     }
 }
@@ -26875,11 +26868,10 @@ void Player::_SaveTalents(SQLTransaction& trans)
     stmt->setUInt64(0, GetGUID().GetCounter());
     trans->Append(stmt);
 
-    PlayerTalentMap* talents;
     for (uint8 group = 0; group < MAX_SPECIALIZATIONS; ++group)
     {
-        talents = GetTalentMap(group);
-        for (PlayerTalentMap::iterator itr = talents->begin(); itr != talents->end();)
+        PlayerTalentMap* talents = GetTalentMap(group);
+        for (auto itr = talents->begin(); itr != talents->end();)
         {
             if (itr->second == PLAYERSPELL_REMOVED)
             {
@@ -26902,22 +26894,15 @@ void Player::_SaveTalents(SQLTransaction& trans)
 
     for (uint8 group = 0; group < MAX_SPECIALIZATIONS; ++group)
     {
-        talents = GetPvpTalentMap(group);
-        for (PlayerTalentMap::iterator itr = talents->begin(); itr != talents->end();)
-        {
-            if (itr->second == PLAYERSPELL_REMOVED)
-            {
-                itr = talents->erase(itr);
-                continue;
-            }
-
-            stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_PVP_TALENT);
-            stmt->setUInt64(0, GetGUID().GetCounter());
-            stmt->setUInt32(1, itr->first);
-            stmt->setUInt8(2, group);
-            trans->Append(stmt);
-            ++itr;
-        }
+        PlayerPvpTalentMap const& talents = GetPvpTalentMap(group);
+        stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_PVP_TALENT);
+        stmt->setUInt64(0, GetGUID().GetCounter());
+        stmt->setUInt32(1, talents[0]);
+        stmt->setUInt32(2, talents[1]);
+        stmt->setUInt32(3, talents[2]);
+        stmt->setUInt32(4, talents[3]);
+        stmt->setUInt8(5, group);
+        trans->Append(stmt);
     }
 }
 
@@ -27001,15 +26986,6 @@ void Player::ActivateTalentGroup(ChrSpecializationEntry const* spec)
         if (!talentInfo)
             continue;
 
-        // unlearn only talents for character class
-        // some spell learned by one class as normal spells or know at creation but another class learn it as talent,
-        // to prevent unexpected lost normal learned spell skip another class talents
-        if (talentInfo->ClassID && talentInfo->ClassID != getClass())
-            continue;
-
-        if (talentInfo->SpellID == 0)
-            continue;
-
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(talentInfo->SpellID);
         if (!spellInfo)
             continue;
@@ -27058,21 +27034,16 @@ void Player::ActivateTalentGroup(ChrSpecializationEntry const* spec)
         }
     }
 
-    for (uint32 pvpTalentID = 0; pvpTalentID < sTalentStore.GetNumRows(); ++pvpTalentID)
+    for (uint8 slot = 0; slot < MAX_PVP_TALENT_SLOTS; ++slot)
     {
-        PvpTalentEntry const* talentInfo = sPvpTalentStore.LookupEntry(pvpTalentID);
+        PvpTalentEntry const* talentInfo = sPvpTalentStore.LookupEntry(GetPvpTalentMap(GetActiveTalentGroup())[slot]);
         if (!talentInfo)
             continue;
 
-        // learn only talents for character class (or x-class talents)
-        if (talentInfo->ClassID && talentInfo->ClassID != getClass())
-            continue;
-
         if (!talentInfo->SpellID)
             continue;
 
-        if (HasPvpTalent(talentInfo->ID, GetActiveTalentGroup()))
-            AddPvpTalent(talentInfo, GetActiveTalentGroup(), true);
+        AddPvpTalent(talentInfo, GetActiveTalentGroup(), slot);
     }
 
     LearnSpecializationSpells();
@@ -27622,6 +27593,7 @@ void Player::SendPlayerChoice(ObjectGuid sender, int32 choiceId)
     displayPlayerChoice.Responses.resize(playerChoice->Responses.size());
     displayPlayerChoice.CloseChoiceFrame = false;
     displayPlayerChoice.HideWarboardHeader = playerChoice->HideWarboardHeader;
+    displayPlayerChoice.KeepOpenAfterChoice = playerChoice->KeepOpenAfterChoice;
 
     for (std::size_t i = 0; i < playerChoice->Responses.size(); ++i)
     {
@@ -27629,6 +27601,9 @@ void Player::SendPlayerChoice(ObjectGuid sender, int32 choiceId)
         WorldPackets::Quest::PlayerChoiceResponse& playerChoiceResponse = displayPlayerChoice.Responses[i];
         playerChoiceResponse.ResponseID = playerChoiceResponseTemplate.ResponseId;
         playerChoiceResponse.ChoiceArtFileID = playerChoiceResponseTemplate.ChoiceArtFileId;
+        playerChoiceResponse.Flags = playerChoiceResponseTemplate.Flags;
+        playerChoiceResponse.WidgetSetID = playerChoiceResponseTemplate.WidgetSetID;
+        playerChoiceResponse.GroupID = playerChoiceResponseTemplate.GroupID;
         playerChoiceResponse.Answer = playerChoiceResponseTemplate.Answer;
         playerChoiceResponse.Header = playerChoiceResponseTemplate.Header;
         playerChoiceResponse.Description = playerChoiceResponseTemplate.Description;
@@ -27953,29 +27928,6 @@ void Player::SendSupercededSpell(uint32 oldSpell, uint32 newSpell) const
     GetSession()->SendPacket(supercededSpells.Write());
 }
 
-uint32 Player::CalculateTalentsTiers() const
-{
-    uint32 const* rowLevels;
-    switch (getClass())
-    {
-        case CLASS_DEATH_KNIGHT:
-            rowLevels = DKTalentRowLevels;
-            break;
-        case CLASS_DEMON_HUNTER:
-            rowLevels = DHTalentRowLevels;
-            break;
-        default:
-            rowLevels = DefaultTalentRowLevels;
-            break;
-    }
-
-    for (uint32 i = MAX_TALENT_TIERS; i; --i)
-        if (getLevel() >= rowLevels[i - 1])
-            return i;
-
-    return 0;
-}
-
 Difficulty Player::GetDifficultyID(MapEntry const* mapEntry) const
 {
     if (!mapEntry->IsRaid())
diff --git a/src/server/game/Entities/Player/Player.h b/src/server/game/Entities/Player/Player.h
index eb12abc021c..391fbb34be3 100644
--- a/src/server/game/Entities/Player/Player.h
+++ b/src/server/game/Entities/Player/Player.h
@@ -101,16 +101,23 @@ namespace WorldPackets
 
 typedef std::deque<Mail*> PlayerMails;
 
-#define PLAYER_MAX_SKILLS                       128
-enum SkillFieldOffset
+#define PLAYER_MAX_SKILLS                       256
+
+template<typename SkillArrayType>
+constexpr std::size_t CalculateSkillFieldArraySize()
 {
-    SKILL_ID_OFFSET = 0,
-    SKILL_STEP_OFFSET = 64,
-    SKILL_RANK_OFFSET = SKILL_STEP_OFFSET + 64,
-    SUBSKILL_START_RANK_OFFSET = SKILL_RANK_OFFSET + 64,
-    SKILL_MAX_RANK_OFFSET = SUBSKILL_START_RANK_OFFSET + 64,
-    SKILL_TEMP_BONUS_OFFSET = SKILL_MAX_RANK_OFFSET + 64,
-    SKILL_PERM_BONUS_OFFSET = SKILL_TEMP_BONUS_OFFSET + 64
+    return PLAYER_MAX_SKILLS / sizeof(uint32) * sizeof(SkillArrayType);
+}
+
+enum SkillFieldOffset : uint16
+{
+    SKILL_ID_OFFSET            = 0,
+    SKILL_STEP_OFFSET          = SKILL_ID_OFFSET + CalculateSkillFieldArraySize<uint16>(),
+    SKILL_RANK_OFFSET          = SKILL_STEP_OFFSET + CalculateSkillFieldArraySize<uint16>(),
+    SUBSKILL_START_RANK_OFFSET = SKILL_RANK_OFFSET + CalculateSkillFieldArraySize<uint16>(),
+    SKILL_MAX_RANK_OFFSET      = SUBSKILL_START_RANK_OFFSET + CalculateSkillFieldArraySize<uint16>(),
+    SKILL_TEMP_BONUS_OFFSET    = SKILL_MAX_RANK_OFFSET + CalculateSkillFieldArraySize<uint16>(),
+    SKILL_PERM_BONUS_OFFSET    = SKILL_TEMP_BONUS_OFFSET + CalculateSkillFieldArraySize<uint16>()
 };
 
 #define PLAYER_EXPLORED_ZONES_SIZE  320
@@ -240,6 +247,7 @@ struct PlayerCurrency
 };
 
 typedef std::unordered_map<uint32, PlayerSpellState> PlayerTalentMap;
+typedef std::array<uint32, MAX_PVP_TALENT_SLOTS> PlayerPvpTalentMap;
 typedef std::unordered_map<uint32, PlayerSpell*> PlayerSpellMap;
 typedef std::unordered_set<SpellModifier*> SpellModContainer;
 typedef std::unordered_map<uint32, PlayerCurrency> PlayerCurrenciesMap;
@@ -391,7 +399,7 @@ enum PlayerFlags
     PLAYER_FLAGS_GM                     = 0x00000008,
     PLAYER_FLAGS_GHOST                  = 0x00000010,
     PLAYER_FLAGS_RESTING                = 0x00000020,
-    PLAYER_FLAGS_UNK6                   = 0x00000040,
+    PLAYER_FLAGS_VOICE_CHAT             = 0x00000040,
     PLAYER_FLAGS_UNK7                   = 0x00000080,       // pre-3.0.3 PLAYER_FLAGS_FFA_PVP flag for FFA PVP state
     PLAYER_FLAGS_CONTESTED_PVP          = 0x00000100,       // Player has been involved in a PvP combat and will be attacked by contested guards
     PLAYER_FLAGS_IN_PVP                 = 0x00000200,
@@ -422,7 +430,8 @@ enum PlayerFlags
 enum PlayerFlagsEx
 {
     PLAYER_FLAGS_EX_REAGENT_BANK_UNLOCKED   = 0x0001,
-    PLAYER_FLAGS_EX_MERCENARY_MODE          = 0x0002
+    PLAYER_FLAGS_EX_MERCENARY_MODE          = 0x0002,
+    PLAYER_FLAGS_EX_ARTIFACT_FORGE_CHEAT    = 0x0004
 };
 
 enum PlayerLocalFlags
@@ -1001,10 +1010,6 @@ enum TalentLearnResult
     TALENT_FAILED_REST_AREA                             = 8
 };
 
-static uint32 const DefaultTalentRowLevels[MAX_TALENT_TIERS] = { 15, 30, 45, 60, 75, 90, 100 };
-static uint32 const DKTalentRowLevels[MAX_TALENT_TIERS] = { 57, 58, 59, 60, 75, 90, 100 };
-static uint32 const DHTalentRowLevels[MAX_TALENT_TIERS] = { 99, 100, 102, 104, 106, 108, 110 };
-
 struct TC_GAME_API SpecializationInfo
 {
     SpecializationInfo() : ResetTalentsCost(0), ResetTalentsTime(0), PrimarySpecialization(0), ActiveGroup(0)
@@ -1012,7 +1017,7 @@ struct TC_GAME_API SpecializationInfo
     }
 
     PlayerTalentMap Talents[MAX_SPECIALIZATIONS];
-    PlayerTalentMap PvpTalents[MAX_SPECIALIZATIONS];
+    PlayerPvpTalentMap PvpTalents[MAX_SPECIALIZATIONS];
     std::vector<uint32> Glyphs[MAX_SPECIALIZATIONS];
     uint32 ResetTalentsCost;
     time_t ResetTalentsTime;
@@ -1033,7 +1038,7 @@ struct PlayerDynamicFieldSpellModByLabel
 };
 #pragma pack(pop)
 
-uint8 constexpr PLAYER_MAX_HONOR_LEVEL = 50;
+uint32 constexpr PLAYER_MAX_HONOR_LEVEL = 500;
 uint8 constexpr PLAYER_LEVEL_MIN_HONOR = 110;
 uint32 constexpr SPELL_PVP_RULES_ENABLED = 134735;
 
@@ -1188,7 +1193,7 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         static bool IsChildEquipmentPos(uint8 bag, uint8 slot);
         bool IsValidPos(uint16 pos, bool explicit_pos) const { return IsValidPos(pos >> 8, pos & 255, explicit_pos); }
         bool IsValidPos(uint8 bag, uint8 slot, bool explicit_pos) const;
-        uint8 GetInventorySlotCount() const { return GetByteValue(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_NUM_BACKPACK_SLOTS); }
+        uint8 GetInventorySlotCount() const { return GetByteValue(ACTIVE_PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_NUM_BACKPACK_SLOTS); }
         void SetInventorySlotCount(uint8 slots);
         uint8 GetBankBagSlotCount() const { return GetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_BANK_BAG_SLOTS); }
         void SetBankBagSlotCount(uint8 count) { SetByteValue(PLAYER_BYTES_3, PLAYER_BYTES_3_OFFSET_BANK_BAG_SLOTS, count); }
@@ -1349,13 +1354,8 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         /***                    QUEST SYSTEM                   ***/
         /*********************************************************/
 
-        int32 GetQuestLevel(Quest const* quest) const
-        {
-            if (!quest)
-                return getLevel();
-            return quest->GetQuestLevel() > 0 ? quest->GetQuestLevel() : std::min<int32>(getLevel(), quest->GetQuestMaxScalingLevel());
-        }
-
+        int32 GetQuestMinLevel(Quest const* quest) const;
+        int32 GetQuestLevel(Quest const* quest) const;
         void PrepareQuestMenu(ObjectGuid guid);
         void SendPreparedQuest(WorldObject* source);
         bool IsActiveQuest(uint32 quest_id) const;
@@ -1501,7 +1501,7 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
 
         static bool IsValidGender(uint8 Gender) { return Gender <= GENDER_FEMALE; }
         static bool IsValidClass(uint8 Class) { return ((1 << (Class - 1)) & CLASSMASK_ALL_PLAYABLE) != 0; }
-        static bool IsValidRace(uint8 Race) { return ((1 << (Race - 1)) & RACEMASK_ALL_PLAYABLE) != 0; }
+        static bool IsValidRace(uint8 Race) { return ((UI64LIT(1) << (Race - 1)) & RACEMASK_ALL_PLAYABLE) != 0; }
         static bool ValidateAppearance(uint8 race, uint8 class_, uint8 gender, uint8 hairID, uint8 hairColor, uint8 faceID, uint8 facialHair, uint8 skinColor, std::array<uint8, PLAYER_CUSTOM_DISPLAY_SIZE> const& customDisplay, bool create = false);
 
         /*********************************************************/
@@ -1530,7 +1530,7 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         void setRegenTimerCount(uint32 time) {m_regenTimerCount = time;}
         void setWeaponChangeTimer(uint32 time) {m_weaponChangeTimer = time;}
 
-        uint64 GetMoney() const { return GetUInt64Value(PLAYER_FIELD_COINAGE); }
+        uint64 GetMoney() const { return GetUInt64Value(ACTIVE_PLAYER_FIELD_COINAGE); }
         bool ModifyMoney(int64 amount, bool sendError = true);
         bool HasEnoughMoney(uint64 amount) const { return (GetMoney() >= amount); }
         bool HasEnoughMoney(int64 amount) const;
@@ -1622,8 +1622,8 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         std::string GetGuildName() const;
 
         // Loot Spec
-        void SetLootSpecId(uint32 id) { SetUInt32Value(PLAYER_FIELD_LOOT_SPEC_ID, id); }
-        uint32 GetLootSpecId() const { return GetUInt32Value(PLAYER_FIELD_LOOT_SPEC_ID); }
+        void SetLootSpecId(uint32 id) { SetUInt32Value(ACTIVE_PLAYER_FIELD_LOOT_SPEC_ID, id); }
+        uint32 GetLootSpecId() const { return GetUInt32Value(ACTIVE_PLAYER_FIELD_LOOT_SPEC_ID); }
 
         // Talents
         uint32 GetTalentResetCost() const { return _specializationInfo.ResetTalentsCost; }
@@ -1645,11 +1645,10 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         bool AddTalent(TalentEntry const* talent, uint8 spec, bool learning);
         bool HasTalent(uint32 spell_id, uint8 spec) const;
         void RemoveTalent(TalentEntry const* talent);
-        uint32 CalculateTalentsTiers() const;
         void ResetTalentSpecialization();
 
-        TalentLearnResult LearnPvpTalent(uint32 talentID, int32* spellOnCooldown);
-        bool AddPvpTalent(PvpTalentEntry const* talent, uint8 activeTalentGroup, bool learning);
+        TalentLearnResult LearnPvpTalent(uint32 talentID, uint8 slot, int32* spellOnCooldown);
+        bool AddPvpTalent(PvpTalentEntry const* talent, uint8 activeTalentGroup, uint8 slot);
         void RemovePvpTalent(PvpTalentEntry const* talent);
         void TogglePvpTalents(bool enable);
         bool HasPvpTalent(uint32 talentID, uint8 activeTalentGroup) const;
@@ -1664,14 +1663,14 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
 
         PlayerTalentMap const* GetTalentMap(uint8 spec) const { return &_specializationInfo.Talents[spec]; }
         PlayerTalentMap* GetTalentMap(uint8 spec) { return &_specializationInfo.Talents[spec]; }
-        PlayerTalentMap const* GetPvpTalentMap(uint8 spec) const { return &_specializationInfo.PvpTalents[spec]; }
-        PlayerTalentMap* GetPvpTalentMap(uint8 spec) { return &_specializationInfo.PvpTalents[spec]; }
+        PlayerPvpTalentMap const& GetPvpTalentMap(uint8 spec) const { return _specializationInfo.PvpTalents[spec]; }
+        PlayerPvpTalentMap& GetPvpTalentMap(uint8 spec) { return _specializationInfo.PvpTalents[spec]; }
         std::vector<uint32> const& GetGlyphs(uint8 spec) const { return _specializationInfo.Glyphs[spec]; }
         std::vector<uint32>& GetGlyphs(uint8 spec) { return _specializationInfo.Glyphs[spec]; }
         ActionButtonList const& GetActionButtons() const { return m_actionButtons; }
 
-        uint32 GetFreePrimaryProfessionPoints() const { return GetUInt32Value(PLAYER_CHARACTER_POINTS); }
-        void SetFreePrimaryProfessions(uint16 profs) { SetUInt32Value(PLAYER_CHARACTER_POINTS, profs); }
+        uint32 GetFreePrimaryProfessionPoints() const { return GetUInt32Value(ACTIVE_PLAYER_FIELD_CHARACTER_POINTS); }
+        void SetFreePrimaryProfessions(uint16 profs) { SetUInt32Value(ACTIVE_PLAYER_FIELD_CHARACTER_POINTS, profs); }
         void InitPrimaryProfessions();
 
         PlayerSpellMap const& GetSpellMap() const { return m_spells; }
@@ -1756,7 +1755,7 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         void SetGuildLevel(uint32 level) { SetUInt32Value(PLAYER_GUILDLEVEL, level); }
         uint32 GetGuildLevel() const { return GetUInt32Value(PLAYER_GUILDLEVEL); }
         void SetGuildIdInvited(ObjectGuid::LowType GuildId) { m_GuildIdInvited = GuildId; }
-        ObjectGuid::LowType GetGuildId() const { return GetUInt64Value(OBJECT_FIELD_DATA); /* return only lower part */ }
+        ObjectGuid::LowType GetGuildId() const { return GetUInt64Value(UNIT_FIELD_GUILD_GUID); /* return only lower part */ }
         Guild* GetGuild();
         Guild const* GetGuild() const;
         static ObjectGuid::LowType GetGuildIdFromDB(ObjectGuid guid);
@@ -1769,8 +1768,8 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         void SetArenaTeamInfoField(uint8 slot, ArenaTeamInfoType type, uint32 value);
         static uint32 GetArenaTeamIdFromDB(ObjectGuid guid, uint8 slot);
         static void LeaveAllArenaTeams(ObjectGuid guid);
-        uint32 GetArenaTeamId(uint8 slot) const { return GetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (slot * ARENA_TEAM_END) + ARENA_TEAM_ID); }
-        uint32 GetArenaPersonalRating(uint8 slot) const { return GetUInt32Value(PLAYER_FIELD_ARENA_TEAM_INFO_1_1 + (slot * ARENA_TEAM_END) + ARENA_TEAM_PERSONAL_RATING); }
+        uint32 GetArenaTeamId(uint8 slot) const { return GetUInt32Value(ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO + (slot * ARENA_TEAM_END) + ARENA_TEAM_ID); }
+        uint32 GetArenaPersonalRating(uint8 slot) const { return GetUInt32Value(ACTIVE_PLAYER_FIELD_ARENA_TEAM_INFO + (slot * ARENA_TEAM_END) + ARENA_TEAM_PERSONAL_RATING); }
         void SetArenaTeamIdInvited(uint32 ArenaTeamId) { m_ArenaTeamIdInvited = ArenaTeamId; }
         uint32 GetArenaTeamIdInvited() const { return m_ArenaTeamIdInvited; }
         uint32 GetRBGPersonalRating() const { return 0; }
@@ -1787,9 +1786,7 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         static Difficulty CheckLoadedLegacyRaidDifficultyID(Difficulty difficulty);
         void SendRaidGroupOnlyMessage(RaidGroupReason reason, int32 delay) const;
 
-        bool UpdateSkill(uint32 skill_id, uint32 step);
         bool UpdateSkillPro(uint16 skillId, int32 chance, uint32 step);
-
         bool UpdateCraftSkill(uint32 spellid);
         bool UpdateGatherSkill(uint32 SkillId, uint32 SkillValue, uint32 RedLevel, uint32 Multiplicator = 1);
         bool UpdateFishingSkill();
@@ -1929,6 +1926,7 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         uint16 GetSkillStep(uint16 skill) const;            // 0...6
         bool HasSkill(uint32 skill) const;
         void LearnSkillRewardedSpells(uint32 skillId, uint32 skillValue);
+        int32 FindProfessionSlotFor(uint32 skillId) const;
 
         WorldLocation& GetTeleportDest() { return m_teleport_dest; }
         bool IsBeingTeleported() const { return mSemaphoreTeleport_Near || mSemaphoreTeleport_Far; }
@@ -1985,15 +1983,11 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         void RestoreHealthAfterDuel() { SetHealth(healthBeforeDuel); }
         void RestoreManaAfterDuel() { SetPower(POWER_MANA, manaBeforeDuel); }
 
-        uint32 GetPrestigeLevel() const { return GetUInt32Value(PLAYER_FIELD_PRESTIGE); }
         uint32 GetHonorLevel() const { return GetUInt32Value(PLAYER_FIELD_HONOR_LEVEL); }
         void AddHonorXP(uint32 xp);
         void SetHonorLevel(uint8 honorLevel);
-        void Prestige();
-        bool CanPrestige() const;
-        bool IsMaxPrestige() const;
-        bool IsMaxHonorLevelAndPrestige() const { return IsMaxPrestige() && GetHonorLevel() == PLAYER_MAX_HONOR_LEVEL; }
-        // Updates PLAYER_FIELD_HONOR_NEXT_LEVEL based on PLAYER_FIELD_HONOR_LEVEL and the smallest value of PLAYER_FIELD_PRESTIGE and (PRESTIGE_COLUMN_COUNT - 1)
+        bool IsMaxHonorLevel() const { return GetHonorLevel() == PLAYER_MAX_HONOR_LEVEL; }
+        // Updates PLAYER_FIELD_HONOR_NEXT_LEVEL based on PLAYER_FIELD_HONOR_LEVEL
         void UpdateHonorNextLevel();
         //End of PvP System
 
@@ -2010,7 +2004,7 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
         int32 CalculateCorpseReclaimDelay(bool load = false) const;
         void SendCorpseReclaimDelay(uint32 delay) const;
 
-        uint32 GetBlockPercent() const override { return GetUInt32Value(PLAYER_SHIELD_BLOCK); }
+        uint32 GetBlockPercent() const override { return GetUInt32Value(ACTIVE_PLAYER_FIELD_SHIELD_BLOCK); }
         bool CanParry() const { return m_canParry; }
         void SetCanParry(bool value);
         bool CanBlock() const { return m_canBlock; }
@@ -2727,7 +2721,7 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
 
         std::unordered_map<ObjectGuid /*LootObject*/, ObjectGuid /*world object*/> m_AELootView;
 
-        void _InitHonorLevelOnLoadFromDB(uint32 /*honor*/, uint32 /*honorLevel*/, uint32 /*prestigeLevel*/);
+        void _InitHonorLevelOnLoadFromDB(uint32 honor, uint32 honorLevel);
         std::unique_ptr<RestMgr> _restMgr;
 
         bool _usePvpItemLevels;
diff --git a/src/server/game/Entities/Player/PlayerTaxi.cpp b/src/server/game/Entities/Player/PlayerTaxi.cpp
index 7a7f8d8533c..68d34e97c33 100644
--- a/src/server/game/Entities/Player/PlayerTaxi.cpp
+++ b/src/server/game/Entities/Player/PlayerTaxi.cpp
@@ -111,13 +111,13 @@ void PlayerTaxi::AppendTaximaskTo(WorldPackets::Taxi::ShowTaxiNodes& data, bool
 {
     if (all)
     {
-        data.CanLandNodes = &sTaxiNodesMask;              // all existed nodes
-        data.CanUseNodes = &sTaxiNodesMask;
+        data.CanLandNodes = sTaxiNodesMask;              // all existed nodes
+        data.CanUseNodes = sTaxiNodesMask;
     }
     else
     {
-        data.CanLandNodes = &m_taximask;                  // known nodes
-        data.CanUseNodes = &m_taximask;
+        data.CanLandNodes = m_taximask;                  // known nodes
+        data.CanUseNodes = m_taximask;
     }
 }
 
diff --git a/src/server/game/Entities/Player/PlayerTaxi.h b/src/server/game/Entities/Player/PlayerTaxi.h
index 7a98e01baa1..9da960883a6 100644
--- a/src/server/game/Entities/Player/PlayerTaxi.h
+++ b/src/server/game/Entities/Player/PlayerTaxi.h
@@ -44,13 +44,13 @@ class TC_GAME_API PlayerTaxi
 
         bool IsTaximaskNodeKnown(uint32 nodeidx) const
         {
-            uint8  field   = uint8((nodeidx - 1) / 8);
+            uint32 field   = uint32((nodeidx - 1) / 8);
             uint32 submask = 1 << ((nodeidx-1) % 8);
             return (m_taximask[field] & submask) == submask;
         }
         bool SetTaximaskNode(uint32 nodeidx)
         {
-            uint8  field   = uint8((nodeidx - 1) / 8);
+            uint32 field   = uint32((nodeidx - 1) / 8);
             uint32 submask = 1 << ((nodeidx-  1) % 8);
             if ((m_taximask[field] & submask) != submask)
             {
diff --git a/src/server/game/Entities/Player/RestMgr.cpp b/src/server/game/Entities/Player/RestMgr.cpp
index ba8c11c5ee0..fc100d36088 100644
--- a/src/server/game/Entities/Player/RestMgr.cpp
+++ b/src/server/game/Entities/Player/RestMgr.cpp
@@ -44,17 +44,17 @@ void RestMgr::SetRestBonus(RestTypes restType, float restBonus)
 
             rest_rested_offset = REST_RESTED_XP;
             rest_state_offset = REST_STATE_XP;
-            next_level_xp_field = PLAYER_NEXT_LEVEL_XP;
+            next_level_xp_field = ACTIVE_PLAYER_FIELD_NEXT_LEVEL_XP;
             affectedByRaF = true;
             break;
         case REST_TYPE_HONOR:
             // Reset restBonus (Honor only) for players with max honor level.
-            if (_player->IsMaxHonorLevelAndPrestige())
+            if (_player->IsMaxHonorLevel())
                 restBonus = 0;
 
             rest_rested_offset = REST_RESTED_HONOR;
             rest_state_offset = REST_STATE_HONOR;
-            next_level_xp_field = PLAYER_FIELD_HONOR_NEXT_LEVEL;
+            next_level_xp_field = ACTIVE_PLAYER_FIELD_HONOR_NEXT_LEVEL;
             break;
         default:
             return;
@@ -72,17 +72,17 @@ void RestMgr::SetRestBonus(RestTypes restType, float restBonus)
 
     // update data for client
     if (affectedByRaF && _player->GetsRecruitAFriendBonus(true) && (_player->GetSession()->IsARecruiter() || _player->GetSession()->GetRecruiterId() != 0))
-        _player->SetUInt32Value(PLAYER_FIELD_REST_INFO + rest_state_offset, REST_STATE_RAF_LINKED);
+        _player->SetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + rest_state_offset, REST_STATE_RAF_LINKED);
     else
     {
         if (_restBonus[restType] > 10)
-            _player->SetUInt32Value(PLAYER_FIELD_REST_INFO + rest_state_offset, REST_STATE_RESTED);
+            _player->SetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + rest_state_offset, REST_STATE_RESTED);
         else if (_restBonus[restType] <= 1)
-            _player->SetUInt32Value(PLAYER_FIELD_REST_INFO + rest_state_offset, REST_STATE_NOT_RAF_LINKED);
+            _player->SetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + rest_state_offset, REST_STATE_NOT_RAF_LINKED);
     }
 
     // RestTickUpdate
-    _player->SetUInt32Value(PLAYER_FIELD_REST_INFO + rest_rested_offset, uint32(_restBonus[restType]));
+    _player->SetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + rest_rested_offset, uint32(_restBonus[restType]));
 }
 
 void RestMgr::AddRestBonus(RestTypes restType, float restBonus)
@@ -153,8 +153,8 @@ void RestMgr::Update(time_t now)
 void RestMgr::LoadRestBonus(RestTypes restType, PlayerRestState state, float restBonus)
 {
     _restBonus[restType] = restBonus;
-    _player->SetUInt32Value(PLAYER_FIELD_REST_INFO + restType * 2, state);
-    _player->SetUInt32Value(PLAYER_FIELD_REST_INFO + restType * 2 + 1, uint32(restBonus));
+    _player->SetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + restType * 2, state);
+    _player->SetUInt32Value(ACTIVE_PLAYER_FIELD_REST_INFO + restType * 2 + 1, uint32(restBonus));
 }
 
 float RestMgr::CalcExtraPerSec(RestTypes restType, float bubble) const
@@ -162,9 +162,9 @@ float RestMgr::CalcExtraPerSec(RestTypes restType, float bubble) const
     switch (restType)
     {
         case REST_TYPE_HONOR:
-            return float(_player->GetUInt32Value(PLAYER_FIELD_HONOR_NEXT_LEVEL)) / 72000.0f * bubble;
+            return float(_player->GetUInt32Value(ACTIVE_PLAYER_FIELD_HONOR_NEXT_LEVEL)) / 72000.0f * bubble;
         case REST_TYPE_XP:
-            return float(_player->GetUInt32Value(PLAYER_NEXT_LEVEL_XP)) / 72000.0f * bubble;
+            return float(_player->GetUInt32Value(ACTIVE_PLAYER_FIELD_NEXT_LEVEL_XP)) / 72000.0f * bubble;
         default:
             return 0.0f;
     }
diff --git a/src/server/game/Entities/Taxi/TaxiPathGraph.cpp b/src/server/game/Entities/Taxi/TaxiPathGraph.cpp
index 3ec90f577a7..2614ad0520c 100644
--- a/src/server/game/Entities/Taxi/TaxiPathGraph.cpp
+++ b/src/server/game/Entities/Taxi/TaxiPathGraph.cpp
@@ -21,6 +21,7 @@
 #include "DB2Stores.h"
 #include "Config.h"
 #include "Util.h"
+#include <boost/graph/depth_first_search.hpp>
 #include <boost/graph/dijkstra_shortest_paths.hpp>
 #include <boost/property_map/transform_value_property_map.hpp>
 
@@ -32,7 +33,7 @@ TaxiPathGraph& TaxiPathGraph::Instance()
 
 void TaxiPathGraph::Initialize()
 {
-    if (GetVertexCount() > 0)
+    if (boost::num_vertices(m_graph) > 0)
         return;
 
     std::vector<std::pair<edge, EdgeCost>> edges;
@@ -47,7 +48,7 @@ void TaxiPathGraph::Initialize()
     }
 
     // create graph
-    m_graph = Graph(GetVertexCount());
+    m_graph = Graph(m_nodesByVertex.size());
     WeightMap weightmap = boost::get(boost::edge_weight, m_graph);
 
     for (std::size_t j = 0; j < edges.size(); ++j)
@@ -59,21 +60,22 @@ void TaxiPathGraph::Initialize()
 
 uint32 TaxiPathGraph::GetNodeIDFromVertexID(vertex_descriptor vertexID)
 {
-    if (vertexID < m_vertices.size())
-        return m_vertices[vertexID]->ID;
+    if (vertexID < m_nodesByVertex.size())
+        return m_nodesByVertex[vertexID]->ID;
 
     return std::numeric_limits<uint32>::max();
 }
 
 TaxiPathGraph::vertex_descriptor TaxiPathGraph::GetVertexIDFromNodeID(TaxiNodesEntry const* node)
 {
-    return node->CharacterBitNumber;
+    auto itr = m_verticesByNode.find(node->ID);
+    return itr != m_verticesByNode.end() ? itr->second : std::numeric_limits<vertex_descriptor>::max();
 }
 
-std::size_t TaxiPathGraph::GetVertexCount()
+void GetTaxiMapPosition(DBCPosition3D const& position, int32 mapId, DBCPosition2D* uiMapPosition, int32* uiMapId)
 {
-    //So we can use this function for readability, we define either max defined vertices or already loaded in graph count
-    return std::max(boost::num_vertices(m_graph), m_vertices.size());
+    if (!DB2Manager::GetUiMapPosition(position.X, position.Y, position.Z, mapId, 0, 0, 0, UI_MAP_SYSTEM_ADVENTURE, false, uiMapId, uiMapPosition))
+        DB2Manager::GetUiMapPosition(position.X, position.Y, position.Z, mapId, 0, 0, 0, UI_MAP_SYSTEM_TAXI, false, uiMapId, uiMapPosition);
 }
 
 void TaxiPathGraph::AddVerticeAndEdgeFromNodeInfo(TaxiNodesEntry const* from, TaxiNodesEntry const* to, uint32 pathId, std::vector<std::pair<edge, EdgeCost>>& edges)
@@ -104,22 +106,21 @@ void TaxiPathGraph::AddVerticeAndEdgeFromNodeInfo(TaxiNodesEntry const* from, Ta
             if (nodes[i - 1]->Flags & TAXI_PATH_NODE_FLAG_TELEPORT)
                 continue;
 
-            uint32 map1, map2;
+            int32 uiMap1, uiMap2;
             DBCPosition2D pos1, pos2;
 
-            DB2Manager::DeterminaAlternateMapPosition(nodes[i - 1]->ContinentID, nodes[i - 1]->Loc.X, nodes[i - 1]->Loc.Y, nodes[i - 1]->Loc.Z, &map1, &pos1);
-            DB2Manager::DeterminaAlternateMapPosition(nodes[i]->ContinentID, nodes[i]->Loc.X, nodes[i]->Loc.Y, nodes[i]->Loc.Z, &map2, &pos2);
+            GetTaxiMapPosition(nodes[i - 1]->Loc, nodes[i - 1]->ContinentID, &pos1, &uiMap1);
+            GetTaxiMapPosition(nodes[i]->Loc, nodes[i]->ContinentID, &pos2, &uiMap2);
 
-            if (map1 != map2)
+            if (uiMap1 != uiMap2)
                 continue;
 
             totalDist += std::sqrt(
                 std::pow(pos2.X - pos1.X, 2) +
-                std::pow(pos2.Y - pos1.Y, 2) +
-                std::pow(nodes[i]->Loc.Z - nodes[i - 1]->Loc.Z, 2));
+                std::pow(pos2.Y - pos1.Y, 2));
         }
 
-        uint32 dist = uint32(totalDist);
+        uint32 dist = uint32(totalDist * 32767.0f);
         if (dist > 0xFFFF)
             dist = 0xFFFF;
 
@@ -176,14 +177,50 @@ std::size_t TaxiPathGraph::GetCompleteNodeRoute(TaxiNodesEntry const* from, Taxi
     return shortestPath.size();
 }
 
+template<typename T>
+struct DiscoverVertexVisitor : public boost::base_visitor<DiscoverVertexVisitor<T>>
+{
+    using event_filter = boost::on_discover_vertex;
+
+    DiscoverVertexVisitor(T&& func) : _func(std::forward<T>(func)) { }
+
+    template <class Vertex, class Graph>
+    void operator()(Vertex v, Graph& /*g*/)
+    {
+        _func(v);
+    }
+
+private:
+    T _func;
+};
+
+template<typename T>
+inline auto make_discover_vertex_dfs_visitor(T&& t)
+{
+    return boost::make_dfs_visitor(DiscoverVertexVisitor<T>(std::forward<T>(t)));
+}
+
+void TaxiPathGraph::GetReachableNodesMask(TaxiNodesEntry const* from, TaxiMask* mask)
+{
+    boost::vector_property_map<boost::default_color_type> color(boost::num_vertices(m_graph));
+    std::fill(color.storage_begin(), color.storage_end(), boost::white_color);
+    boost::depth_first_visit(m_graph, GetVertexIDFromNodeID(from), make_discover_vertex_dfs_visitor([this, mask](vertex_descriptor vertex)
+    {
+        if (TaxiNodesEntry const* taxiNode = sTaxiNodesStore.LookupEntry(GetNodeIDFromVertexID(vertex)))
+            (*mask)[(taxiNode->ID - 1) / 8] |= 1 << ((taxiNode->ID - 1) % 8);
+    }), color);
+}
+
 TaxiPathGraph::vertex_descriptor TaxiPathGraph::CreateVertexFromFromNodeInfoIfNeeded(TaxiNodesEntry const* node)
 {
-    //Check if we need a new one or if it may be already created
-    if (m_vertices.size() <= node->CharacterBitNumber)
-        m_vertices.resize(node->CharacterBitNumber + 1);
+    auto itr = m_verticesByNode.find(node->ID);
+    if (itr == m_verticesByNode.end())
+    {
+        itr = m_verticesByNode.emplace(node->ID, m_nodesByVertex.size()).first;
+        m_nodesByVertex.push_back(node);
+    }
 
-    m_vertices[node->CharacterBitNumber] = node;
-    return node->CharacterBitNumber;
+    return itr->second;
 }
 
 uint32 TaxiPathGraph::EdgeCost::EvaluateDistance(Player const* player) const
diff --git a/src/server/game/Entities/Taxi/TaxiPathGraph.h b/src/server/game/Entities/Taxi/TaxiPathGraph.h
index 5331f12ba49..4f6508e2cfc 100644
--- a/src/server/game/Entities/Taxi/TaxiPathGraph.h
+++ b/src/server/game/Entities/Taxi/TaxiPathGraph.h
@@ -20,7 +20,10 @@
 
 #include "Position.h"
 #include "Define.h"
+#include "DBCEnums.h"
 #include <boost/graph/adjacency_list.hpp>
+#include <unordered_map>
+#include <vector>
 
 class Player;
 struct TaxiNodesEntry;
@@ -32,6 +35,7 @@ public:
 
     void Initialize();
     std::size_t GetCompleteNodeRoute(TaxiNodesEntry const* from, TaxiNodesEntry const* to, Player const* player, std::vector<uint32>& shortestPath);
+    void GetReachableNodesMask(TaxiNodesEntry const* from, TaxiMask* mask);
 
 private:
     struct EdgeCost
@@ -53,10 +57,10 @@ private:
     vertex_descriptor GetVertexIDFromNodeID(TaxiNodesEntry const* node);
     uint32 GetNodeIDFromVertexID(vertex_descriptor vertexID);
     vertex_descriptor CreateVertexFromFromNodeInfoIfNeeded(TaxiNodesEntry const* node);
-    std::size_t GetVertexCount();
 
     Graph m_graph;
-    std::vector<TaxiNodesEntry const*> m_vertices;
+    std::vector<TaxiNodesEntry const*> m_nodesByVertex;
+    std::unordered_map<uint32, vertex_descriptor> m_verticesByNode;
 
     TaxiPathGraph(TaxiPathGraph const&) = delete;
     TaxiPathGraph& operator=(TaxiPathGraph const&) = delete;
diff --git a/src/server/game/Entities/Transport/Transport.cpp b/src/server/game/Entities/Transport/Transport.cpp
index 50b1897e2c5..6de4ae21027 100644
--- a/src/server/game/Entities/Transport/Transport.cpp
+++ b/src/server/game/Entities/Transport/Transport.cpp
@@ -38,7 +38,9 @@ Transport::Transport() : GameObject(),
     _triggeredArrivalEvent(false), _triggeredDepartureEvent(false),
     _passengerTeleportItr(_passengers.begin()), _delayedAddModel(false), _delayedTeleport(false)
 {
-    m_updateFlag = UPDATEFLAG_TRANSPORT | UPDATEFLAG_STATIONARY_POSITION | UPDATEFLAG_ROTATION;
+    m_updateFlag.ServerTime = true;
+    m_updateFlag.Stationary = true;
+    m_updateFlag.Rotation = true;
 }
 
 Transport::~Transport()
diff --git a/src/server/game/Entities/Unit/StatSystem.cpp b/src/server/game/Entities/Unit/StatSystem.cpp
index 7e0d38c9875..6d940a91582 100644
--- a/src/server/game/Entities/Unit/StatSystem.cpp
+++ b/src/server/game/Entities/Unit/StatSystem.cpp
@@ -160,9 +160,9 @@ void Player::ApplySpellPowerBonus(int32 amount, bool apply)
     apply = _ModifyUInt32(apply, m_baseSpellPower, amount);
 
     // For speed just update for client
-    ApplyModUInt32Value(PLAYER_FIELD_MOD_HEALING_DONE_POS, amount, apply);
+    ApplyModUInt32Value(ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_POS, amount, apply);
     for (int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
-        ApplyModUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i, amount, apply);
+        ApplyModUInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i, amount, apply);
 
     if (HasAuraType(SPELL_AURA_OVERRIDE_ATTACK_POWER_BY_SP_PCT))
     {
@@ -176,18 +176,18 @@ void Player::UpdateSpellDamageAndHealingBonus()
     // Magic damage modifiers implemented in Unit::SpellDamageBonusDone
     // This information for client side use only
     // Get healing bonus for all schools
-    SetStatInt32Value(PLAYER_FIELD_MOD_HEALING_DONE_POS, SpellBaseHealingBonusDone(SPELL_SCHOOL_MASK_ALL));
+    SetStatInt32Value(ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_POS, SpellBaseHealingBonusDone(SPELL_SCHOOL_MASK_ALL));
     // Get damage bonus for all schools
     Unit::AuraEffectList const& modDamageAuras = GetAuraEffectsByType(SPELL_AURA_MOD_DAMAGE_DONE);
     for (uint16 i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
     {
-        SetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + i, std::accumulate(modDamageAuras.begin(), modDamageAuras.end(), 0, [i](int32 negativeMod, AuraEffect const* aurEff)
+        SetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + i, std::accumulate(modDamageAuras.begin(), modDamageAuras.end(), 0, [i](int32 negativeMod, AuraEffect const* aurEff)
         {
             if (aurEff->GetAmount() < 0 && aurEff->GetMiscValue() & (1 << i))
                 negativeMod += aurEff->GetAmount();
             return negativeMod;
         }));
-        SetStatInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i, SpellBaseDamageBonusDone(SpellSchoolMask(1 << i)) - GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + i));
+        SetStatInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i, SpellBaseDamageBonusDone(SpellSchoolMask(1 << i)) - GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + i));
     }
 
     if (HasAuraType(SPELL_AURA_OVERRIDE_ATTACK_POWER_BY_SP_PCT))
@@ -231,7 +231,7 @@ bool Player::UpdateAllStats()
 
 void Player::ApplySpellPenetrationBonus(int32 amount, bool apply)
 {
-    ApplyModInt32Value(PLAYER_FIELD_MOD_TARGET_RESISTANCE, -amount, apply);
+    ApplyModInt32Value(ACTIVE_PLAYER_FIELD_MOD_TARGET_RESISTANCE, -amount, apply);
     m_spellPenetrationItemMod += apply ? amount : -amount;
 }
 
@@ -239,8 +239,7 @@ void Player::UpdateResistances(uint32 school)
 {
     if (school > SPELL_SCHOOL_NORMAL)
     {
-        float value  = GetTotalAuraModValue(UnitMods(UNIT_MOD_RESISTANCE_START + school));
-        SetResistance(SpellSchools(school), int32(value));
+        Unit::UpdateResistances(school);
 
         Pet* pet = GetPet();
         if (pet)
@@ -255,6 +254,7 @@ void Player::UpdateArmor()
     UnitMods unitMod = UNIT_MOD_ARMOR;
 
     float value = GetModifierValue(unitMod, BASE_VALUE);    // base armor (from items)
+    float baseValue = value;
     value *= GetModifierValue(unitMod, BASE_PCT);           // armor percent from items
     value += GetModifierValue(unitMod, TOTAL_VALUE);
 
@@ -268,7 +268,7 @@ void Player::UpdateArmor()
 
     value *= GetModifierValue(unitMod, TOTAL_PCT);
 
-    SetArmor(int32(value));
+    SetArmor(int32(baseValue), int32(value - baseValue));
 
     Pet* pet = GetPet();
     if (pet)
@@ -360,11 +360,11 @@ void Player::UpdateAttackPowerAndDamage(bool ranged)
     }
     else
     {
-        int32 minSpellPower = GetInt32Value(PLAYER_FIELD_MOD_HEALING_DONE_POS);
+        int32 minSpellPower = GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_POS);
         for (int i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
-            minSpellPower = std::min(minSpellPower, GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i));
+            minSpellPower = std::min(minSpellPower, GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + i));
 
-        val2 = CalculatePct(float(minSpellPower), GetFloatValue(PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT));
+        val2 = CalculatePct(float(minSpellPower), GetFloatValue(ACTIVE_PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT));
     }
 
     SetModifierValue(unitMod, BASE_VALUE, val2);
@@ -488,7 +488,7 @@ void Player::UpdateBlockPercentage()
 
         value = value < 0.0f ? 0.0f : value;
     }
-    SetStatFloatValue(PLAYER_BLOCK_PERCENTAGE, value);
+    SetStatFloatValue(ACTIVE_PLAYER_FIELD_BLOCK_PERCENTAGE, value);
 }
 
 void Player::UpdateCritPercentage(WeaponAttackType attType)
@@ -501,18 +501,18 @@ void Player::UpdateCritPercentage(WeaponAttackType attType)
     {
         case OFF_ATTACK:
             modGroup = OFFHAND_CRIT_PERCENTAGE;
-            index = PLAYER_OFFHAND_CRIT_PERCENTAGE;
+            index = ACTIVE_PLAYER_FIELD_OFFHAND_CRIT_PERCENTAGE;
             cr = CR_CRIT_MELEE;
             break;
         case RANGED_ATTACK:
             modGroup = RANGED_CRIT_PERCENTAGE;
-            index = PLAYER_RANGED_CRIT_PERCENTAGE;
+            index = ACTIVE_PLAYER_FIELD_RANGED_CRIT_PERCENTAGE;
             cr = CR_CRIT_RANGED;
             break;
         case BASE_ATTACK:
         default:
             modGroup = CRIT_PERCENTAGE;
-            index = PLAYER_CRIT_PERCENTAGE;
+            index = ACTIVE_PLAYER_FIELD_CRIT_PERCENTAGE;
             cr = CR_CRIT_MELEE;
             break;
     }
@@ -545,13 +545,13 @@ void Player::UpdateMastery()
 {
     if (!CanUseMastery())
     {
-        SetFloatValue(PLAYER_MASTERY, 0.0f);
+        SetFloatValue(ACTIVE_PLAYER_FIELD_MASTERY, 0.0f);
         return;
     }
 
     float value = GetTotalAuraModifier(SPELL_AURA_MASTERY);
     value += GetRatingBonusValue(CR_MASTERY);
-    SetFloatValue(PLAYER_MASTERY, value);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_MASTERY, value);
 
     ChrSpecializationEntry const* chrSpec = sChrSpecializationStore.LookupEntry(GetUInt32Value(PLAYER_FIELD_CURRENT_SPEC_ID));
     if (!chrSpec)
@@ -579,7 +579,7 @@ void Player::UpdateMastery()
 void Player::UpdateVersatilityDamageDone()
 {
     // No proof that CR_VERSATILITY_DAMAGE_DONE is allways = PLAYER_VERSATILITY
-    SetUInt32Value(PLAYER_VERSATILITY, GetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + CR_VERSATILITY_DAMAGE_DONE));
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_VERSATILITY, GetUInt32Value(ACTIVE_PLAYER_FIELD_COMBAT_RATING + CR_VERSATILITY_DAMAGE_DONE));
 
     if (getClass() == CLASS_HUNTER)
         UpdateDamagePhysical(RANGED_ATTACK);
@@ -596,7 +596,7 @@ void Player::UpdateHealingDonePercentMod()
     for (AuraEffect const* auraEffect : GetAuraEffectsByType(SPELL_AURA_MOD_HEALING_DONE_PERCENT))
         AddPct(value, auraEffect->GetAmount());
 
-    SetStatFloatValue(PLAYER_FIELD_MOD_HEALING_DONE_PCT, value);
+    SetStatFloatValue(ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_PCT, value);
 }
 
 const float m_diminishing_k[MAX_CLASSES] =
@@ -651,7 +651,7 @@ void Player::UpdateParryPercentage()
 
         value = value < 0.0f ? 0.0f : value;
     }
-    SetStatFloatValue(PLAYER_PARRY_PERCENTAGE, value);
+    SetStatFloatValue(ACTIVE_PLAYER_FIELD_PARRY_PERCENTAGE, value);
 }
 
 void Player::UpdateDodgePercentage()
@@ -686,7 +686,7 @@ void Player::UpdateDodgePercentage()
          value = value > sWorld->getFloatConfig(CONFIG_STATS_LIMITS_DODGE) ? sWorld->getFloatConfig(CONFIG_STATS_LIMITS_DODGE) : value;
 
     value = value < 0.0f ? 0.0f : value;
-    SetStatFloatValue(PLAYER_DODGE_PERCENTAGE, value);
+    SetStatFloatValue(ACTIVE_PLAYER_FIELD_DODGE_PERCENTAGE, value);
 }
 
 void Player::UpdateSpellCritChance()
@@ -700,13 +700,13 @@ void Player::UpdateSpellCritChance()
     crit += GetRatingBonusValue(CR_CRIT_SPELL);
 
     // Store crit value
-    SetFloatValue(PLAYER_SPELL_CRIT_PERCENTAGE1, crit);
+    SetFloatValue(ACTIVE_PLAYER_FIELD_SPELL_CRIT_PERCENTAGE1, crit);
 }
 
 void Player::UpdateArmorPenetration(int32 amount)
 {
     // Store Rating Value
-    SetUInt32Value(PLAYER_FIELD_COMBAT_RATING_1 + CR_ARMOR_PENETRATION, amount);
+    SetUInt32Value(ACTIVE_PLAYER_FIELD_COMBAT_RATING + CR_ARMOR_PENETRATION, amount);
 }
 
 void Player::UpdateMeleeHitChances()
@@ -746,10 +746,10 @@ void Player::UpdateExpertise(WeaponAttackType attack)
     switch (attack)
     {
         case BASE_ATTACK:
-            SetUInt32Value(PLAYER_EXPERTISE, expertise);
+            SetUInt32Value(ACTIVE_PLAYER_FIELD_EXPERTISE, expertise);
             break;
         case OFF_ATTACK:
-            SetUInt32Value(PLAYER_OFFHAND_EXPERTISE, expertise);
+            SetUInt32Value(ACTIVE_PLAYER_FIELD_OFFHAND_EXPERTISE, expertise);
             break;
         default:
             break;
@@ -855,21 +855,11 @@ bool Creature::UpdateAllStats()
     return true;
 }
 
-void Creature::UpdateResistances(uint32 school)
-{
-    if (school > SPELL_SCHOOL_NORMAL)
-    {
-        float value  = GetTotalAuraModValue(UnitMods(UNIT_MOD_RESISTANCE_START + school));
-        SetResistance(SpellSchools(school), int32(value));
-    }
-    else
-        UpdateArmor();
-}
-
 void Creature::UpdateArmor()
 {
+    float baseValue = GetModifierValue(UNIT_MOD_ARMOR, BASE_VALUE);
     float value = GetTotalAuraModValue(UNIT_MOD_ARMOR);
-    SetArmor(int32(value));
+    SetArmor(int32(baseValue), int32(value - baseValue));
 }
 
 void Creature::UpdateMaxHealth()
@@ -1077,13 +1067,18 @@ void Guardian::UpdateResistances(uint32 school)
 {
     if (school > SPELL_SCHOOL_NORMAL)
     {
-        float value  = GetTotalAuraModValue(UnitMods(UNIT_MOD_RESISTANCE_START + school));
+        float baseValue = GetModifierValue(UnitMods(UNIT_MOD_RESISTANCE_START + school), BASE_VALUE);
+        float bonusValue = GetTotalAuraModValue(UnitMods(UNIT_MOD_RESISTANCE_START + school)) - baseValue;
 
         // hunter and warlock pets gain 40% of owner's resistance
         if (IsPet())
-            value += float(CalculatePct(m_owner->GetResistance(SpellSchools(school)), 40));
+        {
+            baseValue += float(CalculatePct(m_owner->GetResistance(SpellSchools(school)), 40));
+            bonusValue += float(CalculatePct(m_owner->GetBonusResistanceMod(SpellSchools(school)), 40));
+        }
 
-        SetResistance(SpellSchools(school), int32(value));
+        SetResistance(SpellSchools(school), int32(baseValue));
+        SetBonusResistanceMod(SpellSchools(school), int32(bonusValue));
     }
     else
         UpdateArmor();
@@ -1091,6 +1086,7 @@ void Guardian::UpdateResistances(uint32 school)
 
 void Guardian::UpdateArmor()
 {
+    float baseValue = 0.0f;
     float value = 0.0f;
     float bonus_armor = 0.0f;
     UnitMods unitMod = UNIT_MOD_ARMOR;
@@ -1102,11 +1098,12 @@ void Guardian::UpdateArmor()
         bonus_armor = m_owner->GetArmor();
 
     value  = GetModifierValue(unitMod, BASE_VALUE);
+    baseValue = value;
     value *= GetModifierValue(unitMod, BASE_PCT);
     value += GetModifierValue(unitMod, TOTAL_VALUE) + bonus_armor;
     value *= GetModifierValue(unitMod, TOTAL_PCT);
 
-    SetArmor(int32(value));
+    SetArmor(int32(baseValue), int32(value - baseValue));
 }
 
 void Guardian::UpdateMaxHealth()
@@ -1186,8 +1183,8 @@ void Guardian::UpdateAttackPowerAndDamage(bool ranged)
         //demons benefit from warlocks shadow or fire damage
         else if (IsPet())
         {
-            int32 fire  = owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE) - owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);
-            int32 shadow = owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW) - owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_SHADOW);
+            int32 fire  = owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE) - owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);
+            int32 shadow = owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW) - owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_SHADOW);
             int32 maximum  = (fire > shadow) ? fire : shadow;
             if (maximum < 0)
                 maximum = 0;
@@ -1197,7 +1194,7 @@ void Guardian::UpdateAttackPowerAndDamage(bool ranged)
         //water elementals benefit from mage's frost damage
         else if (GetEntry() == ENTRY_WATER_ELEMENTAL)
         {
-            int32 frost = owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FROST) - owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FROST);
+            int32 frost = owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FROST) - owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FROST);
             if (frost < 0)
                 frost = 0;
             SetBonusDamage(int32(frost * 0.4f));
@@ -1230,14 +1227,14 @@ void Guardian::UpdateDamagePhysical(WeaponAttackType attType)
         //force of nature
         if (GetEntry() == ENTRY_TREANT)
         {
-            int32 spellDmg = m_owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_NATURE) - m_owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_NATURE);
+            int32 spellDmg = m_owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_NATURE) - m_owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_NATURE);
             if (spellDmg > 0)
                 bonusDamage = spellDmg * 0.09f;
         }
         //greater fire elemental
         else if (GetEntry() == ENTRY_FIRE_ELEMENTAL)
         {
-            int32 spellDmg = m_owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE) - m_owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);
+            int32 spellDmg = m_owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE) - m_owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);
             if (spellDmg > 0)
                 bonusDamage = spellDmg * 0.4f;
         }
@@ -1266,5 +1263,5 @@ void Guardian::SetBonusDamage(int32 damage)
 {
     m_bonusSpellDamage = damage;
     if (GetOwner()->GetTypeId() == TYPEID_PLAYER)
-        GetOwner()->SetUInt32Value(PLAYER_PET_SPELL_POWER, damage);
+        GetOwner()->SetUInt32Value(ACTIVE_PLAYER_FIELD_PET_SPELL_POWER, damage);
 }
diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp
index bd375f96b6c..8261a97c32a 100644
--- a/src/server/game/Entities/Unit/Unit.cpp
+++ b/src/server/game/Entities/Unit/Unit.cpp
@@ -111,13 +111,13 @@ bool DispelableAura::RollDispel() const
 }
 
 DamageInfo::DamageInfo(Unit* attacker, Unit* victim, uint32 damage, SpellInfo const* spellInfo, SpellSchoolMask schoolMask, DamageEffectType damageType, WeaponAttackType attackType)
-    : m_attacker(attacker), m_victim(victim), m_damage(damage), m_spellInfo(spellInfo), m_schoolMask(schoolMask), m_damageType(damageType), m_attackType(attackType),
+    : m_attacker(attacker), m_victim(victim), m_damage(damage), m_originalDamage(damage), m_spellInfo(spellInfo), m_schoolMask(schoolMask), m_damageType(damageType), m_attackType(attackType),
     m_absorb(0), m_resist(0), m_block(0), m_hitMask(0)
 {
 }
 
 DamageInfo::DamageInfo(CalcDamageInfo const& dmgInfo)
-    : m_attacker(dmgInfo.attacker), m_victim(dmgInfo.target), m_damage(dmgInfo.damage), m_spellInfo(nullptr), m_schoolMask(SpellSchoolMask(dmgInfo.damageSchoolMask)),
+    : m_attacker(dmgInfo.attacker), m_victim(dmgInfo.target), m_damage(dmgInfo.damage), m_originalDamage(dmgInfo.damage), m_spellInfo(nullptr), m_schoolMask(SpellSchoolMask(dmgInfo.damageSchoolMask)),
     m_damageType(DIRECT_DAMAGE), m_attackType(dmgInfo.attackType), m_absorb(dmgInfo.absorb), m_resist(dmgInfo.resist), m_block(dmgInfo.blocked_amount), m_hitMask(0)
 {
     switch (dmgInfo.TargetState)
@@ -171,7 +171,7 @@ DamageInfo::DamageInfo(CalcDamageInfo const& dmgInfo)
 }
 
 DamageInfo::DamageInfo(SpellNonMeleeDamage const& spellNonMeleeDamage, DamageEffectType damageType, WeaponAttackType attackType, uint32 hitMask)
-    : m_attacker(spellNonMeleeDamage.attacker), m_victim(spellNonMeleeDamage.target), m_damage(spellNonMeleeDamage.damage),
+    : m_attacker(spellNonMeleeDamage.attacker), m_victim(spellNonMeleeDamage.target), m_damage(spellNonMeleeDamage.damage), m_originalDamage(spellNonMeleeDamage.originalDamage),
     m_spellInfo(sSpellMgr->GetSpellInfo(spellNonMeleeDamage.SpellID)), m_schoolMask(SpellSchoolMask(spellNonMeleeDamage.schoolMask)), m_damageType(damageType),
     m_attackType(attackType), m_absorb(spellNonMeleeDamage.absorb), m_resist(spellNonMeleeDamage.resist), m_block(spellNonMeleeDamage.blocked), m_hitMask(hitMask)
 {
@@ -226,7 +226,7 @@ uint32 DamageInfo::GetHitMask() const
 }
 
 HealInfo::HealInfo(Unit* healer, Unit* target, uint32 heal, SpellInfo const* spellInfo, SpellSchoolMask schoolMask)
-    : _healer(healer), _target(target), _heal(heal), _effectiveHeal(0), _absorb(0), _spellInfo(spellInfo), _schoolMask(schoolMask), _hitMask(0)
+    : _healer(healer), _target(target), _heal(heal), _originalHeal(heal), _effectiveHeal(0), _absorb(0), _spellInfo(spellInfo), _schoolMask(schoolMask), _hitMask(0)
 {
 }
 
@@ -279,8 +279,8 @@ SpellSchoolMask ProcEventInfo::GetSchoolMask() const
 }
 
 SpellNonMeleeDamage::SpellNonMeleeDamage(Unit* _attacker, Unit* _target, uint32 _SpellID, uint32 _SpellXSpellVisualID, uint32 _schoolMask, ObjectGuid _castId)
-    : target(_target), attacker(_attacker), castId(_castId), SpellID(_SpellID), SpellXSpellVisualID(_SpellXSpellVisualID), damage(0), schoolMask(_schoolMask),
-    absorb(0), resist(0), periodicLog(false), blocked(0), HitInfo(0), cleanDamage(0), fullBlock(false), preHitHealth(_target->GetHealth())
+    : target(_target), attacker(_attacker), castId(_castId), SpellID(_SpellID), SpellXSpellVisualID(_SpellXSpellVisualID), damage(0), originalDamage(0),
+    schoolMask(_schoolMask), absorb(0), resist(0), periodicLog(false), blocked(0), HitInfo(0), cleanDamage(0), fullBlock(false), preHitHealth(_target->GetHealth())
 {
 }
 
@@ -297,7 +297,7 @@ Unit::Unit(bool isWorldObject) :
     m_objectType |= TYPEMASK_UNIT;
     m_objectTypeId = TYPEID_UNIT;
 
-    m_updateFlag = UPDATEFLAG_LIVING;
+    m_updateFlag.MovementUpdate = true;
 
     for (uint32 i = 0; i < MAX_ATTACK; ++i)
     {
@@ -1181,6 +1181,7 @@ void Unit::CalculateSpellDamageTaken(SpellNonMeleeDamage* damageInfo, int32 dama
         damage = 0;
 
     damageInfo->damage = damage;
+    damageInfo->originalDamage = damage;
     DamageInfo dmgInfo(*damageInfo, SPELL_DIRECT_DAMAGE, BASE_ATTACK, PROC_HIT_NONE);
     CalcAbsorbResist(dmgInfo);
     damageInfo->absorb = dmgInfo.GetAbsorb();
@@ -1227,6 +1228,7 @@ void Unit::CalculateMeleeDamage(Unit* victim, uint32 damage, CalcDamageInfo* dam
     damageInfo->damageSchoolMask = GetMeleeDamageSchoolMask();
     damageInfo->attackType       = attackType;
     damageInfo->damage           = 0;
+    damageInfo->originalDamage   = 0;
     damageInfo->cleanDamage      = 0;
     damageInfo->absorb           = 0;
     damageInfo->resist           = 0;
@@ -1295,17 +1297,20 @@ void Unit::CalculateMeleeDamage(Unit* victim, uint32 damage, CalcDamageInfo* dam
         case MELEE_HIT_EVADE:
             damageInfo->HitInfo        |= HITINFO_MISS | HITINFO_SWINGNOHITSOUND;
             damageInfo->TargetState     = VICTIMSTATE_EVADES;
+            damageInfo->originalDamage = damageInfo->damage;
             damageInfo->damage = 0;
             damageInfo->cleanDamage = 0;
             return;
         case MELEE_HIT_MISS:
             damageInfo->HitInfo        |= HITINFO_MISS;
             damageInfo->TargetState     = VICTIMSTATE_INTACT;
+            damageInfo->originalDamage = damageInfo->damage;
             damageInfo->damage          = 0;
             damageInfo->cleanDamage     = 0;
             break;
         case MELEE_HIT_NORMAL:
             damageInfo->TargetState     = VICTIMSTATE_HIT;
+            damageInfo->originalDamage = damageInfo->damage;
             break;
         case MELEE_HIT_CRIT:
         {
@@ -1320,21 +1325,26 @@ void Unit::CalculateMeleeDamage(Unit* victim, uint32 damage, CalcDamageInfo* dam
 
             if (mod != 0)
                 AddPct(damageInfo->damage, mod);
+
+            damageInfo->originalDamage = damageInfo->damage;
             break;
         }
         case MELEE_HIT_PARRY:
             damageInfo->TargetState  = VICTIMSTATE_PARRY;
+            damageInfo->originalDamage = damageInfo->damage;
             damageInfo->cleanDamage += damageInfo->damage;
             damageInfo->damage = 0;
             break;
         case MELEE_HIT_DODGE:
             damageInfo->TargetState  = VICTIMSTATE_DODGE;
+            damageInfo->originalDamage = damageInfo->damage;
             damageInfo->cleanDamage += damageInfo->damage;
             damageInfo->damage = 0;
             break;
         case MELEE_HIT_BLOCK:
             damageInfo->TargetState = VICTIMSTATE_HIT;
             damageInfo->HitInfo    |= HITINFO_BLOCK;
+            damageInfo->originalDamage = damageInfo->damage;
             // 30% damage blocked, double blocked amount if block is critical
             damageInfo->blocked_amount = CalculatePct(damageInfo->damage, damageInfo->target->isBlockCritical() ? damageInfo->target->GetBlockPercent() * 2 : damageInfo->target->GetBlockPercent());
             damageInfo->damage      -= damageInfo->blocked_amount;
@@ -1344,6 +1354,7 @@ void Unit::CalculateMeleeDamage(Unit* victim, uint32 damage, CalcDamageInfo* dam
         {
             damageInfo->HitInfo     |= HITINFO_GLANCING;
             damageInfo->TargetState  = VICTIMSTATE_HIT;
+            damageInfo->originalDamage = damageInfo->damage;
             int32 leveldif = int32(victim->getLevel()) - int32(getLevel());
             if (leveldif > 3)
                 leveldif = 3;
@@ -1358,6 +1369,7 @@ void Unit::CalculateMeleeDamage(Unit* victim, uint32 damage, CalcDamageInfo* dam
             damageInfo->TargetState  = VICTIMSTATE_HIT;
             // 150% normal damage
             damageInfo->damage += (damageInfo->damage / 2);
+            damageInfo->originalDamage = damageInfo->damage;
             break;
         default:
             break;
@@ -1372,6 +1384,7 @@ void Unit::CalculateMeleeDamage(Unit* victim, uint32 damage, CalcDamageInfo* dam
     resilienceReduction = damageInfo->damage - resilienceReduction;
     damageInfo->damage      -= resilienceReduction;
     damageInfo->cleanDamage += resilienceReduction;
+    damageInfo->originalDamage -= resilienceReduction;
 
     // Calculate absorb resist
     if (int32(damageInfo->damage) > 0)
@@ -1514,7 +1527,6 @@ void Unit::DealMeleeDamage(CalcDamageInfo* damageInfo, bool durabilityLoss)
             DamageInfo damageInfo(this, victim, damage, spellInfo, spellInfo->GetSchoolMask(), SPELL_DIRECT_DAMAGE, BASE_ATTACK);
             victim->CalcAbsorbResist(damageInfo);
             damage = damageInfo.GetDamage();
-            // No Unit::CalcAbsorbResist here - opcode doesn't send that data - this damage is probably not affected by that
             victim->DealDamageMods(this, damage, nullptr);
 
             WorldPackets::CombatLog::SpellDamageShield damageShield;
@@ -1522,6 +1534,7 @@ void Unit::DealMeleeDamage(CalcDamageInfo* damageInfo, bool durabilityLoss)
             damageShield.Defender = GetGUID();
             damageShield.SpellID = spellInfo->Id;
             damageShield.TotalDamage = damage;
+            damageShield.OriginalDamage = damageInfo.GetOriginalDamage();
             damageShield.OverKill = std::max(int32(damage) - int32(GetHealth()), 0);
             damageShield.SchoolMask = spellInfo->SchoolMask;
             damageShield.LogAbsorbed = damageInfo.GetAbsorb();
@@ -1881,6 +1894,7 @@ void Unit::CalcAbsorbResist(DamageInfo& damageInfo)
             CleanDamage cleanDamage = CleanDamage(splitDamage, 0, BASE_ATTACK, MELEE_HIT_NORMAL);
             DealDamage(caster, splitDamage, &cleanDamage, DIRECT_DAMAGE, damageInfo.GetSchoolMask(), (*itr)->GetSpellInfo(), false);
             log.damage = splitDamage;
+            log.originalDamage = splitDamage;
             log.absorb = split_absorb;
             SendSpellNonMeleeDamageLog(&log);
 
@@ -2016,6 +2030,7 @@ void Unit::FakeAttackerStateUpdate(Unit* victim, WeaponAttackType attType /*= BA
     damageInfo.damageSchoolMask = GetMeleeDamageSchoolMask();
     damageInfo.attackType = attType;
     damageInfo.damage = 0;
+    damageInfo.originalDamage = 0;
     damageInfo.cleanDamage = 0;
     damageInfo.absorb = 0;
     damageInfo.resist = 0;
@@ -2573,7 +2588,7 @@ float Unit::GetUnitDodgeChance(WeaponAttackType attType, Unit const* victim) con
     float chance = 0.0f;
     float levelBonus = 0.0f;
     if (victim->GetTypeId() == TYPEID_PLAYER)
-        chance = victim->GetFloatValue(PLAYER_DODGE_PERCENTAGE);
+        chance = victim->GetFloatValue(ACTIVE_PLAYER_FIELD_DODGE_PERCENTAGE);
     else
     {
         if (!victim->IsTotem())
@@ -2617,7 +2632,7 @@ float Unit::GetUnitParryChance(WeaponAttackType attType, Unit const* victim) con
                 tmpitem = playerVictim->GetWeaponForAttack(OFF_ATTACK, true);
 
             if (tmpitem)
-                chance = playerVictim->GetFloatValue(PLAYER_PARRY_PERCENTAGE);
+                chance = playerVictim->GetFloatValue(ACTIVE_PLAYER_FIELD_PARRY_PERCENTAGE);
         }
     }
     else
@@ -2666,7 +2681,7 @@ float Unit::GetUnitBlockChance(WeaponAttackType /*attType*/, Unit const* victim)
         {
             Item* tmpitem = playerVictim->GetUseableItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
             if (tmpitem && !tmpitem->IsBroken() && tmpitem->GetTemplate()->GetInventoryType() == INVTYPE_SHIELD)
-                chance = playerVictim->GetFloatValue(PLAYER_BLOCK_PERCENTAGE);
+                chance = playerVictim->GetFloatValue(ACTIVE_PLAYER_FIELD_BLOCK_PERCENTAGE);
         }
     }
     else
@@ -2693,13 +2708,13 @@ float Unit::GetUnitCriticalChance(WeaponAttackType attackType, Unit const* victi
         switch (attackType)
         {
             case BASE_ATTACK:
-                chance = GetFloatValue(PLAYER_CRIT_PERCENTAGE);
+                chance = GetFloatValue(ACTIVE_PLAYER_FIELD_CRIT_PERCENTAGE);
                 break;
             case OFF_ATTACK:
-                chance = GetFloatValue(PLAYER_OFFHAND_CRIT_PERCENTAGE);
+                chance = GetFloatValue(ACTIVE_PLAYER_FIELD_OFFHAND_CRIT_PERCENTAGE);
                 break;
             case RANGED_ATTACK:
-                chance = GetFloatValue(PLAYER_RANGED_CRIT_PERCENTAGE);
+                chance = GetFloatValue(ACTIVE_PLAYER_FIELD_RANGED_CRIT_PERCENTAGE);
                 break;
                 // Just for good manner
             default:
@@ -4724,26 +4739,6 @@ int32 Unit::GetMaxNegativeAuraModifierByAffectMask(AuraType auratype, SpellInfo
     });
 }
 
-float Unit::GetResistanceBuffMods(SpellSchools school, bool positive) const
-{
-    return GetFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school);
-}
-
-void Unit::SetResistanceBuffMods(SpellSchools school, bool positive, float val)
-{
-    SetFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school, val);
-}
-
-void Unit::ApplyResistanceBuffModsMod(SpellSchools school, bool positive, float val, bool apply)
-{
-    ApplyModSignedFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school, val, apply);
-}
-
-void Unit::ApplyResistanceBuffModsPercentMod(SpellSchools school, bool positive, float val, bool apply)
-{
-    ApplyPercentModFloatValue(positive ? UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE+school : UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE+school, val, apply);
-}
-
 void Unit::InitStatBuffMods()
 {
     for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i)
@@ -5005,6 +5000,7 @@ void Unit::SendSpellNonMeleeDamageLog(SpellNonMeleeDamage const* log)
     packet.CastID = log->castId;
     packet.SpellID = log->SpellID;
     packet.Damage = log->damage;
+    packet.OriginalDamage = log->originalDamage;
     if (log->damage > log->preHitHealth)
         packet.Overkill = log->damage - log->preHitHealth;
     else
@@ -5017,9 +5013,9 @@ void Unit::SendSpellNonMeleeDamageLog(SpellNonMeleeDamage const* log)
     packet.Periodic = log->periodicLog;
     packet.Flags = log->HitInfo;
 
-    WorldPackets::Spells::SandboxScalingData sandboxScalingData;
-    if (sandboxScalingData.GenerateDataForUnits(log->attacker, log->target))
-        packet.SandboxScaling = sandboxScalingData;
+    WorldPackets::Spells::ContentTuningParams contentTuningParams;
+    if (contentTuningParams.GenerateDataForUnits(log->attacker, log->target))
+        packet.ContentTuning = contentTuningParams;
 
     SendCombatLogMessage(&packet);
 }
@@ -5045,10 +5041,10 @@ void Unit::SendPeriodicAuraLog(SpellPeriodicAuraLogInfo* info)
     data.SpellID = aura->GetId();
     data.LogData.Initialize(this);
 
-    /// @todo: should send more logs in one packet when multistrike
     WorldPackets::CombatLog::SpellPeriodicAuraLog::SpellLogEffect spellLogEffect;
     spellLogEffect.Effect = aura->GetAuraType();
     spellLogEffect.Amount = info->damage;
+    spellLogEffect.OriginalDamage = info->originalDamage;
     spellLogEffect.OverHealOrKill = info->overDamage;
     spellLogEffect.SchoolMaskOrPower = aura->GetSpellInfo()->GetSchoolMask();
     spellLogEffect.AbsorbedOrAmplitude = info->absorb;
@@ -5056,10 +5052,10 @@ void Unit::SendPeriodicAuraLog(SpellPeriodicAuraLogInfo* info)
     spellLogEffect.Crit = info->critical;
     /// @todo: implement debug info
 
-    WorldPackets::Spells::SandboxScalingData sandboxScalingData;
+    WorldPackets::Spells::ContentTuningParams contentTuningParams;
     if (Unit* caster = ObjectAccessor::GetUnit(*this, aura->GetCasterGUID()))
-        if (sandboxScalingData.GenerateDataForUnits(caster, this))
-            spellLogEffect.SandboxScaling = sandboxScalingData;
+        if (contentTuningParams.GenerateDataForUnits(caster, this))
+            spellLogEffect.ContentTuning = contentTuningParams;
 
     data.Effects.push_back(spellLogEffect);
 
@@ -5101,6 +5097,7 @@ void Unit::SendAttackStateUpdate(CalcDamageInfo* damageInfo)
     packet.AttackerGUID = damageInfo->attacker->GetGUID();
     packet.VictimGUID = damageInfo->target->GetGUID();
     packet.Damage = damageInfo->damage;
+    packet.OriginalDamage = damageInfo->originalDamage;
     int32 overkill = damageInfo->damage - damageInfo->target->GetHealth();
     packet.OverDamage = (overkill < 0 ? -1 : overkill);
 
@@ -5116,9 +5113,9 @@ void Unit::SendAttackStateUpdate(CalcDamageInfo* damageInfo)
 
     packet.LogData.Initialize(damageInfo->attacker);
 
-    WorldPackets::Spells::SandboxScalingData sandboxScalingData;
-    if (sandboxScalingData.GenerateDataForUnits(damageInfo->attacker, damageInfo->target))
-        packet.SandboxScaling = sandboxScalingData;
+    WorldPackets::Spells::ContentTuningParams contentTuningParams;
+    if (contentTuningParams.GenerateDataForUnits(damageInfo->attacker, damageInfo->target))
+        packet.ContentTuning = contentTuningParams;
 
     SendCombatLogMessage(&packet);
 }
@@ -5130,6 +5127,7 @@ void Unit::SendAttackStateUpdate(uint32 HitInfo, Unit* target, uint8 /*SwingType
     dmgInfo.attacker = this;
     dmgInfo.target = target;
     dmgInfo.damage = Damage - AbsorbDamage - Resist - BlockedAmount;
+    dmgInfo.originalDamage = Damage;
     dmgInfo.damageSchoolMask = damageSchoolMask;
     dmgInfo.absorb = AbsorbDamage;
     dmgInfo.resist = Resist;
@@ -5899,7 +5897,7 @@ void Unit::SetMinion(Minion *minion, bool apply)
         {
             SetCritterGUID(minion->GetGUID());
             if (GetTypeId() == TYPEID_PLAYER)
-                minion->SetGuidValue(UNIT_FIELD_BATTLE_PET_COMPANION_GUID, GetGuidValue(PLAYER_FIELD_SUMMONED_BATTLE_PET_ID));
+                minion->SetGuidValue(UNIT_FIELD_BATTLE_PET_COMPANION_GUID, GetGuidValue(ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID));
         }
 
         // PvP, FFAPvP
@@ -6354,32 +6352,12 @@ void Unit::SendHealSpellLog(HealInfo& healInfo, bool critical /*= false*/)
 
     spellHealLog.TargetGUID = healInfo.GetTarget()->GetGUID();
     spellHealLog.CasterGUID = healInfo.GetHealer()->GetGUID();
-
     spellHealLog.SpellID = healInfo.GetSpellInfo()->Id;
     spellHealLog.Health = healInfo.GetHeal();
+    spellHealLog.OriginalHeal = healInfo.GetOriginalHeal();
     spellHealLog.OverHeal = int32(healInfo.GetHeal()) - healInfo.GetEffectiveHeal();
     spellHealLog.Absorbed = healInfo.GetAbsorb();
-
     spellHealLog.Crit = critical;
-
-    /// @todo: 6.x Has to be implemented
-    /*
-    packet.ReadBit("Multistrike");
-
-    var hasCritRollMade = packet.ReadBit("HasCritRollMade");
-    var hasCritRollNeeded = packet.ReadBit("HasCritRollNeeded");
-    var hasLogData = packet.ReadBit("HasLogData");
-
-    if (hasCritRollMade)
-        packet.ReadSingle("CritRollMade");
-
-    if (hasCritRollNeeded)
-        packet.ReadSingle("CritRollNeeded");
-
-    if (hasLogData)
-        SpellParsers.ReadSpellCastLogData(packet);
-    */
-
     spellHealLog.LogData.Initialize(healInfo.GetTarget());
     SendCombatLogMessage(&spellHealLog);
 }
@@ -6514,7 +6492,7 @@ float Unit::SpellDamagePctDone(Unit* victim, SpellInfo const* spellProto, Damage
     {
         for (uint32 i = 0; i < MAX_SPELL_SCHOOL; ++i)
             if (spellProto->GetSchoolMask() & (1 << i))
-                maxModDamagePercentSchool = std::max(maxModDamagePercentSchool, GetFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i));
+                maxModDamagePercentSchool = std::max(maxModDamagePercentSchool, GetFloatValue(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i));
     }
     else
         maxModDamagePercentSchool = GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_DAMAGE_PERCENT_DONE, spellProto->GetSchoolMask());
@@ -6654,7 +6632,7 @@ int32 Unit::SpellBaseDamageBonusDone(SpellSchoolMask schoolMask) const
 {
     if (GetTypeId() == TYPEID_PLAYER)
     {
-        float overrideSP = GetFloatValue(PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT);
+        float overrideSP = GetFloatValue(ACTIVE_PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT);
         if (overrideSP > 0.0f)
             return int32(CalculatePct(GetTotalAttackPowerValue(BASE_ATTACK), overrideSP) + 0.5f);
     }
@@ -6734,7 +6712,7 @@ float Unit::GetUnitSpellCriticalChance(Unit* victim, SpellInfo const* spellProto
                 crit_chance = 0.0f;
             // For other schools
             else if (GetTypeId() == TYPEID_PLAYER)
-                crit_chance = GetFloatValue(PLAYER_SPELL_CRIT_PERCENTAGE1);
+                crit_chance = GetFloatValue(ACTIVE_PLAYER_FIELD_SPELL_CRIT_PERCENTAGE1);
             else
                 crit_chance = (float)m_baseSpellCritChance;
             // taken
@@ -6975,7 +6953,7 @@ float Unit::SpellHealingPctDone(Unit* /*victim*/, SpellInfo const* spellProto) c
         return 1.0f;
 
     if (IsPlayer())
-        return GetFloatValue(PLAYER_FIELD_MOD_HEALING_DONE_PCT);
+        return GetFloatValue(ACTIVE_PLAYER_FIELD_MOD_HEALING_DONE_PCT);
 
     float DoneTotalMod = 1.0f;
 
@@ -7074,7 +7052,7 @@ int32 Unit::SpellBaseHealingBonusDone(SpellSchoolMask schoolMask) const
 {
     if (GetTypeId() == TYPEID_PLAYER)
     {
-        float overrideSP = GetFloatValue(PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT);
+        float overrideSP = GetFloatValue(ACTIVE_PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT);
         if (overrideSP > 0.0f)
             return int32(CalculatePct(GetTotalAttackPowerValue(BASE_ATTACK), overrideSP) + 0.5f);
     }
@@ -7346,7 +7324,7 @@ uint32 Unit::MeleeDamageBonusDone(Unit* victim, uint32 pdamage, WeaponAttackType
             {
                 for (uint32 i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
                     if (spellProto->GetSchoolMask() & (1 << i))
-                        maxModDamagePercentSchool = std::max(maxModDamagePercentSchool, GetFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i));
+                        maxModDamagePercentSchool = std::max(maxModDamagePercentSchool, GetFloatValue(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i));
             }
             else
                 maxModDamagePercentSchool = GetTotalAuraMultiplierByMiscMask(SPELL_AURA_MOD_DAMAGE_PERCENT_DONE, spellProto->GetSchoolMask());
@@ -9337,6 +9315,19 @@ Stats Unit::GetStatByAuraGroup(UnitMods unitMod) const
     return stat;
 }
 
+void Unit::UpdateResistances(uint32 school)
+{
+    if (school > SPELL_SCHOOL_NORMAL)
+    {
+        UnitMods unitMod = UnitMods(UNIT_MOD_RESISTANCE_START + school);
+
+        SetResistance(SpellSchools(school), int32(m_auraModifiersGroup[unitMod][BASE_VALUE]));
+        SetBonusResistanceMod(SpellSchools(school), int32(GetTotalAuraModValue(unitMod) - GetResistance(SpellSchools(school))));
+    }
+    else
+        UpdateArmor();
+}
+
 float Unit::GetTotalAttackPowerValue(WeaponAttackType attType) const
 {
     if (attType == RANGED_ATTACK)
@@ -10340,9 +10331,11 @@ bool Unit::IsPolymorphed() const
     return spellInfo->GetSpellSpecific() == SPELL_SPECIFIC_MAGE_POLYMORPH;
 }
 
-void Unit::SetDisplayId(uint32 modelId)
+void Unit::SetDisplayId(uint32 modelId, float displayScale /*= 1.f*/)
 {
     SetUInt32Value(UNIT_FIELD_DISPLAYID, modelId);
+    SetFloatValue(UNIT_FIELD_DISPLAY_SCALE, displayScale);
+
     // Set Gender by modelId
     if (CreatureModelInfo const* minfo = sObjectMgr->GetCreatureModelInfo(modelId))
         SetByteValue(UNIT_FIELD_BYTES_0, UNIT_BYTES_0_OFFSET_GENDER, minfo->gender);
@@ -10365,7 +10358,7 @@ void Unit::RestoreDisplayId(bool ignorePositiveAurasPreventingMounting /*= false
                     if (!ignorePositiveAurasPreventingMounting)
                         handledAura = (*i);
                     else if (CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate((*i)->GetMiscValue()))
-                        if (!IsDisallowedMountForm((*i)->GetId(), FORM_NONE, sObjectMgr->ChooseDisplayId(ci)))
+                        if (!IsDisallowedMountForm((*i)->GetId(), FORM_NONE, ObjectMgr::ChooseDisplayId(ci)->CreatureDisplayID))
                             handledAura = (*i);
                 }
                 // prefer negative auras
@@ -11686,7 +11679,7 @@ bool Unit::CreateVehicleKit(uint32 id, uint32 creatureEntry, bool loading /*= fa
         return false;
 
     m_vehicleKit = new Vehicle(this, vehInfo, creatureEntry);
-    m_updateFlag |= UPDATEFLAG_VEHICLE;
+    m_updateFlag.Vehicle = true;
     m_unitTypeMask |= UNIT_MASK_VEHICLE;
 
     if (!loading)
@@ -11708,7 +11701,7 @@ void Unit::RemoveVehicleKit(bool onRemoveFromWorld /*= false*/)
 
     m_vehicleKit = NULL;
 
-    m_updateFlag &= ~UPDATEFLAG_VEHICLE;
+    m_updateFlag.Vehicle = false;
     m_unitTypeMask &= ~UNIT_MASK_VEHICLE;
     RemoveFlag64(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK | UNIT_NPC_FLAG_PLAYER_VEHICLE);
 }
@@ -13121,15 +13114,17 @@ void Unit::SendClearTarget()
     SendMessageToSet(breakTarget.Write(), false);
 }
 
-uint32 Unit::GetResistance(SpellSchoolMask mask) const
+int32 Unit::GetResistance(SpellSchoolMask mask) const
 {
-    int32 resist = -1;
+    Optional<int32> resist;
     for (int i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
-        if (mask & (1 << i) && (resist < 0 || resist > int32(GetResistance(SpellSchools(i)))))
-            resist = int32(GetResistance(SpellSchools(i)));
+    {
+        int32 schoolResistance = GetResistance(SpellSchools(i)) + GetBonusResistanceMod(SpellSchools(i));
+        if (mask & (1 << i) && (!resist || *resist > schoolResistance))
+            resist = schoolResistance;
+    }
 
-    // resist value will never be negative here
-    return uint32(resist);
+    return resist ? *resist : 0;
 }
 
 void CharmInfo::SetIsCommandAttack(bool val)
@@ -13673,7 +13668,7 @@ void Unit::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target)
     if (target == this)
         visibleFlag |= UF_FLAG_PRIVATE;
     else if (GetTypeId() == TYPEID_PLAYER)
-        valCount = PLAYER_FIELD_END_NOT_SELF;
+        valCount = PLAYER_END;
 
     std::size_t blockCount = UpdateMask::GetBlockCount(valCount);
 
@@ -13721,8 +13716,6 @@ void Unit::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target)
             // FIXME: Some values at server stored in float format but must be sent to client in uint32 format
             // there are some float values which may be negative or can't get negative due to other checks
             else if ((index >= UNIT_FIELD_NEGSTAT && index < UNIT_FIELD_NEGSTAT + MAX_STATS) ||
-                (index >= UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE  && index < (UNIT_FIELD_RESISTANCEBUFFMODSPOSITIVE + MAX_SPELL_SCHOOL)) ||
-                (index >= UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE  && index < (UNIT_FIELD_RESISTANCEBUFFMODSNEGATIVE + MAX_SPELL_SCHOOL)) ||
                 (index >= UNIT_FIELD_POSSTAT && index < UNIT_FIELD_POSSTAT + MAX_STATS))
             {
                 *data << uint32(m_floatValues[index]);
@@ -13756,7 +13749,7 @@ void Unit::BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target)
 
                     if (cinfo->flags_extra & CREATURE_FLAG_EXTRA_TRIGGER)
                         if (target->IsGameMaster())
-                            displayId = cinfo->GetFirstVisibleModel();
+                            displayId = cinfo->GetFirstVisibleModel()->CreatureDisplayID;
                 }
 
                 *data << uint32(displayId);
diff --git a/src/server/game/Entities/Unit/Unit.h b/src/server/game/Entities/Unit/Unit.h
index 74e2ed60f77..ad8ecf37733 100644
--- a/src/server/game/Entities/Unit/Unit.h
+++ b/src/server/game/Entities/Unit/Unit.h
@@ -576,6 +576,7 @@ class TC_GAME_API DamageInfo
         Unit* const m_attacker;
         Unit* const m_victim;
         uint32 m_damage;
+        uint32 const m_originalDamage;
         SpellInfo const* const m_spellInfo;
         SpellSchoolMask const m_schoolMask;
         DamageEffectType const m_damageType;
@@ -601,6 +602,7 @@ class TC_GAME_API DamageInfo
         DamageEffectType GetDamageType() const { return m_damageType; }
         WeaponAttackType GetAttackType() const { return m_attackType; }
         uint32 GetDamage() const { return m_damage; }
+        uint32 GetOriginalDamage() const { return m_originalDamage; }
         uint32 GetAbsorb() const { return m_absorb; }
         uint32 GetResist() const { return m_resist; }
         uint32 GetBlock() const { return m_block; }
@@ -614,6 +616,7 @@ class TC_GAME_API HealInfo
         Unit* const _healer;
         Unit* const _target;
         uint32 _heal;
+        uint32 const _originalHeal;
         uint32 _effectiveHeal;
         uint32 _absorb;
         SpellInfo const* const _spellInfo;
@@ -629,6 +632,7 @@ class TC_GAME_API HealInfo
         Unit* GetHealer() const { return _healer; }
         Unit* GetTarget() const { return _target; }
         uint32 GetHeal() const { return _heal; }
+        uint32 GetOriginalHeal() const { return _originalHeal; }
         uint32 GetEffectiveHeal() const { return _effectiveHeal; }
         uint32 GetAbsorb() const { return _absorb; }
         SpellInfo const* GetSpellInfo() const { return _spellInfo; };
@@ -682,6 +686,7 @@ struct CalcDamageInfo
     Unit  *target;               // Target for damage
     uint32 damageSchoolMask;
     uint32 damage;
+    uint32 originalDamage;
     uint32 absorb;
     uint32 resist;
     uint32 blocked_amount;
@@ -706,6 +711,7 @@ struct TC_GAME_API SpellNonMeleeDamage
     uint32 SpellID;
     uint32 SpellXSpellVisualID;
     uint32 damage;
+    uint32 originalDamage;
     uint32 schoolMask;
     uint32 absorb;
     uint32 resist;
@@ -720,11 +726,12 @@ struct TC_GAME_API SpellNonMeleeDamage
 
 struct SpellPeriodicAuraLogInfo
 {
-    SpellPeriodicAuraLogInfo(AuraEffect const* _auraEff, uint32 _damage, uint32 _overDamage, uint32 _absorb, uint32 _resist, float _multiplier, bool _critical)
-        : auraEff(_auraEff), damage(_damage), overDamage(_overDamage), absorb(_absorb), resist(_resist), multiplier(_multiplier), critical(_critical){ }
+    SpellPeriodicAuraLogInfo(AuraEffect const* _auraEff, uint32 _damage, uint32 _originalDamage, uint32 _overDamage, uint32 _absorb, uint32 _resist, float _multiplier, bool _critical)
+        : auraEff(_auraEff), damage(_damage), originalDamage(_originalDamage), overDamage(_overDamage), absorb(_absorb), resist(_resist), multiplier(_multiplier), critical(_critical){ }
 
     AuraEffect const* auraEff;
     uint32 damage;
+    uint32 originalDamage;
     uint32 overDamage;                                      // overkill/overheal
     uint32 absorb;
     uint32 resist;
@@ -1033,12 +1040,18 @@ class TC_GAME_API Unit : public WorldObject
 
         float GetStat(Stats stat) const { return float(GetUInt32Value(UNIT_FIELD_STAT+stat)); }
         void SetStat(Stats stat, int32 val) { SetStatInt32Value(UNIT_FIELD_STAT+stat, val); }
-        uint32 GetArmor() const { return GetResistance(SPELL_SCHOOL_NORMAL); }
-        void SetArmor(int32 val) { SetResistance(SPELL_SCHOOL_NORMAL, val); }
+        uint32 GetArmor() const { return GetResistance(SPELL_SCHOOL_NORMAL) + GetBonusResistanceMod(SPELL_SCHOOL_NORMAL); }
+        void SetArmor(int32 val, int32 bonusVal)
+        {
+            SetResistance(SPELL_SCHOOL_NORMAL, val);
+            SetBonusResistanceMod(SPELL_SCHOOL_NORMAL, bonusVal);
+        }
 
-        uint32 GetResistance(SpellSchools school) const { return GetUInt32Value(UNIT_FIELD_RESISTANCES+school); }
-        uint32 GetResistance(SpellSchoolMask mask) const;
-        void SetResistance(SpellSchools school, int32 val) { SetStatInt32Value(UNIT_FIELD_RESISTANCES+school, val); }
+        int32 GetResistance(SpellSchools school) const { return GetUInt32Value(UNIT_FIELD_RESISTANCES + school); }
+        int32 GetBonusResistanceMod(SpellSchools school) const { return GetUInt32Value(UNIT_FIELD_BONUS_RESISTANCE_MODS + school); }
+        int32 GetResistance(SpellSchoolMask mask) const;
+        void SetResistance(SpellSchools school, int32 val) { SetStatInt32Value(UNIT_FIELD_RESISTANCES + school, val); }
+        void SetBonusResistanceMod(SpellSchools school, int32 val) { SetStatInt32Value(UNIT_FIELD_BONUS_RESISTANCE_MODS + school, val); }
 
         uint64 GetHealth()    const { return GetUInt64Value(UNIT_FIELD_HEALTH); }
         uint64 GetMaxHealth() const { return GetUInt64Value(UNIT_FIELD_MAXHEALTH); }
@@ -1533,10 +1546,6 @@ class TC_GAME_API Unit : public WorldObject
         int32 GetMaxPositiveAuraModifierByAffectMask(AuraType auratype, SpellInfo const* affectedSpell) const;
         int32 GetMaxNegativeAuraModifierByAffectMask(AuraType auratype, SpellInfo const* affectedSpell) const;
 
-        float GetResistanceBuffMods(SpellSchools school, bool positive) const;
-        void SetResistanceBuffMods(SpellSchools school, bool positive, float val);
-        void ApplyResistanceBuffModsMod(SpellSchools school, bool positive, float val, bool apply);
-        void ApplyResistanceBuffModsPercentMod(SpellSchools school, bool positive, float val, bool apply);
         void InitStatBuffMods();
         void ApplyStatBuffMod(Stats stat, float val, bool apply);
         void ApplyStatPercentBuffMod(Stats stat, float val, bool apply);
@@ -1620,7 +1629,7 @@ class TC_GAME_API Unit : public WorldObject
         void SetCanModifyStats(bool modifyStats) { m_canModifyStats = modifyStats; }
         virtual bool UpdateStats(Stats stat) = 0;
         virtual bool UpdateAllStats() = 0;
-        virtual void UpdateResistances(uint32 school) = 0;
+        virtual void UpdateResistances(uint32 school);
         virtual void UpdateAllResistances();
         virtual void UpdateArmor() = 0;
         virtual void UpdateMaxHealth() = 0;
@@ -1675,10 +1684,11 @@ class TC_GAME_API Unit : public WorldObject
         void UpdateInterruptMask();
 
         uint32 GetDisplayId() const { return GetUInt32Value(UNIT_FIELD_DISPLAYID); }
-        virtual void SetDisplayId(uint32 modelId);
+        virtual void SetDisplayId(uint32 modelId, float displayScale = 1.f);
         uint32 GetNativeDisplayId() const { return GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID); }
+        float GetNativeDisplayScale() const { return GetFloatValue(UNIT_FIELD_NATIVE_X_DISPLAY_SCALE); }
         void RestoreDisplayId(bool ignorePositiveAurasPreventingMounting = false);
-        void SetNativeDisplayId(uint32 modelId) { SetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID, modelId); }
+        void SetNativeDisplayId(uint32 displayId, float displayScale = 1.f) { SetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID, displayId); SetFloatValue(UNIT_FIELD_NATIVE_X_DISPLAY_SCALE, displayScale); }
         void setTransForm(uint32 spellid) { m_transform = spellid;}
         uint32 getTransForm() const { return m_transform;}
 
diff --git a/src/server/game/Globals/AreaTriggerDataStore.cpp b/src/server/game/Globals/AreaTriggerDataStore.cpp
index 903525c90f5..ecbaac165a6 100644
--- a/src/server/game/Globals/AreaTriggerDataStore.cpp
+++ b/src/server/game/Globals/AreaTriggerDataStore.cpp
@@ -147,8 +147,8 @@ void AreaTriggerDataStore::LoadAreaTriggerTemplates()
         while (templates->NextRow());
     }
 
-    //                                                                  0            1              2            3             4             5              6                  7             8
-    if (QueryResult areatriggerSpellMiscs = WorldDatabase.Query("SELECT SpellMiscId, AreaTriggerId, MoveCurveId, ScaleCurveId, MorphCurveId, FacingCurveId, DecalPropertiesId, TimeToTarget, TimeToTargetScale FROM `spell_areatrigger`"))
+    //                                                                  0            1              2            3             4             5              6       7          8                  9             10
+    if (QueryResult areatriggerSpellMiscs = WorldDatabase.Query("SELECT SpellMiscId, AreaTriggerId, MoveCurveId, ScaleCurveId, MorphCurveId, FacingCurveId, AnimId, AnimKitId, DecalPropertiesId, TimeToTarget, TimeToTargetScale FROM `spell_areatrigger`"))
     {
         do
         {
@@ -182,10 +182,13 @@ void AreaTriggerDataStore::LoadAreaTriggerTemplates()
 
 #undef VALIDATE_AND_SET_CURVE
 
-            miscTemplate.DecalPropertiesId = areatriggerSpellMiscFields[6].GetUInt32();
+            miscTemplate.AnimId = areatriggerSpellMiscFields[6].GetInt32();
+            miscTemplate.AnimKitId = areatriggerSpellMiscFields[7].GetInt32();
 
-            miscTemplate.TimeToTarget       = areatriggerSpellMiscFields[7].GetUInt32();
-            miscTemplate.TimeToTargetScale  = areatriggerSpellMiscFields[8].GetUInt32();
+            miscTemplate.DecalPropertiesId = areatriggerSpellMiscFields[8].GetUInt32();
+
+            miscTemplate.TimeToTarget       = areatriggerSpellMiscFields[9].GetUInt32();
+            miscTemplate.TimeToTargetScale  = areatriggerSpellMiscFields[10].GetUInt32();
 
             miscTemplate.SplinePoints = std::move(splinesBySpellMisc[miscTemplate.MiscId]);
 
diff --git a/src/server/game/Globals/ConversationDataStore.cpp b/src/server/game/Globals/ConversationDataStore.cpp
index af2a416e000..9d57f6d0a17 100644
--- a/src/server/game/Globals/ConversationDataStore.cpp
+++ b/src/server/game/Globals/ConversationDataStore.cpp
@@ -150,7 +150,7 @@ void ConversationDataStore::LoadConversationTemplates()
         TC_LOG_INFO("server.loading", ">> Loaded 0 Conversation actors. DB table `conversation_actors` is empty.");
     }
 
-    if (QueryResult templates = WorldDatabase.Query("SELECT Id, FirstLineId, LastLineEndTime, ScriptName FROM conversation_template"))
+    if (QueryResult templates = WorldDatabase.Query("SELECT Id, FirstLineId, LastLineEndTime, TextureKitId, ScriptName FROM conversation_template"))
     {
         uint32 oldMSTime = getMSTime();
 
@@ -162,7 +162,8 @@ void ConversationDataStore::LoadConversationTemplates()
             conversationTemplate.Id                 = fields[0].GetUInt32();
             conversationTemplate.FirstLineId        = fields[1].GetUInt32();
             conversationTemplate.LastLineEndTime    = fields[2].GetUInt32();
-            conversationTemplate.ScriptId           = sObjectMgr->GetScriptId(fields[3].GetString());
+            conversationTemplate.TextureKitId       = fields[3].GetUInt32();
+            conversationTemplate.ScriptId           = sObjectMgr->GetScriptId(fields[4].GetString());
 
             conversationTemplate.Actors = std::move(actorsByConversation[conversationTemplate.Id]);
             conversationTemplate.ActorGuids = std::move(actorGuidsByConversation[conversationTemplate.Id]);
@@ -184,7 +185,7 @@ void ConversationDataStore::LoadConversationTemplates()
                 currentConversationLine = sConversationLineStore.AssertEntry(currentConversationLine->NextConversationLineID);
             }
 
-            _conversationTemplateStore[conversationTemplate.Id] = conversationTemplate;
+            _conversationTemplateStore[conversationTemplate.Id] = std::move(conversationTemplate);
         }
         while (templates->NextRow());
 
diff --git a/src/server/game/Globals/ConversationDataStore.h b/src/server/game/Globals/ConversationDataStore.h
index e6e750455d5..d4d53a2cd7d 100644
--- a/src/server/game/Globals/ConversationDataStore.h
+++ b/src/server/game/Globals/ConversationDataStore.h
@@ -28,7 +28,6 @@ enum ConversationLineFlags
     CONVERSATION_LINE_FLAG_NOTIFY_STARTED = 0x1 // Client will send CMSG_CONVERSATION_LINE_STARTED when it runs this line
 };
 
-#pragma pack(push, 1)
 struct ConversationActorTemplate
 {
     uint32 Id;
@@ -36,6 +35,7 @@ struct ConversationActorTemplate
     uint32 CreatureModelId;
 };
 
+#pragma pack(push, 1)
 struct ConversationLineTemplate
 {
     uint32 Id;          // Link to ConversationLine.db2
@@ -52,6 +52,7 @@ struct ConversationTemplate
     uint32 Id;
     uint32 FirstLineId;     // Link to ConversationLine.db2
     uint32 LastLineEndTime; // Time in ms after conversation creation the last line fades out
+    uint32 TextureKitId;    // Background texture
 
     std::vector<ConversationActorTemplate const*> Actors;
     std::vector<ObjectGuid::LowType> ActorGuids;
diff --git a/src/server/game/Globals/ObjectMgr.cpp b/src/server/game/Globals/ObjectMgr.cpp
index 2dd2753cde3..d0b70bf3d8a 100644
--- a/src/server/game/Globals/ObjectMgr.cpp
+++ b/src/server/game/Globals/ObjectMgr.cpp
@@ -54,6 +54,7 @@
 #include "VMapFactory.h"
 #include "World.h"
 #include <G3D/g3dmath.h>
+#include <numeric>
 
 ScriptMapMap sSpellScripts;
 ScriptMapMap sEventScripts;
@@ -171,30 +172,37 @@ ExtendedPlayerName ExtractExtendedPlayerName(std::string const& name)
 
 LanguageDesc lang_description[LANGUAGES_COUNT] =
 {
-    { LANG_ADDON,           0, 0                       },
-    { LANG_UNIVERSAL,       0, 0                       },
-    { LANG_ORCISH,        669, SKILL_LANG_ORCISH       },
-    { LANG_DARNASSIAN,    671, SKILL_LANG_DARNASSIAN   },
-    { LANG_TAURAHE,       670, SKILL_LANG_TAURAHE      },
-    { LANG_DWARVISH,      672, SKILL_LANG_DWARVEN      },
-    { LANG_COMMON,        668, SKILL_LANG_COMMON       },
-    { LANG_DEMONIC,       815, SKILL_LANG_DEMON_TONGUE },
-    { LANG_TITAN,         816, SKILL_LANG_TITAN        },
-    { LANG_THALASSIAN,    813, SKILL_LANG_THALASSIAN   },
-    { LANG_DRACONIC,      814, SKILL_LANG_DRACONIC     },
-    { LANG_KALIMAG,       817, SKILL_LANG_OLD_TONGUE   },
-    { LANG_GNOMISH,      7340, SKILL_LANG_GNOMISH      },
-    { LANG_TROLL,        7341, SKILL_LANG_TROLL        },
-    { LANG_GUTTERSPEAK, 17737, SKILL_LANG_FORSAKEN     },
-    { LANG_DRAENEI,     29932, SKILL_LANG_DRAENEI      },
-    { LANG_ZOMBIE,          0, 0                       },
-    { LANG_GNOMISH_BINARY,  0, 0                       },
-    { LANG_GOBLIN_BINARY,   0, 0                       },
-    { LANG_WORGEN,      69270, SKILL_LANG_GILNEAN      },
-    { LANG_GOBLIN,      69269, SKILL_LANG_GOBLIN       },
-    { LANG_PANDAREN_NEUTRAL,  108127, SKILL_LANG_PANDAREN_NEUTRAL  },
-    { LANG_PANDAREN_ALLIANCE, 108130, SKILL_LANG_PANDAREN_ALLIANCE },
-    { LANG_PANDAREN_HORDE,    108131, SKILL_LANG_PANDAREN_HORDE    }
+    { LANG_ADDON,                  0, 0                               },
+    { LANG_ADDON_LOGGED,           0, 0                               },
+    { LANG_UNIVERSAL,              0, 0                               },
+    { LANG_ORCISH,               669, SKILL_LANGUAGE_ORCISH           },
+    { LANG_DARNASSIAN,           671, SKILL_LANGUAGE_DARNASSIAN       },
+    { LANG_TAURAHE,              670, SKILL_LANGUAGE_TAURAHE          },
+    { LANG_DWARVISH,             672, SKILL_LANGUAGE_DWARVEN          },
+    { LANG_COMMON,               668, SKILL_LANGUAGE_COMMON           },
+    { LANG_DEMONIC,              815, SKILL_LANGUAGE_DEMON_TONGUE     },
+    { LANG_TITAN,                816, SKILL_LANGUAGE_TITAN            },
+    { LANG_THALASSIAN,           813, SKILL_LANGUAGE_THALASSIAN       },
+    { LANG_DRACONIC,             814, SKILL_LANGUAGE_DRACONIC         },
+    { LANG_KALIMAG,           265462, SKILL_LANGUAGE_OLD_TONGUE       },
+    { LANG_GNOMISH,             7340, SKILL_LANGUAGE_GNOMISH          },
+    { LANG_TROLL,               7341, SKILL_LANGUAGE_TROLL            },
+    { LANG_GUTTERSPEAK,        17737, SKILL_LANGUAGE_FORSAKEN         },
+    { LANG_DRAENEI,            29932, SKILL_LANGUAGE_DRAENEI          },
+    { LANG_ZOMBIE,            265467, 0                               },
+    { LANG_GNOMISH_BINARY,    265460, 0                               },
+    { LANG_GOBLIN_BINARY,     265461, 0                               },
+    { LANG_WORGEN,             69270, SKILL_LANGUAGE_GILNEAN          },
+    { LANG_GOBLIN,             69269, SKILL_LANGUAGE_GOBLIN           },
+    { LANG_PANDAREN_NEUTRAL,  108127, SKILL_LANGUAGE_PANDAREN_NEUTRAL },
+    { LANG_PANDAREN_ALLIANCE, 108130, 0                               },
+    { LANG_PANDAREN_HORDE,    108131, 0                               },
+    { LANG_SPRITE,            265466, 0                               },
+    { LANG_SHATH_YAR,         265465, 0                               },
+    { LANG_NERGLISH,          265464, 0                               },
+    { LANG_MOONKIN,           265463, 0                               },
+    { LANG_SHALASSIAN,        262439, SKILL_LANGUAGE_SHALASSIAN       },
+    { LANG_THALASSIAN_2,      262454, SKILL_LANGUAGE_THALASSIAN_2     }
 };
 
 LanguageDesc const* GetLanguageDescByID(uint32 lang)
@@ -404,21 +412,21 @@ void ObjectMgr::LoadCreatureTemplates()
 {
     uint32 oldMSTime = getMSTime();
 
-    //                                               0      1                   2                   3                   4            5            6         7         8
-    QueryResult result = WorldDatabase.Query("SELECT entry, difficulty_entry_1, difficulty_entry_2, difficulty_entry_3, KillCredit1, KillCredit2, modelid1, modelid2, modelid3, "
-    //                                        9         10    11          12       13        14        15              16        17        18                      19                 20
-                                             "modelid4, name, femaleName, subname, TitleAlt, IconName, gossip_menu_id, minlevel, maxlevel, HealthScalingExpansion, RequiredExpansion, VignetteID, "
-    //                                        21       22       23          24         25     26    27         28              29               30            31
+    //                                               0      1                   2                   3                   4            5            6     7           8
+    QueryResult result = WorldDatabase.Query("SELECT entry, difficulty_entry_1, difficulty_entry_2, difficulty_entry_3, KillCredit1, KillCredit2, name, femaleName, subname, "
+    //                                        9         10        11              12        13        14                      15                 16
+                                             "TitleAlt, IconName, gossip_menu_id, minlevel, maxlevel, HealthScalingExpansion, RequiredExpansion, VignetteID, "
+    //                                        17       18       19          20         21     22    23         24              25               26            27
                                              "faction, npcflag, speed_walk, speed_run, scale, rank, dmgschool, BaseAttackTime, RangeAttackTime, BaseVariance, RangeVariance, "
-    //                                        32          33          34           35           36            37      38             39
+    //                                        28          29          30           31           32            33      34             35
                                              "unit_class, unit_flags, unit_flags2, unit_flags3, dynamicflags, family, trainer_class, type, "
-    //                                        40          41           42      43              44        45           46           47           48           49           50
+    //                                        36          37           38      39              40        41           42           43           44           45           46
                                              "type_flags, type_flags2, lootid, pickpocketloot, skinloot, resistance1, resistance2, resistance3, resistance4, resistance5, resistance6, "
-    //                                        51      52      53      54      55      56      57      58      59         60       61       62      63
+    //                                        47      48      49      50      51      52      53      54      55         56       57       58      59
                                              "spell1, spell2, spell3, spell4, spell5, spell6, spell7, spell8, VehicleId, mingold, maxgold, AIName, MovementType, "
-    //                                        64           65           66              67                   68            69                 70             71              72
+    //                                        60           61           62              63                   64            65                 66             67              68
                                              "InhabitType, HoverHeight, HealthModifier, HealthModifierExtra, ManaModifier, ManaModifierExtra, ArmorModifier, DamageModifier, ExperienceModifier, "
-    //                                        73            74          75           76                    77           78
+    //                                        69            70          71           72                    73           74
                                              "RacialLeader, movementId, RegenHealth, mechanic_immune_mask, flags_extra, ScriptName FROM creature_template");
 
     if (!result)
@@ -435,6 +443,9 @@ void ObjectMgr::LoadCreatureTemplates()
     }
     while (result->NextRow());
 
+    // We load the creature models after loading but before checking
+    LoadCreatureTemplateModels();
+
     // Checking needs to be done after loading because of the difficulty self referencing
     for (CreatureTemplateContainer::const_iterator itr = _creatureTemplateStore.begin(); itr != _creatureTemplateStore.end(); ++itr)
         CheckCreatureTemplate(&itr->second);
@@ -456,72 +467,121 @@ void ObjectMgr::LoadCreatureTemplate(Field* fields)
     for (uint8 i = 0; i < MAX_KILL_CREDIT; ++i)
         creatureTemplate.KillCredit[i]      = fields[4 + i].GetUInt32();
 
-    creatureTemplate.Modelid1               = fields[6].GetUInt32();
-    creatureTemplate.Modelid2               = fields[7].GetUInt32();
-    creatureTemplate.Modelid3               = fields[8].GetUInt32();
-    creatureTemplate.Modelid4               = fields[9].GetUInt32();
-    creatureTemplate.Name                   = fields[10].GetString();
-    creatureTemplate.FemaleName             = fields[11].GetString();
-    creatureTemplate.SubName                = fields[12].GetString();
-    creatureTemplate.TitleAlt               = fields[13].GetString();
-    creatureTemplate.IconName               = fields[14].GetString();
-    creatureTemplate.GossipMenuId           = fields[15].GetUInt32();
-    creatureTemplate.minlevel               = fields[16].GetInt16();
-    creatureTemplate.maxlevel               = fields[17].GetInt16();
-    creatureTemplate.HealthScalingExpansion = fields[18].GetInt32();
-    creatureTemplate.RequiredExpansion      = fields[19].GetUInt32();
-    creatureTemplate.VignetteID             = fields[20].GetUInt32();
-    creatureTemplate.faction                = fields[21].GetUInt16();
-    creatureTemplate.npcflag                = fields[22].GetUInt64();
-    creatureTemplate.speed_walk             = fields[23].GetFloat();
-    creatureTemplate.speed_run              = fields[24].GetFloat();
-    creatureTemplate.scale                  = fields[25].GetFloat();
-    creatureTemplate.rank                   = uint32(fields[26].GetUInt8());
-    creatureTemplate.dmgschool              = uint32(fields[27].GetInt8());
-    creatureTemplate.BaseAttackTime         = fields[28].GetUInt32();
-    creatureTemplate.RangeAttackTime        = fields[29].GetUInt32();
-    creatureTemplate.BaseVariance           = fields[30].GetFloat();
-    creatureTemplate.RangeVariance          = fields[31].GetFloat();
-    creatureTemplate.unit_class             = uint32(fields[32].GetUInt8());
-    creatureTemplate.unit_flags             = fields[33].GetUInt32();
-    creatureTemplate.unit_flags2            = fields[34].GetUInt32();
-    creatureTemplate.unit_flags3            = fields[35].GetUInt32();
-    creatureTemplate.dynamicflags           = fields[36].GetUInt32();
-    creatureTemplate.family                 = CreatureFamily(fields[37].GetUInt8());
-    creatureTemplate.trainer_class          = uint32(fields[38].GetUInt8());
-    creatureTemplate.type                   = uint32(fields[39].GetUInt8());
-    creatureTemplate.type_flags             = fields[40].GetUInt32();
-    creatureTemplate.type_flags2            = fields[41].GetUInt32();
-    creatureTemplate.lootid                 = fields[42].GetUInt32();
-    creatureTemplate.pickpocketLootId       = fields[43].GetUInt32();
-    creatureTemplate.SkinLootId             = fields[44].GetUInt32();
+    creatureTemplate.Name                   = fields[6].GetString();
+    creatureTemplate.FemaleName             = fields[7].GetString();
+    creatureTemplate.SubName                = fields[8].GetString();
+    creatureTemplate.TitleAlt               = fields[9].GetString();
+    creatureTemplate.IconName               = fields[10].GetString();
+    creatureTemplate.GossipMenuId           = fields[11].GetUInt32();
+    creatureTemplate.minlevel               = fields[12].GetInt16();
+    creatureTemplate.maxlevel               = fields[13].GetInt16();
+    creatureTemplate.HealthScalingExpansion = fields[14].GetInt32();
+    creatureTemplate.RequiredExpansion      = fields[15].GetUInt32();
+    creatureTemplate.VignetteID             = fields[16].GetUInt32();
+    creatureTemplate.faction                = fields[17].GetUInt16();
+    creatureTemplate.npcflag                = fields[18].GetUInt64();
+    creatureTemplate.speed_walk             = fields[19].GetFloat();
+    creatureTemplate.speed_run              = fields[20].GetFloat();
+    creatureTemplate.scale                  = fields[21].GetFloat();
+    creatureTemplate.rank                   = uint32(fields[22].GetUInt8());
+    creatureTemplate.dmgschool              = uint32(fields[23].GetInt8());
+    creatureTemplate.BaseAttackTime         = fields[24].GetUInt32();
+    creatureTemplate.RangeAttackTime        = fields[25].GetUInt32();
+    creatureTemplate.BaseVariance           = fields[26].GetFloat();
+    creatureTemplate.RangeVariance          = fields[27].GetFloat();
+    creatureTemplate.unit_class             = uint32(fields[28].GetUInt8());
+    creatureTemplate.unit_flags             = fields[29].GetUInt32();
+    creatureTemplate.unit_flags2            = fields[30].GetUInt32();
+    creatureTemplate.unit_flags3            = fields[31].GetUInt32();
+    creatureTemplate.dynamicflags           = fields[32].GetUInt32();
+    creatureTemplate.family                 = CreatureFamily(fields[33].GetUInt8());
+    creatureTemplate.trainer_class          = uint32(fields[34].GetUInt8());
+    creatureTemplate.type                   = uint32(fields[35].GetUInt8());
+    creatureTemplate.type_flags             = fields[36].GetUInt32();
+    creatureTemplate.type_flags2            = fields[37].GetUInt32();
+    creatureTemplate.lootid                 = fields[38].GetUInt32();
+    creatureTemplate.pickpocketLootId       = fields[39].GetUInt32();
+    creatureTemplate.SkinLootId             = fields[40].GetUInt32();
 
     for (uint8 i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
-        creatureTemplate.resistance[i]      = fields[45 + i - 1].GetInt16();
+        creatureTemplate.resistance[i]      = fields[41 + i - 1].GetInt16();
 
     for (uint8 i = 0; i < MAX_CREATURE_SPELLS; ++i)
-        creatureTemplate.spells[i]          = fields[51 + i].GetUInt32();
-
-    creatureTemplate.VehicleId              = fields[59].GetUInt32();
-    creatureTemplate.mingold                = fields[60].GetUInt32();
-    creatureTemplate.maxgold                = fields[61].GetUInt32();
-    creatureTemplate.AIName                 = fields[62].GetString();
-    creatureTemplate.MovementType           = uint32(fields[63].GetUInt8());
-    creatureTemplate.InhabitType            = uint32(fields[64].GetUInt8());
-    creatureTemplate.HoverHeight            = fields[65].GetFloat();
-    creatureTemplate.ModHealth              = fields[66].GetFloat();
-    creatureTemplate.ModHealthExtra         = fields[67].GetFloat();
-    creatureTemplate.ModMana                = fields[68].GetFloat();
-    creatureTemplate.ModManaExtra           = fields[69].GetFloat();
-    creatureTemplate.ModArmor               = fields[70].GetFloat();
-    creatureTemplate.ModDamage              = fields[71].GetFloat();
-    creatureTemplate.ModExperience          = fields[72].GetFloat();
-    creatureTemplate.RacialLeader           = fields[73].GetBool();
-    creatureTemplate.movementId             = fields[74].GetUInt32();
-    creatureTemplate.RegenHealth            = fields[75].GetBool();
-    creatureTemplate.MechanicImmuneMask     = fields[76].GetUInt32();
-    creatureTemplate.flags_extra            = fields[77].GetUInt32();
-    creatureTemplate.ScriptID               = GetScriptId(fields[78].GetString());
+        creatureTemplate.spells[i]          = fields[47 + i].GetUInt32();
+
+    creatureTemplate.VehicleId              = fields[55].GetUInt32();
+    creatureTemplate.mingold                = fields[56].GetUInt32();
+    creatureTemplate.maxgold                = fields[57].GetUInt32();
+    creatureTemplate.AIName                 = fields[58].GetString();
+    creatureTemplate.MovementType           = uint32(fields[59].GetUInt8());
+    creatureTemplate.InhabitType            = uint32(fields[60].GetUInt8());
+    creatureTemplate.HoverHeight            = fields[61].GetFloat();
+    creatureTemplate.ModHealth              = fields[62].GetFloat();
+    creatureTemplate.ModHealthExtra         = fields[63].GetFloat();
+    creatureTemplate.ModMana                = fields[64].GetFloat();
+    creatureTemplate.ModManaExtra           = fields[65].GetFloat();
+    creatureTemplate.ModArmor               = fields[66].GetFloat();
+    creatureTemplate.ModDamage              = fields[67].GetFloat();
+    creatureTemplate.ModExperience          = fields[68].GetFloat();
+    creatureTemplate.RacialLeader           = fields[69].GetBool();
+    creatureTemplate.movementId             = fields[70].GetUInt32();
+    creatureTemplate.RegenHealth            = fields[71].GetBool();
+    creatureTemplate.MechanicImmuneMask     = fields[72].GetUInt32();
+    creatureTemplate.flags_extra            = fields[73].GetUInt32();
+    creatureTemplate.ScriptID               = GetScriptId(fields[74].GetString());
+}
+
+void ObjectMgr::LoadCreatureTemplateModels()
+{
+    uint32 oldMSTime = getMSTime();
+
+    //                                               0           1                  2             3
+    QueryResult result = WorldDatabase.Query("SELECT CreatureID, CreatureDisplayID, DisplayScale, Probability FROM creature_template_model ORDER BY Idx ASC");
+
+    if (!result)
+    {
+        TC_LOG_INFO("server.loading", ">> Loaded 0 creature template model definitions. DB table `creature_template_model` is empty.");
+        return;
+    }
+
+    uint32 count = 0;
+    do
+    {
+        Field* fields = result->Fetch();
+
+        uint32 creatureId = fields[0].GetUInt32();
+        uint32 creatureDisplayId = fields[1].GetUInt32();
+        float displayScale = fields[2].GetFloat();
+        float probability = fields[3].GetFloat();
+
+        CreatureTemplate const* cInfo = GetCreatureTemplate(creatureId);
+        if (!cInfo)
+        {
+            TC_LOG_ERROR("sql.sql", "Creature template (Entry: %u) does not exist but has a record in `creature_template_model`", creatureId);
+            continue;
+        }
+
+        CreatureDisplayInfoEntry const* displayEntry = sCreatureDisplayInfoStore.LookupEntry(creatureDisplayId);
+        if (!displayEntry)
+        {
+            TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) lists non-existing CreatureDisplayID id (%u), this can crash the client.", creatureId, creatureDisplayId);
+            continue;
+        }
+
+        CreatureModelInfo const* modelInfo = GetCreatureModelInfo(creatureDisplayId);
+        if (!modelInfo)
+            TC_LOG_ERROR("sql.sql", "No model data exist for `CreatureDisplayID` = %u listed by creature (Entry: %u).", creatureDisplayId, creatureId);
+
+        if (displayScale <= 0.0f)
+            displayScale = 1.0f;
+
+        const_cast<CreatureTemplate*>(cInfo)->Models.emplace_back(creatureDisplayId, displayScale, probability);
+
+        ++count;
+    }
+    while (result->NextRow());
+
+    TC_LOG_INFO("server.loading", ">> Loaded %u creature template models in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }
 
 void ObjectMgr::LoadCreatureTemplateAddons()
@@ -860,76 +920,6 @@ void ObjectMgr::CheckCreatureTemplate(CreatureTemplate const* cInfo)
         const_cast<CreatureTemplate*>(cInfo)->faction = sFactionTemplateStore.AssertEntry(35)->ID; // this might seem stupid but all shit will would break if faction 35 did not exist
     }
 
-    // used later for scale
-    CreatureDisplayInfoEntry const* displayScaleEntry = nullptr;
-
-    if (cInfo->Modelid1)
-    {
-        CreatureDisplayInfoEntry const* displayEntry = sCreatureDisplayInfoStore.LookupEntry(cInfo->Modelid1);
-        if (!displayEntry)
-        {
-            TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) lists non-existing Modelid1 id (%u), this can crash the client.", cInfo->Entry, cInfo->Modelid1);
-            const_cast<CreatureTemplate*>(cInfo)->Modelid1 = 0;
-        }
-        else
-            displayScaleEntry = displayEntry;
-
-        CreatureModelInfo const* modelInfo = GetCreatureModelInfo(cInfo->Modelid1);
-        if (!modelInfo)
-            TC_LOG_ERROR("sql.sql", "No model data exist for `Modelid1` = %u listed by creature (Entry: %u).", cInfo->Modelid1, cInfo->Entry);
-    }
-
-    if (cInfo->Modelid2)
-    {
-        CreatureDisplayInfoEntry const* displayEntry = sCreatureDisplayInfoStore.LookupEntry(cInfo->Modelid2);
-        if (!displayEntry)
-        {
-            TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) lists non-existing Modelid2 id (%u), this can crash the client.", cInfo->Entry, cInfo->Modelid2);
-            const_cast<CreatureTemplate*>(cInfo)->Modelid2 = 0;
-        }
-        else if (!displayScaleEntry)
-            displayScaleEntry = displayEntry;
-
-        CreatureModelInfo const* modelInfo = GetCreatureModelInfo(cInfo->Modelid2);
-        if (!modelInfo)
-            TC_LOG_ERROR("sql.sql", "No model data exist for `Modelid2` = %u listed by creature (Entry: %u).", cInfo->Modelid2, cInfo->Entry);
-    }
-
-    if (cInfo->Modelid3)
-    {
-        CreatureDisplayInfoEntry const* displayEntry = sCreatureDisplayInfoStore.LookupEntry(cInfo->Modelid3);
-        if (!displayEntry)
-        {
-            TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) lists non-existing Modelid3 id (%u), this can crash the client.", cInfo->Entry, cInfo->Modelid3);
-            const_cast<CreatureTemplate*>(cInfo)->Modelid3 = 0;
-        }
-        else if (!displayScaleEntry)
-            displayScaleEntry = displayEntry;
-
-        CreatureModelInfo const* modelInfo = GetCreatureModelInfo(cInfo->Modelid3);
-        if (!modelInfo)
-            TC_LOG_ERROR("sql.sql", "No model data exist for `Modelid3` = %u listed by creature (Entry: %u).", cInfo->Modelid3, cInfo->Entry);
-    }
-
-    if (cInfo->Modelid4)
-    {
-        CreatureDisplayInfoEntry const* displayEntry = sCreatureDisplayInfoStore.LookupEntry(cInfo->Modelid4);
-        if (!displayEntry)
-        {
-            TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) lists non-existing Modelid4 id (%u), this can crash the client.", cInfo->Entry, cInfo->Modelid4);
-            const_cast<CreatureTemplate*>(cInfo)->Modelid4 = 0;
-        }
-        else if (!displayScaleEntry)
-            displayScaleEntry = displayEntry;
-
-        CreatureModelInfo const* modelInfo = GetCreatureModelInfo(cInfo->Modelid4);
-        if (!modelInfo)
-            TC_LOG_ERROR("sql.sql", "No model data exist for `Modelid4` = %u listed by creature (Entry: %u).", cInfo->Modelid4, cInfo->Entry);
-    }
-
-    if (!displayScaleEntry)
-        TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) does not have any existing display id in Modelid1/Modelid2/Modelid3/Modelid4.", cInfo->Entry);
-
     for (uint8 k = 0; k < MAX_KILL_CREDIT; ++k)
     {
         if (cInfo->KillCredit[k])
@@ -942,6 +932,11 @@ void ObjectMgr::CheckCreatureTemplate(CreatureTemplate const* cInfo)
         }
     }
 
+    if (!cInfo->Models.size())
+        TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) does not have any existing display id in creature_template_model.", cInfo->Entry);
+    else if (std::accumulate(cInfo->Models.begin(), cInfo->Models.end(), 0.0f, [](float sum, CreatureModel const& model) { return sum + model.Probability; }) <= 0.0f)
+        TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) has zero total chance for all models in creature_template_model.", cInfo->Entry);
+
     if (!cInfo->unit_class || ((1 << (cInfo->unit_class-1)) & CLASSMASK_ALL_CREATURES) == 0)
     {
         TC_LOG_ERROR("sql.sql", "Creature (Entry: %u) has invalid unit_class (%u) in creature_template. Set to 1 (UNIT_CLASS_WARRIOR).", cInfo->Entry, cInfo->unit_class);
@@ -1022,15 +1017,6 @@ void ObjectMgr::CheckCreatureTemplate(CreatureTemplate const* cInfo)
         const_cast<CreatureTemplate*>(cInfo)->MovementType = IDLE_MOTION_TYPE;
     }
 
-    /// if not set custom creature scale then load scale from CreatureDisplayInfo.dbc
-    if (cInfo->scale <= 0.0f)
-    {
-        if (displayScaleEntry)
-            const_cast<CreatureTemplate*>(cInfo)->scale = displayScaleEntry->CreatureModelScale;
-        else
-            const_cast<CreatureTemplate*>(cInfo)->scale = 1.0f;
-    }
-
     if (cInfo->HealthScalingExpansion < EXPANSION_LEVEL_CURRENT || cInfo->HealthScalingExpansion > (MAX_EXPANSIONS - 1))
     {
         TC_LOG_ERROR("sql.sql", "Table `creature_template` lists creature (ID: %u) with invalid `HealthScalingExpansion` %i. Ignored and set to 0.", cInfo->Entry, cInfo->HealthScalingExpansion);
@@ -1402,14 +1388,16 @@ CreatureModelInfo const* ObjectMgr::GetCreatureModelInfo(uint32 modelId) const
     return nullptr;
 }
 
-uint32 ObjectMgr::ChooseDisplayId(CreatureTemplate const* cinfo, CreatureData const* data /*= nullptr*/)
+CreatureModel const* ObjectMgr::ChooseDisplayId(CreatureTemplate const* cinfo, CreatureData const* data /*= nullptr*/)
 {
     // Load creature model (display id)
     if (data && data->displayid)
-        return data->displayid;
+        if (CreatureModel const* model = cinfo->GetModelWithDisplayId(data->displayid))
+            return model;
 
     if (!(cinfo->flags_extra & CREATURE_FLAG_EXTRA_TRIGGER))
-        return cinfo->GetRandomValidModelId();
+        if (CreatureModel const* model = cinfo->GetRandomValidModel())
+            return model;
 
     // Triggers by default receive the invisible model
     return cinfo->GetFirstInvisibleModel();
@@ -1442,9 +1430,9 @@ void ObjectMgr::ChooseCreatureFlags(CreatureTemplate const* cInfo, uint64& npcFl
     }
 }
 
-CreatureModelInfo const* ObjectMgr::GetCreatureModelRandomGender(uint32* displayID) const
+CreatureModelInfo const* ObjectMgr::GetCreatureModelRandomGender(CreatureModel* model, CreatureTemplate const* creatureTemplate) const
 {
-    CreatureModelInfo const* modelInfo = GetCreatureModelInfo(*displayID);
+    CreatureModelInfo const* modelInfo = GetCreatureModelInfo(model->CreatureDisplayID);
     if (!modelInfo)
         return nullptr;
 
@@ -1453,11 +1441,20 @@ CreatureModelInfo const* ObjectMgr::GetCreatureModelRandomGender(uint32* display
     {
         CreatureModelInfo const* minfo_tmp = GetCreatureModelInfo(modelInfo->displayId_other_gender);
         if (!minfo_tmp)
-            TC_LOG_ERROR("sql.sql", "Model (Entry: %u) has modelid_other_gender %u not found in table `creature_model_info`. ", *displayID, modelInfo->displayId_other_gender);
+            TC_LOG_ERROR("sql.sql", "Model (Entry: %u) has modelid_other_gender %u not found in table `creature_model_info`. ", model->CreatureDisplayID, modelInfo->displayId_other_gender);
         else
         {
             // DisplayID changed
-            *displayID = modelInfo->displayId_other_gender;
+            model->CreatureDisplayID = modelInfo->displayId_other_gender;
+            if (creatureTemplate)
+            {
+                auto itr = std::find_if(creatureTemplate->Models.begin(), creatureTemplate->Models.end(), [&](CreatureModel const& templateModel)
+                {
+                    return templateModel.CreatureDisplayID == modelInfo->displayId_other_gender;
+                });
+                if (itr != creatureTemplate->Models.end())
+                    *model = *itr;
+            }
             return minfo_tmp;
         }
     }
@@ -3492,13 +3489,13 @@ void ObjectMgr::LoadPlayerInfo()
             do
             {
                 Field* fields = result->Fetch();
-                uint32 raceMask = fields[0].GetUInt32();
+                uint64 raceMask = fields[0].GetUInt64();
                 uint32 classMask = fields[1].GetUInt32();
                 uint32 spellId = fields[2].GetUInt32();
 
                 if (raceMask != 0 && !(raceMask & RACEMASK_ALL_PLAYABLE))
                 {
-                    TC_LOG_ERROR("sql.sql", "Wrong race mask %u in `playercreateinfo_spell_custom` table, ignoring.", raceMask);
+                    TC_LOG_ERROR("sql.sql", "Wrong race mask " UI64FMTD " in `playercreateinfo_spell_custom` table, ignoring.", raceMask);
                     continue;
                 }
 
@@ -3510,7 +3507,7 @@ void ObjectMgr::LoadPlayerInfo()
 
                 for (uint32 raceIndex = RACE_HUMAN; raceIndex < MAX_RACES; ++raceIndex)
                 {
-                    if (raceMask == 0 || ((1 << (raceIndex - 1)) & raceMask))
+                    if (raceMask == 0 || ((UI64LIT(1) << (raceIndex - 1)) & raceMask))
                     {
                         for (uint32 classIndex = CLASS_WARRIOR; classIndex < MAX_CLASSES; ++classIndex)
                         {
@@ -3552,13 +3549,13 @@ void ObjectMgr::LoadPlayerInfo()
             do
             {
                 Field* fields       = result->Fetch();
-                uint32 raceMask     = fields[0].GetUInt32();
+                uint64 raceMask     = fields[0].GetUInt64();
                 uint32 classMask    = fields[1].GetUInt32();
                 uint32 spellId      = fields[2].GetUInt32();
 
                 if (raceMask != 0 && !(raceMask & RACEMASK_ALL_PLAYABLE))
                 {
-                    TC_LOG_ERROR("sql.sql", "Wrong race mask %u in `playercreateinfo_cast_spell` table, ignoring.", raceMask);
+                    TC_LOG_ERROR("sql.sql", "Wrong race mask " UI64FMTD " in `playercreateinfo_cast_spell` table, ignoring.", raceMask);
                     continue;
                 }
 
@@ -3570,7 +3567,7 @@ void ObjectMgr::LoadPlayerInfo()
 
                 for (uint32 raceIndex = RACE_HUMAN; raceIndex < MAX_RACES; ++raceIndex)
                 {
-                    if (raceMask == 0 || ((1 << (raceIndex - 1)) & raceMask))
+                    if (raceMask == 0 || ((UI64LIT(1) << (raceIndex - 1)) & raceMask))
                     {
                         for (uint32 classIndex = CLASS_WARRIOR; classIndex < MAX_CLASSES; ++classIndex)
                         {
@@ -3924,35 +3921,35 @@ void ObjectMgr::LoadQuests()
     mExclusiveQuestGroups.clear();
 
     QueryResult result = WorldDatabase.Query("SELECT "
-        //0  1          2           3                4               5         6            7            8                  9                10                  11
-        "ID, QuestType, QuestLevel, MaxScalingLevel, QuestPackageID, MinLevel, QuestSortID, QuestInfoID, SuggestedGroupNum, RewardNextQuest, RewardXPDifficulty, RewardXPMultiplier, "
-        //12          13                     14                     15                16                   17                   18                   19           20           21               22
+        //0  1          2           3                    4                5               6         7            8            9                  10               11                  12
+        "ID, QuestType, QuestLevel, ScalingFactionGroup, MaxScalingLevel, QuestPackageID, MinLevel, QuestSortID, QuestInfoID, SuggestedGroupNum, RewardNextQuest, RewardXPDifficulty, RewardXPMultiplier, "
+        //13          14                     15                     16                17                   18                   19                   20           21           22               23
         "RewardMoney, RewardMoneyDifficulty, RewardMoneyMultiplier, RewardBonusMoney, RewardDisplaySpell1, RewardDisplaySpell2, RewardDisplaySpell3, RewardSpell, RewardHonor, RewardKillHonor, StartItem, "
-        //23                         24                          25                        26     27
-        "RewardArtifactXPDifficulty, RewardArtifactXPMultiplier, RewardArtifactCategoryID, Flags, FlagsEx, "
-        //28          29             30         31                 32           33             34         35
+        //24                         25                          26                        27     28       29
+        "RewardArtifactXPDifficulty, RewardArtifactXPMultiplier, RewardArtifactCategoryID, Flags, FlagsEx, FlagsEx2, "
+        //30          31             32           33               34           35             36         37
         "RewardItem1, RewardAmount1, ItemDrop1, ItemDropQuantity1, RewardItem2, RewardAmount2, ItemDrop2, ItemDropQuantity2, "
-        //36          37             38         39                 40             41           42         43
+        //38           39            40         41                42            43             44         45
         "RewardItem3, RewardAmount3, ItemDrop3, ItemDropQuantity3, RewardItem4, RewardAmount4, ItemDrop4, ItemDropQuantity4, "
-        //44                  45                         46                          47                   48                         49
+        //46                  47                         48                          49                   50                         51
         "RewardChoiceItemID1, RewardChoiceItemQuantity1, RewardChoiceItemDisplayID1, RewardChoiceItemID2, RewardChoiceItemQuantity2, RewardChoiceItemDisplayID2, "
-        //50                  51                         52                          53                   54                         55
+        //52                  53                         54                          55                   56                         57
         "RewardChoiceItemID3, RewardChoiceItemQuantity3, RewardChoiceItemDisplayID3, RewardChoiceItemID4, RewardChoiceItemQuantity4, RewardChoiceItemDisplayID4, "
-        //56                  57                         58                          59                   60                         61
+        //58                  59                         60                          61                   62                         63
         "RewardChoiceItemID5, RewardChoiceItemQuantity5, RewardChoiceItemDisplayID5, RewardChoiceItemID6, RewardChoiceItemQuantity6, RewardChoiceItemDisplayID6, "
-        //62           63    64    65           66           67                 68                 69                 70             71
-        "POIContinent, POIx, POIy, POIPriority, RewardTitle, RewardArenaPoints, RewardSkillLineID, RewardNumSkillUps, PortraitGiver, PortraitTurnIn, "
-        //72               73                   74                      75                   76                77                   78                      79
+        //64           65    66    67           68           69                 70                 71                 72             73                  74
+        "POIContinent, POIx, POIy, POIPriority, RewardTitle, RewardArenaPoints, RewardSkillLineID, RewardNumSkillUps, PortraitGiver, PortraitGiverMount, PortraitTurnIn, "
+        //75               76                   77                      78                   79                80                   81                      82
         "RewardFactionID1, RewardFactionValue1, RewardFactionOverride1, RewardFactionCapIn1, RewardFactionID2, RewardFactionValue2, RewardFactionOverride2, RewardFactionCapIn2, "
-        //80               81                   82                      83                   84                85                   86                      87
+        //83               84                   85                      86                   87                88                   89                      90
         "RewardFactionID3, RewardFactionValue3, RewardFactionOverride3, RewardFactionCapIn3, RewardFactionID4, RewardFactionValue4, RewardFactionOverride4, RewardFactionCapIn4, "
-        //88               89                   90                      91                   92
+        //91               92                   93                      94                   95
         "RewardFactionID5, RewardFactionValue5, RewardFactionOverride5, RewardFactionCapIn5, RewardFactionFlags, "
-        //93                94                  95                 96                 97                  98                  99                 100
+        //96                97                  98                 99                  100                101                 102                103
         "RewardCurrencyID1, RewardCurrencyQty1, RewardCurrencyID2, RewardCurrencyQty2, RewardCurrencyID3, RewardCurrencyQty3, RewardCurrencyID4, RewardCurrencyQty4, "
-        //101                102                 103          104          105             106            107
-        "AcceptedSoundKitID, CompleteSoundKitID, AreaGroupID, TimeAllowed, AllowableRaces, QuestRewardID, Expansion, "
-        //108      109             110               111              112                113                114                 115                 116
+        //104                105                 106          107          108             109               110
+        "AcceptedSoundKitID, CompleteSoundKitID, AreaGroupID, TimeAllowed, AllowableRaces, TreasurePickerID, Expansion, "
+        //111      112             113               114              115                116                117                 118                 119
         "LogTitle, LogDescription, QuestDescription, AreaDescription, PortraitGiverText, PortraitGiverName, PortraitTurnInText, PortraitTurnInName, QuestCompletionLog"
         " FROM quest_template");
     if (!result)
@@ -6174,7 +6171,7 @@ uint32 ObjectMgr::GetNearestTaxiNode(float x, float y, float z, uint32 mapid, ui
         if (!node || node->ContinentID != mapid || !(node->Flags & requireFlag))
             continue;
 
-        uint8  field   = (uint8)((node->ID - 1) / 8);
+        uint32 field   = uint32((node->ID - 1) / 8);
         uint32 submask = 1 << ((node->ID - 1) % 8);
 
         // skip not taxi network nodes
@@ -6227,7 +6224,8 @@ void ObjectMgr::GetTaxiPath(uint32 source, uint32 destination, uint32 &path, uin
 
 uint32 ObjectMgr::GetTaxiMountDisplayId(uint32 id, uint32 team, bool allowed_alt_team /* = false */)
 {
-    uint32 mount_id = 0;
+    CreatureModel mountModel;
+    CreatureTemplate const* mount_info = nullptr;
 
     // select mount creature id
     TaxiNodesEntry const* node = sTaxiNodesStore.LookupEntry(id);
@@ -6247,22 +6245,23 @@ uint32 ObjectMgr::GetTaxiMountDisplayId(uint32 id, uint32 team, bool allowed_alt
             mount_entry = team == ALLIANCE ? node->MountCreatureID[0] : node->MountCreatureID[1];
         }
 
-        CreatureTemplate const* mount_info = GetCreatureTemplate(mount_entry);
+        mount_info = GetCreatureTemplate(mount_entry);
         if (mount_info)
         {
-            mount_id = mount_info->GetRandomValidModelId();
-            if (!mount_id)
+            CreatureModel const* model = mount_info->GetRandomValidModel();
+            if (!model)
             {
                 TC_LOG_ERROR("sql.sql", "No displayid found for the taxi mount with the entry %u! Can't load it!", mount_entry);
                 return 0;
             }
+            mountModel = *model;
         }
     }
 
     // minfo is not actually used but the mount_id was updated
-    GetCreatureModelRandomGender(&mount_id);
+    GetCreatureModelRandomGender(&mountModel, mount_info);
 
-    return mount_id;
+    return mountModel.CreatureDisplayID;
 }
 
 void ObjectMgr::LoadGraveyardZones()
@@ -7027,8 +7026,8 @@ void ObjectMgr::LoadGameObjectTemplate()
                                              "Data0, Data1, Data2, Data3, Data4, Data5, Data6, Data7, Data8, Data9, Data10, Data11, Data12, "
     //                                        21      22      23      24      25      26      27      28      29      30      31      32      33      34      35      36
                                              "Data13, Data14, Data15, Data16, Data17, Data18, Data19, Data20, Data21, Data22, Data23, Data24, Data25, Data26, Data27, Data28, "
-    //                                        37      38       39     40      41             42      43
-                                             "Data29, Data30, Data31, Data32, RequiredLevel, AIName, ScriptName "
+    //                                        37      38       39     40      41      42             43      44
+                                             "Data29, Data30, Data31, Data32, Data33, RequiredLevel, AIName, ScriptName "
                                              "FROM gameobject_template");
 
     if (!result)
@@ -7058,9 +7057,9 @@ void ObjectMgr::LoadGameObjectTemplate()
         for (uint8 i = 0; i < MAX_GAMEOBJECT_DATA; ++i)
             got.raw.data[i] = fields[8 + i].GetUInt32();
 
-        got.RequiredLevel = fields[41].GetInt32();
-        got.AIName = fields[42].GetString();
-        got.ScriptId = GetScriptId(fields[43].GetString());
+        got.RequiredLevel = fields[42].GetInt32();
+        got.AIName = fields[43].GetString();
+        got.ScriptId = GetScriptId(fields[44].GetString());
 
         // Checks
 
@@ -7696,8 +7695,8 @@ void ObjectMgr::LoadQuestPOI()
 
     uint32 count = 0;
 
-    //                                                   0        1        2            3           4                 5           6         7            8       9       10         11              12             13               14
-    QueryResult result = WorldDatabase.Query("SELECT QuestID, BlobIndex, Idx1, ObjectiveIndex, QuestObjectiveID, QuestObjectID, MapID, WorldMapAreaId, Floor, Priority, Flags, WorldEffectID, PlayerConditionID, WoDUnk1, AlwaysAllowMergingBlobs FROM quest_poi order by QuestID, Idx1");
+    //                                               0        1          2     3               4                 5              6      7        8         9      10             11                 12               13
+    QueryResult result = WorldDatabase.Query("SELECT QuestID, BlobIndex, Idx1, ObjectiveIndex, QuestObjectiveID, QuestObjectID, MapID, UiMapID, Priority, Flags, WorldEffectID, PlayerConditionID, SpawnTrackingID, AlwaysAllowMergingBlobs FROM quest_poi order by QuestID, Idx1");
     if (!result)
     {
         TC_LOG_ERROR("server.loading", ">> Loaded 0 quest POI definitions. DB table `quest_poi` is empty.");
@@ -7737,33 +7736,32 @@ void ObjectMgr::LoadQuestPOI()
     {
         Field* fields = result->Fetch();
 
-        int32 QuestID               = fields[0].GetInt32();
-        int32 BlobIndex             = fields[1].GetInt32();
-        int32 Idx1                  = fields[2].GetInt32();
-        int32 ObjectiveIndex        = fields[3].GetInt32();
-        int32 QuestObjectiveID      = fields[4].GetInt32();
-        int32 QuestObjectID         = fields[5].GetInt32();
-        int32 MapID                 = fields[6].GetInt32();
-        int32 WorldMapAreaId        = fields[7].GetInt32();
-        int32 Floor                 = fields[8].GetInt32();
-        int32 Priority              = fields[9].GetInt32();
-        int32 Flags                 = fields[10].GetInt32();
-        int32 WorldEffectID         = fields[11].GetInt32();
-        int32 PlayerConditionID     = fields[12].GetInt32();
-        int32 WoDUnk1               = fields[13].GetInt32();
-        bool AlwaysAllowMergingBlobs = fields[14].GetBool();
-
-        if (!sObjectMgr->GetQuestTemplate(QuestID))
-            TC_LOG_ERROR("sql.sql", "`quest_poi` quest id (%u) Idx1 (%u) does not exist in `quest_template`", QuestID, Idx1);
-
-        QuestPOI POI(BlobIndex, ObjectiveIndex, QuestObjectiveID, QuestObjectID, MapID, WorldMapAreaId, Floor, Priority, Flags, WorldEffectID, PlayerConditionID, WoDUnk1, AlwaysAllowMergingBlobs);
-        if (QuestID < int32(POIs.size()) && Idx1 < int32(POIs[QuestID].size()))
-        {
-            POI.points = POIs[QuestID][Idx1];
-            _questPOIStore[QuestID].push_back(POI);
+        int32 questID               = fields[0].GetInt32();
+        int32 blobIndex             = fields[1].GetInt32();
+        int32 idx1                  = fields[2].GetInt32();
+        int32 objectiveIndex        = fields[3].GetInt32();
+        int32 questObjectiveID      = fields[4].GetInt32();
+        int32 questObjectID         = fields[5].GetInt32();
+        int32 mapID                 = fields[6].GetInt32();
+        int32 uiMapID               = fields[7].GetInt32();
+        int32 priority              = fields[8].GetInt32();
+        int32 flags                 = fields[9].GetInt32();
+        int32 worldEffectID         = fields[10].GetInt32();
+        int32 playerConditionID     = fields[11].GetInt32();
+        int32 spawnTrackingID       = fields[12].GetInt32();
+        bool alwaysAllowMergingBlobs = fields[13].GetBool();
+
+        if (!sObjectMgr->GetQuestTemplate(questID))
+            TC_LOG_ERROR("sql.sql", "`quest_poi` quest id (%u) Idx1 (%u) does not exist in `quest_template`", questID, idx1);
+
+        QuestPOI POI(blobIndex, objectiveIndex, questObjectiveID, questObjectID, mapID, uiMapID, priority, flags, worldEffectID, playerConditionID, spawnTrackingID, alwaysAllowMergingBlobs);
+        if (questID < int32(POIs.size()) && idx1 < int32(POIs[questID].size()))
+        {
+            POI.points = POIs[questID][idx1];
+            _questPOIStore[questID].push_back(POI);
         }
         else
-            TC_LOG_ERROR("sql.sql", "Table quest_poi references unknown quest points for quest %i POI id %i", QuestID, BlobIndex);
+            TC_LOG_ERROR("sql.sql", "Table quest_poi references unknown quest points for quest %i POI id %i", questID, blobIndex);
 
         ++count;
     } while (result->NextRow());
@@ -8578,7 +8576,7 @@ void ObjectMgr::LoadMailLevelRewards()
         Field* fields = result->Fetch();
 
         uint8 level           = fields[0].GetUInt8();
-        uint32 raceMask       = fields[1].GetUInt32();
+        uint64 raceMask       = fields[1].GetUInt64();
         uint32 mailTemplateId = fields[2].GetUInt32();
         uint32 senderEntry    = fields[3].GetUInt32();
 
@@ -8590,7 +8588,7 @@ void ObjectMgr::LoadMailLevelRewards()
 
         if (!(raceMask & RACEMASK_ALL_PLAYABLE))
         {
-            TC_LOG_ERROR("sql.sql", "Table `mail_level_reward` has raceMask (%u) for level %u that not include any player races, ignoring.", raceMask, level);
+            TC_LOG_ERROR("sql.sql", "Table `mail_level_reward` has raceMask (" UI64FMTD ") for level %u that not include any player races, ignoring.", raceMask, level);
             continue;
         }
 
@@ -8669,18 +8667,6 @@ void ObjectMgr::LoadTrainers()
             if (!allReqValid)
                 continue;
 
-            spell.LearnedSpellId = spell.SpellId;
-            for (SpellEffectInfo const* spellEffect : spellInfo->GetEffectsForDifficulty(DIFFICULTY_NONE))
-            {
-                if (spellEffect && spellEffect->IsEffect(SPELL_EFFECT_LEARN_SPELL))
-                {
-                    ASSERT(spell.LearnedSpellId == spell.SpellId,
-                        "Only one learned spell is currently supported - spell %u already teaches %u but it tried to overwrite it with %u",
-                        spell.SpellId, spell.LearnedSpellId, spellEffect->TriggerSpell);
-                    spell.LearnedSpellId = spellEffect->TriggerSpell;
-                }
-            }
-
             spellsByTrainer[trainerId].push_back(spell);
 
         } while (trainerSpellsResult->NextRow());
@@ -9282,8 +9268,8 @@ CreatureBaseStats const* ObjectMgr::GetCreatureBaseStats(uint8 level, uint8 unit
 void ObjectMgr::LoadCreatureClassLevelStats()
 {
     uint32 oldMSTime = getMSTime();
-    //                                               0      1      2         3          4            5                  6            7            8            9            10           11
-    QueryResult result = WorldDatabase.Query("SELECT level, class, basemana, basearmor, attackpower, rangedattackpower, damage_base, damage_exp1, damage_exp2, damage_exp3, damage_exp4, damage_exp5 FROM creature_classlevelstats");
+    //                                               0      1      2         3          4            5
+    QueryResult result = WorldDatabase.Query("SELECT level, class, basemana, basearmor, attackpower, rangedattackpower FROM creature_classlevelstats");
 
     if (!result)
     {
@@ -9581,7 +9567,7 @@ void ObjectMgr::LoadTerrainWorldMaps()
     uint32 oldMSTime = getMSTime();
 
     //                                               0               1
-    QueryResult result = WorldDatabase.Query("SELECT TerrainSwapMap, WorldMapArea FROM `terrain_worldmap`");
+    QueryResult result = WorldDatabase.Query("SELECT TerrainSwapMap, UiMapPhaseId FROM `terrain_worldmap`");
 
     if (!result)
     {
@@ -9595,7 +9581,7 @@ void ObjectMgr::LoadTerrainWorldMaps()
         Field* fields = result->Fetch();
 
         uint32 mapId = fields[0].GetUInt32();
-        uint32 worldMapArea = fields[1].GetUInt32();
+        uint32 uiMapPhaseId = fields[1].GetUInt32();
 
         if (!sMapStore.LookupEntry(mapId))
         {
@@ -9603,15 +9589,15 @@ void ObjectMgr::LoadTerrainWorldMaps()
             continue;
         }
 
-        if (!sWorldMapAreaStore.LookupEntry(worldMapArea))
+        if (!sDB2Manager.IsUiMapPhase(uiMapPhaseId))
         {
-            TC_LOG_ERROR("sql.sql", "WorldMapArea %u defined in `terrain_worldmap` does not exist, skipped.", worldMapArea);
+            TC_LOG_ERROR("sql.sql", "Phase %u defined in `terrain_worldmap` is not a valid terrain swap phase, skipped.", uiMapPhaseId);
             continue;
         }
 
         TerrainSwapInfo* terrainSwapInfo = &_terrainSwapInfoById[mapId];
         terrainSwapInfo->Id = mapId;
-        terrainSwapInfo->UiWorldMapAreaIDSwaps.push_back(worldMapArea);
+        terrainSwapInfo->UiMapPhaseIDs.push_back(uiMapPhaseId);
 
         ++count;
     } while (result->NextRow());
@@ -9758,11 +9744,6 @@ TerrainSwapInfo const* ObjectMgr::GetTerrainSwapInfo(uint32 terrainSwapId) const
     return Trinity::Containers::MapGetValuePtr(_terrainSwapInfoById, terrainSwapId);
 }
 
-std::vector<TerrainSwapInfo*> const* ObjectMgr::GetTerrainSwapsForMap(uint32 mapId) const
-{
-    return Trinity::Containers::MapGetValuePtr(_terrainSwapInfoByMap, mapId);
-}
-
 GameObjectTemplate const* ObjectMgr::GetGameObjectTemplate(uint32 entry) const
 {
     GameObjectTemplateContainer::const_iterator itr = _gameObjectTemplateStore.find(entry);
@@ -10104,7 +10085,7 @@ void ObjectMgr::LoadPlayerChoices()
     uint32 oldMSTime = getMSTime();
     _playerChoices.clear();
 
-    QueryResult choices = WorldDatabase.Query("SELECT ChoiceId, UiTextureKitId, Question, HideWarboardHeader FROM playerchoice");
+    QueryResult choices = WorldDatabase.Query("SELECT ChoiceId, UiTextureKitId, Question, HideWarboardHeader, KeepOpenAfterChoice FROM playerchoice");
 
     if (!choices)
     {
@@ -10129,10 +10110,11 @@ void ObjectMgr::LoadPlayerChoices()
         choice.UiTextureKitId = fields[1].GetInt32();
         choice.Question = fields[2].GetString();
         choice.HideWarboardHeader = fields[3].GetBool();
+        choice.KeepOpenAfterChoice = fields[4].GetBool();
 
     } while (choices->NextRow());
 
-    if (QueryResult responses = WorldDatabase.Query("SELECT ChoiceId, ResponseId, ChoiceArtFileId, Header, Answer, Description, Confirmation FROM playerchoice_response ORDER BY `Index` ASC"))
+    if (QueryResult responses = WorldDatabase.Query("SELECT ChoiceId, ResponseId, ChoiceArtFileId, Flags, WidgetSetID, GroupID, Header, Answer, Description, Confirmation FROM playerchoice_response ORDER BY `Index` ASC"))
     {
         do
         {
@@ -10153,10 +10135,13 @@ void ObjectMgr::LoadPlayerChoices()
             PlayerChoiceResponse& response = choice->Responses.back();
             response.ResponseId         = responseId;
             response.ChoiceArtFileId    = fields[2].GetInt32();
-            response.Header             = fields[3].GetString();
-            response.Answer             = fields[4].GetString();
-            response.Description        = fields[5].GetString();
-            response.Confirmation       = fields[6].GetString();
+            response.Flags              = fields[3].GetInt32();
+            response.WidgetSetID        = fields[4].GetUInt32();
+            response.GroupID            = fields[5].GetUInt8();
+            response.Header             = fields[6].GetString();
+            response.Answer             = fields[7].GetString();
+            response.Description        = fields[8].GetString();
+            response.Confirmation       = fields[9].GetString();
             ++responseCount;
 
         } while (responses->NextRow());
diff --git a/src/server/game/Globals/ObjectMgr.h b/src/server/game/Globals/ObjectMgr.h
index d8a667210c1..7052bc790ca 100644
--- a/src/server/game/Globals/ObjectMgr.h
+++ b/src/server/game/Globals/ObjectMgr.h
@@ -609,9 +609,9 @@ struct PetLevelInfo
 struct MailLevelReward
 {
     MailLevelReward() : raceMask(0), mailTemplateId(0), senderEntry(0) { }
-    MailLevelReward(uint32 _raceMask, uint32 _mailTemplateId, uint32 _senderEntry) : raceMask(_raceMask), mailTemplateId(_mailTemplateId), senderEntry(_senderEntry) { }
+    MailLevelReward(uint64 _raceMask, uint32 _mailTemplateId, uint32 _senderEntry) : raceMask(_raceMask), mailTemplateId(_mailTemplateId), senderEntry(_senderEntry) { }
 
-    uint32 raceMask;
+    uint64 raceMask;
     uint32 mailTemplateId;
     uint32 senderEntry;
 };
@@ -710,20 +710,19 @@ struct QuestPOI
     int32 QuestObjectiveID;
     int32 QuestObjectID;
     int32 MapID;
-    int32 WorldMapAreaID;
-    int32 Floor;
+    int32 UiMapID;
     int32 Priority;
     int32 Flags;
     int32 WorldEffectID;
     int32 PlayerConditionID;
-    int32 UnkWoD1;
+    int32 SpawnTrackingID;
     std::vector<QuestPOIPoint> points;
     bool AlwaysAllowMergingBlobs;
 
-    QuestPOI() : BlobIndex(0), ObjectiveIndex(0), QuestObjectiveID(0), QuestObjectID(0), MapID(0), WorldMapAreaID(0), Floor(0), Priority(0), Flags(0), WorldEffectID(0), PlayerConditionID(0), UnkWoD1(0), AlwaysAllowMergingBlobs(false){ }
-    QuestPOI(int32 _BlobIndex, int32 _ObjectiveIndex, int32 _QuestObjectiveID, int32 _QuestObjectID, int32 _MapID, int32 _WorldMapAreaID, int32 _Foor, int32 _Priority, int32 _Flags, int32 _WorldEffectID, int32 _PlayerConditionID, int32 _UnkWoD1, bool _AlwaysAllowMergingBlobs) :
-        BlobIndex(_BlobIndex), ObjectiveIndex(_ObjectiveIndex), QuestObjectiveID(_QuestObjectiveID), QuestObjectID(_QuestObjectID), MapID(_MapID), WorldMapAreaID(_WorldMapAreaID),
-        Floor(_Foor), Priority(_Priority), Flags(_Flags), WorldEffectID(_WorldEffectID), PlayerConditionID(_PlayerConditionID), UnkWoD1(_UnkWoD1), AlwaysAllowMergingBlobs(_AlwaysAllowMergingBlobs) { }
+    QuestPOI() : BlobIndex(0), ObjectiveIndex(0), QuestObjectiveID(0), QuestObjectID(0), MapID(0), UiMapID(0), Priority(0), Flags(0), WorldEffectID(0), PlayerConditionID(0), SpawnTrackingID(0), AlwaysAllowMergingBlobs(false){ }
+    QuestPOI(int32 blobIndex, int32 objectiveIndex, int32 questObjectiveID, int32 questObjectID, int32 mapID, int32 uiMapID, int32 priority, int32 flags, int32 worldEffectID, int32 playerConditionID, int32 spawnTrackingID, bool alwaysAllowMergingBlobs) :
+        BlobIndex(blobIndex), ObjectiveIndex(objectiveIndex), QuestObjectiveID(questObjectiveID), QuestObjectID(questObjectID), MapID(mapID), UiMapID(uiMapID),
+        Priority(priority), Flags(flags), WorldEffectID(worldEffectID), PlayerConditionID(playerConditionID), SpawnTrackingID(spawnTrackingID), AlwaysAllowMergingBlobs(alwaysAllowMergingBlobs) { }
 };
 
 typedef std::vector<QuestPOI> QuestPOIVector;
@@ -794,6 +793,9 @@ struct PlayerChoiceResponse
 {
     int32 ResponseId;
     int32 ChoiceArtFileId;
+    int32 Flags;
+    uint32 WidgetSetID;
+    uint8 GroupID;
     std::string Header;
     std::string Answer;
     std::string Description;
@@ -808,6 +810,7 @@ struct PlayerChoice
     std::string Question;
     std::vector<PlayerChoiceResponse> Responses;
     bool HideWarboardHeader;
+    bool KeepOpenAfterChoice;
 
     PlayerChoiceResponse const* GetResponse(int32 responseId) const
     {
@@ -885,7 +888,7 @@ typedef std::unordered_map<uint64, DungeonEncounterList> DungeonEncounterContain
 struct TerrainSwapInfo
 {
     uint32 Id;
-    std::vector<uint32> UiWorldMapAreaIDSwaps;
+    std::vector<uint32> UiMapPhaseIDs;
 };
 
 struct PhaseInfoStruct
@@ -959,8 +962,8 @@ class TC_GAME_API ObjectMgr
         CreatureTemplate const* GetCreatureTemplate(uint32 entry) const;
         CreatureTemplateContainer const* GetCreatureTemplates() const { return &_creatureTemplateStore; }
         CreatureModelInfo const* GetCreatureModelInfo(uint32 modelId) const;
-        CreatureModelInfo const* GetCreatureModelRandomGender(uint32* displayID) const;
-        static uint32 ChooseDisplayId(CreatureTemplate const* cinfo, CreatureData const* data = nullptr);
+        CreatureModelInfo const* GetCreatureModelRandomGender(CreatureModel* mode, CreatureTemplate const* creatureTemplate) const;
+        static CreatureModel const* ChooseDisplayId(CreatureTemplate const* cinfo, CreatureData const* data = nullptr);
         static void ChooseCreatureFlags(CreatureTemplate const* cInfo, uint64& npcFlags, uint32& unitFlags, uint32& unitFlags2, uint32& unitFlags3, uint32& dynamicFlags, CreatureData const* data = nullptr);
         EquipmentInfo const* GetEquipmentInfo(uint32 entry, int8& id) const;
         CreatureAddon const* GetCreatureAddon(ObjectGuid::LowType lowguid) const;
@@ -1182,6 +1185,7 @@ class TC_GAME_API ObjectMgr
         void LoadCreatureClassLevelStats();
         void LoadCreatureLocales();
         void LoadCreatureTemplates();
+        void LoadCreatureTemplateModels();
         void LoadCreatureTemplateAddons();
         void LoadCreatureTemplate(Field* fields);
         void LoadCreatureScalingData();
@@ -1308,7 +1312,7 @@ class TC_GAME_API ObjectMgr
 
         ExclusiveQuestGroups mExclusiveQuestGroups;
 
-        MailLevelReward const* GetMailLevelReward(uint8 level, uint32 raceMask)
+        MailLevelReward const* GetMailLevelReward(uint8 level, uint64 raceMask)
         {
             MailLevelRewardContainer::const_iterator map_itr = _mailLevelRewardStore.find(level);
             if (map_itr == _mailLevelRewardStore.end())
@@ -1666,7 +1670,7 @@ class TC_GAME_API ObjectMgr
         PhaseInfoStruct const* GetPhaseInfo(uint32 phaseId) const;
         std::vector<PhaseAreaInfo> const* GetPhasesForArea(uint32 areaId) const;
         TerrainSwapInfo const* GetTerrainSwapInfo(uint32 terrainSwapId) const;
-        std::vector<TerrainSwapInfo*> const* GetTerrainSwapsForMap(uint32 mapId) const;
+        std::unordered_map<uint32, std::vector<TerrainSwapInfo*>> const& GetTerrainSwaps() const { return _terrainSwapInfoByMap; }
 
     private:
         std::unordered_map<uint32, PhaseInfoStruct> _phaseInfoById;
diff --git a/src/server/game/Handlers/AuthHandler.cpp b/src/server/game/Handlers/AuthHandler.cpp
index 296bf506edc..251708cb48d 100644
--- a/src/server/game/Handlers/AuthHandler.cpp
+++ b/src/server/game/Handlers/AuthHandler.cpp
@@ -98,6 +98,9 @@ void WorldSession::SendFeatureSystemStatusGlueScreen()
     features.BpayStoreDisabledByParentalControls = false;
     features.CharUndeleteEnabled = sWorld->getBoolConfig(CONFIG_FEATURE_SYSTEM_CHARACTER_UNDELETE_ENABLED);
     features.BpayStoreEnabled = sWorld->getBoolConfig(CONFIG_FEATURE_SYSTEM_BPAY_STORE_ENABLED);
+    features.MaxCharactersPerRealm = sWorld->getIntConfig(CONFIG_CHARACTERS_PER_REALM);
+    features.MinimumExpansionLevel = EXPANSION_CLASSIC;
+    features.MaximumExpansionLevel = sWorld->getIntConfig(CONFIG_EXPANSION);
 
     SendPacket(features.Write());
 }
diff --git a/src/server/game/Handlers/BattlePetHandler.cpp b/src/server/game/Handlers/BattlePetHandler.cpp
index 295b0c52a4d..ed439b8fab6 100644
--- a/src/server/game/Handlers/BattlePetHandler.cpp
+++ b/src/server/game/Handlers/BattlePetHandler.cpp
@@ -68,7 +68,7 @@ void WorldSession::HandleCageBattlePet(WorldPackets::BattlePet::CageBattlePet& c
 
 void WorldSession::HandleBattlePetSummon(WorldPackets::BattlePet::BattlePetSummon& battlePetSummon)
 {
-    if (_player->GetGuidValue(PLAYER_FIELD_SUMMONED_BATTLE_PET_ID) != battlePetSummon.PetGuid)
+    if (_player->GetGuidValue(ACTIVE_PLAYER_FIELD_SUMMONED_BATTLE_PET_ID) != battlePetSummon.PetGuid)
         GetBattlePetMgr()->SummonPet(battlePetSummon.PetGuid);
     else
         GetBattlePetMgr()->DismissPet();
diff --git a/src/server/game/Handlers/CalendarHandler.cpp b/src/server/game/Handlers/CalendarHandler.cpp
index bf9ddd12b7b..43de963bda4 100644
--- a/src/server/game/Handlers/CalendarHandler.cpp
+++ b/src/server/game/Handlers/CalendarHandler.cpp
@@ -79,8 +79,7 @@ void WorldSession::HandleCalendarGetCalendar(WorldPackets::Calendar::CalendarGet
         WorldPackets::Calendar::CalendarSendCalendarEventInfo eventInfo;
         eventInfo.EventID = event->GetEventId();
         eventInfo.Date = event->GetDate();
-        Guild* guild = sGuildMgr->GetGuildById(event->GetGuildId());
-        eventInfo.EventGuildID = guild ? guild->GetGUID() : ObjectGuid::Empty;
+        eventInfo.EventClubID = event->GetGuildId();
         eventInfo.EventName = event->GetTitle();
         eventInfo.EventType = event->GetType();
         eventInfo.Flags = event->GetFlags();
@@ -124,10 +123,10 @@ void WorldSession::HandleCalendarGetEvent(WorldPackets::Calendar::CalendarGetEve
         sCalendarMgr->SendCalendarCommandResult(_player->GetGUID(), CALENDAR_ERROR_EVENT_INVALID);
 }
 
-void WorldSession::HandleCalendarGuildFilter(WorldPackets::Calendar::CalendarGuildFilter& calendarGuildFilter)
+void WorldSession::HandleCalendarCommunityFilter(WorldPackets::Calendar::CalendarCommunityFilter& calendarCommunityFilter)
 {
     if (Guild* guild = sGuildMgr->GetGuildById(_player->GetGuildId()))
-        guild->MassInviteToEvent(this, calendarGuildFilter.MinLevel, calendarGuildFilter.MaxLevel, calendarGuildFilter.MaxRankOrder);
+        guild->MassInviteToEvent(this, calendarCommunityFilter.MinLevel, calendarCommunityFilter.MaxLevel, calendarCommunityFilter.MaxRankOrder);
 }
 
 void WorldSession::HandleCalendarAddEvent(WorldPackets::Calendar::CalendarAddEvent& calendarAddEvent)
diff --git a/src/server/game/Handlers/ChannelHandler.cpp b/src/server/game/Handlers/ChannelHandler.cpp
index 90e6150a284..529bfb50fdc 100644
--- a/src/server/game/Handlers/ChannelHandler.cpp
+++ b/src/server/game/Handlers/ChannelHandler.cpp
@@ -146,9 +146,6 @@ void WorldSession::HandleChannelPlayerCommand(WorldPackets::Channel::ChannelPlay
             case CMSG_CHAT_CHANNEL_MODERATOR:
                 channel->SetModerator(GetPlayer(), packet.Name);
                 break;
-            case CMSG_CHAT_CHANNEL_MUTE:
-                channel->SetMute(GetPlayer(), packet.Name);
-                break;
             case CMSG_CHAT_CHANNEL_SET_OWNER:
                 channel->SetOwner(GetPlayer(), packet.Name);
                 break;
@@ -161,9 +158,6 @@ void WorldSession::HandleChannelPlayerCommand(WorldPackets::Channel::ChannelPlay
             case CMSG_CHAT_CHANNEL_UNMODERATOR:
                 channel->UnsetModerator(GetPlayer(), packet.Name);
                 break;
-            case CMSG_CHAT_CHANNEL_UNMUTE:
-                channel->UnsetMute(GetPlayer(), packet.Name);
-                break;
             case CMSG_CHAT_CHANNEL_UNSILENCE_ALL:
                 channel->UnsilenceAll(GetPlayer(), packet.Name);
                 break;
diff --git a/src/server/game/Handlers/CharacterHandler.cpp b/src/server/game/Handlers/CharacterHandler.cpp
index 210b2f0c915..c5b4e0487ff 100644
--- a/src/server/game/Handlers/CharacterHandler.cpp
+++ b/src/server/game/Handlers/CharacterHandler.cpp
@@ -349,6 +349,7 @@ void WorldSession::HandleCharEnum(PreparedQueryResult result)
         while (result->NextRow());
     }
 
+    charEnum.IsTestDemonHunterCreationAllowed = canAlwaysCreateDemonHunter;
     charEnum.IsDemonHunterCreationAllowed = GetAccountExpansion() >= EXPANSION_LEGION || canAlwaysCreateDemonHunter;
     charEnum.IsAlliedRacesCreationAllowed = GetAccountExpansion() >= EXPANSION_BATTLE_FOR_AZEROTH;
 
@@ -506,8 +507,8 @@ void WorldSession::HandleCharCreateOpcode(WorldPackets::Character::CreateCharact
 
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RACEMASK))
     {
-        uint32 raceMaskDisabled = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK);
-        if ((1 << (charCreate.CreateInfo->Race - 1)) & raceMaskDisabled)
+        uint64 raceMaskDisabled = sWorld->GetUInt64Config(CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK);
+        if ((UI64LIT(1) << (charCreate.CreateInfo->Race - 1)) & raceMaskDisabled)
         {
             SendCharCreate(CHAR_CREATE_DISABLED);
             return;
@@ -733,7 +734,7 @@ void WorldSession::HandleCharCreateOpcode(WorldPackets::Character::CreateCharact
 
             LoginDatabase.CommitTransaction(trans);
 
-            SendCharCreate(CHAR_CREATE_SUCCESS);
+            SendCharCreate(CHAR_CREATE_SUCCESS, newChar.GetGUID());
 
             TC_LOG_INFO("entities.player.character", "Account: %u (IP: %s) Create Character: %s %s", GetAccountId(), GetRemoteAddress().c_str(), createInfo->Name.c_str(), newChar.GetGUID().ToString().c_str());
             sScriptMgr->OnPlayerCreate(&newChar);
@@ -972,16 +973,6 @@ void WorldSession::HandlePlayerLogin(LoginQueryHolder* holder)
     WorldPackets::BattlePet::BattlePetJournalLockAcquired lock;
     SendPacket(lock.Write());
 
-    WorldPackets::Artifact::ArtifactKnowledge artifactKnowledge;
-    artifactKnowledge.ArtifactCategoryID = ARTIFACT_CATEGORY_PRIMARY;
-    artifactKnowledge.KnowledgeLevel = sWorld->getIntConfig(CONFIG_CURRENCY_START_ARTIFACT_KNOWLEDGE);
-    SendPacket(artifactKnowledge.Write());
-
-    WorldPackets::Artifact::ArtifactKnowledge artifactKnowledgeFishingPole;
-    artifactKnowledgeFishingPole.ArtifactCategoryID = ARTIFACT_CATEGORY_FISHING;
-    artifactKnowledgeFishingPole.KnowledgeLevel = 0;
-    SendPacket(artifactKnowledgeFishingPole.Write());
-
     pCurrChar->SendInitialPacketsBeforeAddToMap();
 
     //Show cinematic at the first time that player login
@@ -1234,7 +1225,7 @@ void WorldSession::HandleTutorialFlag(WorldPackets::Misc::TutorialSetFlag& packe
 
 void WorldSession::HandleSetWatchedFactionOpcode(WorldPackets::Character::SetWatchedFaction& packet)
 {
-    GetPlayer()->SetUInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, packet.FactionIndex);
+    GetPlayer()->SetUInt32Value(ACTIVE_PLAYER_FIELD_WATCHED_FACTION_INDEX, packet.FactionIndex);
 }
 
 void WorldSession::HandleSetFactionInactiveOpcode(WorldPackets::Character::SetFactionInactive& packet)
@@ -1834,8 +1825,8 @@ void WorldSession::HandleCharRaceOrFactionChangeCallback(std::shared_ptr<WorldPa
 
     if (!HasPermission(rbac::RBAC_PERM_SKIP_CHECK_CHARACTER_CREATION_RACEMASK))
     {
-        uint32 raceMaskDisabled = sWorld->getIntConfig(CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK);
-        if ((1 << (factionChangeInfo->RaceID - 1)) & raceMaskDisabled)
+        uint64 raceMaskDisabled = sWorld->GetUInt64Config(CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK);
+        if ((UI64LIT(1) << (factionChangeInfo->RaceID - 1)) & raceMaskDisabled)
         {
             SendCharFactionChange(CHAR_CREATE_ERROR, factionChangeInfo.get());
             return;
@@ -1962,7 +1953,7 @@ void WorldSession::HandleCharRaceOrFactionChangeCallback(std::shared_ptr<WorldPa
         trans->Append(stmt);
 
         // Race specific languages
-        if (factionChangeInfo->RaceID != RACE_ORC && factionChangeInfo->RaceID != RACE_HUMAN)
+        if (factionChangeInfo->RaceID != RACE_ORC && factionChangeInfo->RaceID != RACE_HUMAN && factionChangeInfo->RaceID != RACE_MAGHAR_ORC)
         {
             stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_SKILL_LANGUAGE);
             stmt->setUInt64(0, lowGuid);
@@ -1970,6 +1961,7 @@ void WorldSession::HandleCharRaceOrFactionChangeCallback(std::shared_ptr<WorldPa
             switch (factionChangeInfo->RaceID)
             {
                 case RACE_DWARF:
+                case RACE_DARK_IRON_DWARF:
                     stmt->setUInt16(1, 111);
                     break;
                 case RACE_DRAENEI:
@@ -2351,7 +2343,7 @@ void WorldSession::HandleReorderCharacters(WorldPackets::Character::ReorderChara
 void WorldSession::HandleOpeningCinematic(WorldPackets::Misc::OpeningCinematic& /*packet*/)
 {
     // Only players that has not yet gained any experience can use this
-    if (_player->GetUInt32Value(PLAYER_XP))
+    if (_player->GetUInt32Value(ACTIVE_PLAYER_FIELD_XP))
         return;
 
     if (ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(_player->getClass()))
@@ -2485,10 +2477,11 @@ void WorldSession::HandleCharUndeleteOpcode(WorldPackets::Character::UndeleteCha
     }));
 }
 
-void WorldSession::SendCharCreate(ResponseCodes result)
+void WorldSession::SendCharCreate(ResponseCodes result, ObjectGuid const& guid /*= ObjectGuid::Empty*/)
 {
     WorldPackets::Character::CreateChar response;
     response.Code = result;
+    response.Guid = guid;
 
     SendPacket(response.Write());
 }
diff --git a/src/server/game/Handlers/ChatHandler.cpp b/src/server/game/Handlers/ChatHandler.cpp
index b056274adca..fb354886846 100644
--- a/src/server/game/Handlers/ChatHandler.cpp
+++ b/src/server/game/Handlers/ChatHandler.cpp
@@ -413,41 +413,12 @@ void WorldSession::HandleChatMessage(ChatMsg type, uint32 lang, std::string msg,
 
 void WorldSession::HandleChatAddonMessageOpcode(WorldPackets::Chat::ChatAddonMessage& chatAddonMessage)
 {
-    ChatMsg type;
-
-    switch (chatAddonMessage.GetOpcode())
-    {
-        case CMSG_CHAT_ADDON_MESSAGE_GUILD:
-            type = CHAT_MSG_GUILD;
-            break;
-        case CMSG_CHAT_ADDON_MESSAGE_OFFICER:
-            type = CHAT_MSG_OFFICER;
-            break;
-        case CMSG_CHAT_ADDON_MESSAGE_PARTY:
-            type = CHAT_MSG_PARTY;
-            break;
-        case CMSG_CHAT_ADDON_MESSAGE_RAID:
-            type = CHAT_MSG_RAID;
-            break;
-        case CMSG_CHAT_ADDON_MESSAGE_INSTANCE_CHAT:
-            type = CHAT_MSG_INSTANCE_CHAT;
-            break;
-        default:
-            TC_LOG_ERROR("network", "HandleChatAddonMessageOpcode: Unknown addon chat opcode (%u)", chatAddonMessage.GetOpcode());
-            return;
-    }
-
-    HandleChatAddonMessage(type, chatAddonMessage.Prefix, chatAddonMessage.Text);
-}
-
-void WorldSession::HandleChatAddonMessageWhisperOpcode(WorldPackets::Chat::ChatAddonMessageWhisper& chatAddonMessageWhisper)
-{
-    HandleChatAddonMessage(CHAT_MSG_WHISPER, chatAddonMessageWhisper.Prefix, chatAddonMessageWhisper.Text, chatAddonMessageWhisper.Target);
+    HandleChatAddonMessage(chatAddonMessage.Params.Type, chatAddonMessage.Params.Prefix, chatAddonMessage.Params.Text);
 }
 
-void WorldSession::HandleChatAddonMessageChannelOpcode(WorldPackets::Chat::ChatAddonMessageChannel& chatAddonMessageChannel)
+void WorldSession::HandleChatAddonMessageTargetedOpcode(WorldPackets::Chat::ChatAddonMessageTargeted& chatAddonMessageTargeted)
 {
-    HandleChatAddonMessage(CHAT_MSG_CHANNEL, chatAddonMessageChannel.Prefix, chatAddonMessageChannel.Text, chatAddonMessageChannel.Target);
+    HandleChatAddonMessage(chatAddonMessageTargeted.Params.Type, chatAddonMessageTargeted.Params.Prefix, chatAddonMessageTargeted.Params.Text, chatAddonMessageTargeted.Target);
 }
 
 void WorldSession::HandleChatAddonMessage(ChatMsg type, std::string prefix, std::string text, std::string target /*= ""*/)
diff --git a/src/server/game/Handlers/DuelHandler.cpp b/src/server/game/Handlers/DuelHandler.cpp
index 41892196367..c017617f507 100644
--- a/src/server/game/Handlers/DuelHandler.cpp
+++ b/src/server/game/Handlers/DuelHandler.cpp
@@ -49,7 +49,7 @@ void WorldSession::HandleCanDuel(WorldPackets::Duel::CanDuel& packet)
 
 void WorldSession::HandleDuelResponseOpcode(WorldPackets::Duel::DuelResponse& duelResponse)
 {
-    if (duelResponse.Accepted)
+    if (duelResponse.Accepted && !duelResponse.Forfeited)
         HandleDuelAccepted();
     else
         HandleDuelCancelled();
diff --git a/src/server/game/Handlers/HotfixHandler.cpp b/src/server/game/Handlers/HotfixHandler.cpp
index 0d887769d08..4fc6426c2df 100644
--- a/src/server/game/Handlers/HotfixHandler.cpp
+++ b/src/server/game/Handlers/HotfixHandler.cpp
@@ -73,11 +73,16 @@ void WorldSession::HandleHotfixRequest(WorldPackets::Hotfix::HotfixRequest& hotf
             WorldPackets::Hotfix::HotfixResponse::HotfixData hotfixData;
             hotfixData.ID = hotfixId;
             hotfixData.RecordID = *hotfix;
-            if (storage->HasRecord(hotfixData.RecordID))
+            if (storage && storage->HasRecord(hotfixData.RecordID))
             {
                 hotfixData.Data = boost::in_place();
                 storage->WriteRecord(hotfixData.RecordID, GetSessionDbcLocale(), *hotfixData.Data);
             }
+            else if (std::vector<uint8> const* blobData = sDB2Manager.GetHotfixBlobData(PAIR64_HIPART(hotfixId), *hotfix))
+            {
+                hotfixData.Data = boost::in_place();
+                hotfixData.Data->append(blobData->data(), blobData->size());
+            }
 
             hotfixQueryResponse.Hotfixes.emplace_back(std::move(hotfixData));
         }
diff --git a/src/server/game/Handlers/InspectHandler.cpp b/src/server/game/Handlers/InspectHandler.cpp
index 2d8c559de51..1121fd4647d 100644
--- a/src/server/game/Handlers/InspectHandler.cpp
+++ b/src/server/game/Handlers/InspectHandler.cpp
@@ -62,6 +62,10 @@ void WorldSession::HandleInspectOpcode(WorldPackets::Inspect::Inspect& inspect)
             if (v.second != PLAYERSPELL_REMOVED)
                 inspectResult.Talents.push_back(v.first);
         }
+
+        PlayerPvpTalentMap const& pvpTalents = player->GetPvpTalentMap(player->GetActiveTalentGroup());
+        for (std::size_t i = 0; i < pvpTalents.size(); ++i)
+            inspectResult.PvpTalents[i] = pvpTalents[i];
     }
 
     if (Guild* guild = sGuildMgr->GetGuildById(player->GetGuildId()))
@@ -97,9 +101,9 @@ void WorldSession::HandleRequestHonorStatsOpcode(WorldPackets::Inspect::RequestH
 
     WorldPackets::Inspect::InspectHonorStats honorStats;
     honorStats.PlayerGUID  = request.TargetGUID;
-    honorStats.LifetimeHK  = player->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS);
-    honorStats.YesterdayHK = player->GetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS);
-    honorStats.TodayHK     = player->GetUInt16Value(PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS);
+    honorStats.LifetimeHK  = player->GetUInt32Value(ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS);
+    honorStats.YesterdayHK = player->GetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_YESTERDAY_KILLS);
+    honorStats.TodayHK     = player->GetUInt16Value(ACTIVE_PLAYER_FIELD_KILLS, PLAYER_FIELD_KILLS_OFFSET_TODAY_KILLS);
     honorStats.LifetimeMaxRank = 0; /// @todo
 
     SendPacket(honorStats.Write());
diff --git a/src/server/game/Handlers/ItemHandler.cpp b/src/server/game/Handlers/ItemHandler.cpp
index 0ba24d95ac9..b518001ce34 100644
--- a/src/server/game/Handlers/ItemHandler.cpp
+++ b/src/server/game/Handlers/ItemHandler.cpp
@@ -516,7 +516,7 @@ void WorldSession::HandleBuybackItem(WorldPackets::Item::BuyBackItem& packet)
     Item* pItem = _player->GetItemFromBuyBackSlot(packet.Slot);
     if (pItem)
     {
-        uint32 price = _player->GetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + packet.Slot - BUYBACK_SLOT_START);
+        uint32 price = _player->GetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_PRICE + packet.Slot - BUYBACK_SLOT_START);
         if (!_player->HasEnoughMoney(uint64(price)))
         {
             _player->SendBuyError(BUY_ERR_NOT_ENOUGHT_MONEY, creature, pItem->GetEntry(), 0);
diff --git a/src/server/game/Handlers/MiscHandler.cpp b/src/server/game/Handlers/MiscHandler.cpp
index 296cd80e323..ec3307a0c6b 100644
--- a/src/server/game/Handlers/MiscHandler.cpp
+++ b/src/server/game/Handlers/MiscHandler.cpp
@@ -756,7 +756,7 @@ void WorldSession::HandleSetActionBarToggles(WorldPackets::Character::SetActionB
         return;
     }
 
-    GetPlayer()->SetByteValue(PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_ACTION_BAR_TOGGLES, packet.Mask);
+    GetPlayer()->SetByteValue(ACTIVE_PLAYER_FIELD_BYTES, PLAYER_FIELD_BYTES_OFFSET_ACTION_BAR_TOGGLES, packet.Mask);
 }
 
 void WorldSession::HandlePlayedTime(WorldPackets::Character::RequestPlayedTime& packet)
@@ -824,11 +824,11 @@ void WorldSession::HandleFarSightOpcode(WorldPackets::Misc::FarSight& packet)
 {
     if (packet.Enable)
     {
-        TC_LOG_DEBUG("network", "Added FarSight %s to %s", _player->GetGuidValue(PLAYER_FARSIGHT).ToString().c_str(), _player->GetGUID().ToString().c_str());
+        TC_LOG_DEBUG("network", "Added FarSight %s to %s", _player->GetGuidValue(ACTIVE_PLAYER_FIELD_FARSIGHT).ToString().c_str(), _player->GetGUID().ToString().c_str());
         if (WorldObject* target = _player->GetViewpoint())
             _player->SetSeer(target);
         else
-            TC_LOG_DEBUG("network", "Player %s (%s) requests non-existing seer %s", _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), _player->GetGuidValue(PLAYER_FARSIGHT).ToString().c_str());
+            TC_LOG_DEBUG("network", "Player %s (%s) requests non-existing seer %s", _player->GetName().c_str(), _player->GetGUID().ToString().c_str(), _player->GetGuidValue(ACTIVE_PLAYER_FIELD_FARSIGHT).ToString().c_str());
     }
     else
     {
@@ -1152,12 +1152,6 @@ void WorldSession::HandleMountSetFavorite(WorldPackets::Misc::MountSetFavorite&
     _collectionMgr->MountSetFavorite(mountSetFavorite.MountSpellID, mountSetFavorite.IsFavorite);
 }
 
-void WorldSession::HandlePvpPrestigeRankUp(WorldPackets::Misc::PvpPrestigeRankUp& /*pvpPrestigeRankUp*/)
-{
-    if (_player->CanPrestige())
-        _player->Prestige();
-}
-
 void WorldSession::HandleCloseInteraction(WorldPackets::Misc::CloseInteraction& closeInteraction)
 {
     if (_player->PlayerTalkClass->GetInteractionData().SourceGuid == closeInteraction.SourceGuid)
diff --git a/src/server/game/Handlers/QueryHandler.cpp b/src/server/game/Handlers/QueryHandler.cpp
index 273bf287821..48bb45581fa 100644
--- a/src/server/game/Handlers/QueryHandler.cpp
+++ b/src/server/game/Handlers/QueryHandler.cpp
@@ -95,10 +95,12 @@ void WorldSession::HandleCreatureQuery(WorldPackets::Query::QueryCreature& packe
         for (uint32 i = 0; i < MAX_KILL_CREDIT; ++i)
             stats.ProxyCreatureID[i] = creatureInfo->KillCredit[i];
 
-        stats.CreatureDisplayID[0] = creatureInfo->Modelid1;
-        stats.CreatureDisplayID[1] = creatureInfo->Modelid2;
-        stats.CreatureDisplayID[2] = creatureInfo->Modelid3;
-        stats.CreatureDisplayID[3] = creatureInfo->Modelid4;
+        std::transform(creatureInfo->Models.begin(), creatureInfo->Models.end(), std::back_inserter(stats.Display.CreatureDisplay),
+            [&stats](CreatureModel const& model) -> WorldPackets::Query::CreatureXDisplay
+        {
+            stats.Display.TotalProbability += model.Probability;
+            return { model.CreatureDisplayID, model.DisplayScale, model.Probability };
+        });
 
         stats.HpMulti = creatureInfo->ModHealth;
         stats.EnergyMulti = creatureInfo->ModMana;
@@ -107,14 +109,14 @@ void WorldSession::HandleCreatureQuery(WorldPackets::Query::QueryCreature& packe
         stats.RequiredExpansion = creatureInfo->RequiredExpansion;
         stats.HealthScalingExpansion = creatureInfo->HealthScalingExpansion;
         stats.VignetteID = creatureInfo->VignetteID;
+        stats.Class = creatureInfo->unit_class;
 
         stats.Title = creatureInfo->SubName;
         stats.TitleAlt = creatureInfo->TitleAlt;
         stats.CursorName = creatureInfo->IconName;
 
         if (std::vector<uint32> const* items = sObjectMgr->GetCreatureQuestItemList(packet.CreatureID))
-            for (uint32 item : *items)
-                stats.QuestItems.push_back(item);
+            stats.QuestItems.insert(stats.QuestItems.begin(), items->begin(), items->end());
 
         LocaleConstant localeConstant = GetSessionDbLocaleIndex();
         if (localeConstant != LOCALE_enUS)
@@ -368,13 +370,12 @@ void WorldSession::HandleQuestPOIQuery(WorldPackets::Query::QuestPOIQuery& quest
                     questPOIBlobData.QuestObjectiveID   = data->QuestObjectiveID;
                     questPOIBlobData.QuestObjectID      = data->QuestObjectID;
                     questPOIBlobData.MapID              = data->MapID;
-                    questPOIBlobData.WorldMapAreaID     = data->WorldMapAreaID;
-                    questPOIBlobData.Floor              = data->Floor;
+                    questPOIBlobData.UiMapID            = data->UiMapID;
                     questPOIBlobData.Priority           = data->Priority;
                     questPOIBlobData.Flags              = data->Flags;
                     questPOIBlobData.WorldEffectID      = data->WorldEffectID;
                     questPOIBlobData.PlayerConditionID  = data->PlayerConditionID;
-                    questPOIBlobData.UnkWoD1            = data->UnkWoD1;
+                    questPOIBlobData.SpawnTrackingID    = data->SpawnTrackingID;
                     questPOIBlobData.AlwaysAllowMergingBlobs = data->AlwaysAllowMergingBlobs;
 
                     for (QuestPOIPoint const& point : data->points)
diff --git a/src/server/game/Handlers/SkillHandler.cpp b/src/server/game/Handlers/SkillHandler.cpp
index fc1741c6885..1d95689d761 100644
--- a/src/server/game/Handlers/SkillHandler.cpp
+++ b/src/server/game/Handlers/SkillHandler.cpp
@@ -55,14 +55,14 @@ void WorldSession::HandleLearnPvpTalentsOpcode(WorldPackets::Talent::LearnPvpTal
 {
     WorldPackets::Talent::LearnPvpTalentsFailed learnPvpTalentsFailed;
     bool anythingLearned = false;
-    for (uint32 talentId : packet.Talents)
+    for (WorldPackets::Talent::PvPTalent pvpTalent : packet.Talents)
     {
-        if (TalentLearnResult result = _player->LearnPvpTalent(talentId, &learnPvpTalentsFailed.SpellID))
+        if (TalentLearnResult result = _player->LearnPvpTalent(pvpTalent.PvPTalentID, pvpTalent.Slot, &learnPvpTalentsFailed.SpellID))
         {
             if (!learnPvpTalentsFailed.Reason)
                 learnPvpTalentsFailed.Reason = result;
 
-            learnPvpTalentsFailed.Talents.push_back(talentId);
+            learnPvpTalentsFailed.Talents.push_back(pvpTalent);
         }
         else
             anythingLearned = true;
diff --git a/src/server/game/Handlers/SpellHandler.cpp b/src/server/game/Handlers/SpellHandler.cpp
index ca011dfd61f..f6d4a7dad5f 100644
--- a/src/server/game/Handlers/SpellHandler.cpp
+++ b/src/server/game/Handlers/SpellHandler.cpp
@@ -466,7 +466,7 @@ void WorldSession::HandleSelfResOpcode(WorldPackets::Spells::SelfRes& selfRes)
     if (_player->HasAuraType(SPELL_AURA_PREVENT_RESURRECTION))
         return; // silent return, client should display error by itself and not send this opcode
 
-    std::vector<uint32> const& selfResSpells = _player->GetDynamicValues(PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS);
+    std::vector<uint32> const& selfResSpells = _player->GetDynamicValues(ACTIVE_PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS);
     if (std::find(selfResSpells.begin(), selfResSpells.end(), selfRes.SpellID) == selfResSpells.end())
         return;
 
@@ -474,7 +474,7 @@ void WorldSession::HandleSelfResOpcode(WorldPackets::Spells::SelfRes& selfRes)
     if (spellInfo)
         _player->CastSpell(_player, spellInfo, false, nullptr);
 
-    _player->RemoveDynamicValue(PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS, selfRes.SpellID);
+    _player->RemoveDynamicValue(ACTIVE_PLAYER_DYNAMIC_FIELD_SELF_RES_SPELLS, selfRes.SpellID);
 }
 
 void WorldSession::HandleSpellClick(WorldPackets::Spells::SpellClick& spellClick)
diff --git a/src/server/game/Handlers/TaxiHandler.cpp b/src/server/game/Handlers/TaxiHandler.cpp
index abb05a2a0c9..4ec66720641 100644
--- a/src/server/game/Handlers/TaxiHandler.cpp
+++ b/src/server/game/Handlers/TaxiHandler.cpp
@@ -107,6 +107,16 @@ void WorldSession::SendTaxiMenu(Creature* unit)
 
     GetPlayer()->m_taxi.AppendTaximaskTo(data, lastTaxiCheaterState);
 
+    TaxiMask reachableNodes;
+    std::fill(reachableNodes.begin(), reachableNodes.end(), 0);
+    sTaxiPathGraph.GetReachableNodesMask(sTaxiNodesStore.LookupEntry(curloc), &reachableNodes);
+
+    for (std::size_t i = 0; i < TaxiMaskSize; ++i)
+    {
+        data.CanLandNodes[i] &= reachableNodes[i];
+        data.CanUseNodes[i] &= reachableNodes[i];
+    }
+
     SendPacket(data.Write());
 
     GetPlayer()->SetTaxiCheater(lastTaxiCheaterState);
diff --git a/src/server/game/Miscellaneous/SharedDefines.h b/src/server/game/Miscellaneous/SharedDefines.h
index f7bea0e904e..a3ff3403e86 100644
--- a/src/server/game/Miscellaneous/SharedDefines.h
+++ b/src/server/game/Miscellaneous/SharedDefines.h
@@ -85,15 +85,14 @@ enum Expansions
     EXPANSION_MISTS_OF_PANDARIA        = 4,
     EXPANSION_WARLORDS_OF_DRAENOR      = 5,
     EXPANSION_LEGION                   = 6,
+    EXPANSION_BATTLE_FOR_AZEROTH       = 7,
     MAX_EXPANSIONS,
 
-    // future expansion
-    EXPANSION_BATTLE_FOR_AZEROTH       = 7,
 
     MAX_ACCOUNT_EXPANSIONS
 };
 
-#define CURRENT_EXPANSION EXPANSION_LEGION
+#define CURRENT_EXPANSION EXPANSION_BATTLE_FOR_AZEROTH
 
 inline uint32 GetMaxLevelForExpansion(uint32 expansion)
 {
@@ -113,6 +112,8 @@ inline uint32 GetMaxLevelForExpansion(uint32 expansion)
             return 100;
         case EXPANSION_LEGION:
             return 110;
+        case EXPANSION_BATTLE_FOR_AZEROTH:
+            return 120;
         default:
             break;
     }
@@ -127,10 +128,10 @@ enum Gender
     GENDER_NONE                        =  2
 };
 
-// ChrRaces.dbc (6.0.2.18988)
+// ChrRaces.db2 (8.0.1.27075)
 enum Races
 {
-    RACE_NONE               = 0,
+    RACE_NONE                   = 0,
     RACE_HUMAN                  = 1,
     RACE_ORC                    = 2,
     RACE_DWARF                  = 3,
@@ -153,54 +154,63 @@ enum Races
     //RACE_NORTHREND_SKELETON = 20,
     //RACE_ICE_TROLL          = 21,
     RACE_WORGEN                 = 22,
-    //RACE_GILNEAN            = 23
+    //RACE_GILNEAN            = 23,
     RACE_PANDAREN_NEUTRAL       = 24,
     RACE_PANDAREN_ALLIANCE      = 25,
     RACE_PANDAREN_HORDE         = 26,
     RACE_NIGHTBORNE             = 27,
     RACE_HIGHMOUNTAIN_TAUREN    = 28,
     RACE_VOID_ELF               = 29,
-    RACE_LIGHTFORGED_DRAENEI    = 30
+    RACE_LIGHTFORGED_DRAENEI    = 30,
+    //RACE_ZANDALARI_TROLL    = 31,
+    //RACE_KUL_TIRAN          = 32,
+    //RACE_THIN_HUMAN         = 33,
+    RACE_DARK_IRON_DWARF        = 34,
+    //RACE_VULPERA            = 35,
+    RACE_MAGHAR_ORC             = 36
 };
 
 // max+1 for player race
-#define MAX_RACES         31
-
-#define RACEMASK_ALL_PLAYABLE      \
-    ((1<<(RACE_HUMAN-1))         | \
-     (1<<(RACE_ORC-1))           | \
-     (1<<(RACE_DWARF-1))         | \
-     (1<<(RACE_NIGHTELF-1))      | \
-     (1<<(RACE_UNDEAD_PLAYER-1)) | \
-     (1<<(RACE_TAUREN-1))        | \
-     (1<<(RACE_GNOME-1))         | \
-     (1<<(RACE_TROLL-1))         | \
-     (1<<(RACE_BLOODELF-1))      | \
-     (1<<(RACE_DRAENEI-1))       | \
-     (1<<(RACE_GOBLIN-1))        | \
-     (1<<(RACE_WORGEN-1))        | \
-     (1<<(RACE_PANDAREN_NEUTRAL-1))  |\
-     (1<<(RACE_PANDAREN_ALLIANCE-1)) |\
-     (1<<(RACE_PANDAREN_HORDE-1))|\
-     (1<<(RACE_NIGHTBORNE-1))|\
-     (1<<(RACE_HIGHMOUNTAIN_TAUREN-1))|\
-     (1<<(RACE_VOID_ELF-1))|\
-     (1<<(RACE_LIGHTFORGED_DRAENEI-1)))
-
-#define RACEMASK_NEUTRAL (1<<(RACE_PANDAREN_NEUTRAL-1))
-
-#define RACEMASK_ALLIANCE     \
-    ((1<<(RACE_HUMAN-1))    | \
-     (1<<(RACE_DWARF-1))    | \
-     (1<<(RACE_NIGHTELF-1)) | \
-     (1<<(RACE_GNOME-1))    | \
-     (1<<(RACE_DRAENEI-1))  | \
-     (1<<(RACE_WORGEN-1))   | \
-     (1<<(RACE_PANDAREN_ALLIANCE-1)) |\
-     (1<<(RACE_VOID_ELF-1)) |\
-     (1<<(RACE_LIGHTFORGED_DRAENEI-1)))
-
-#define RACEMASK_HORDE RACEMASK_ALL_PLAYABLE & ~RACEMASK_ALLIANCE
+#define MAX_RACES         37
+
+#define RACEMASK_ALL_PLAYABLE                     \
+    ((UI64LIT(1)<<(RACE_HUMAN-1))               | \
+     (UI64LIT(1)<<(RACE_ORC-1))                 | \
+     (UI64LIT(1)<<(RACE_DWARF-1))               | \
+     (UI64LIT(1)<<(RACE_NIGHTELF-1))            | \
+     (UI64LIT(1)<<(RACE_UNDEAD_PLAYER-1))       | \
+     (UI64LIT(1)<<(RACE_TAUREN-1))              | \
+     (UI64LIT(1)<<(RACE_GNOME-1))               | \
+     (UI64LIT(1)<<(RACE_TROLL-1))               | \
+     (UI64LIT(1)<<(RACE_BLOODELF-1))            | \
+     (UI64LIT(1)<<(RACE_DRAENEI-1))             | \
+     (UI64LIT(1)<<(RACE_GOBLIN-1))              | \
+     (UI64LIT(1)<<(RACE_WORGEN-1))              | \
+     (UI64LIT(1)<<(RACE_PANDAREN_NEUTRAL-1))    | \
+     (UI64LIT(1)<<(RACE_PANDAREN_ALLIANCE-1))   | \
+     (UI64LIT(1)<<(RACE_PANDAREN_HORDE-1))      | \
+     (UI64LIT(1)<<(RACE_NIGHTBORNE-1))          | \
+     (UI64LIT(1)<<(RACE_HIGHMOUNTAIN_TAUREN-1)) | \
+     (UI64LIT(1)<<(RACE_VOID_ELF-1))            | \
+     (UI64LIT(1)<<(RACE_LIGHTFORGED_DRAENEI-1)) | \
+     (UI64LIT(1)<<(RACE_DARK_IRON_DWARF-1))     | \
+     (UI64LIT(1)<<(RACE_MAGHAR_ORC-1)))
+
+#define RACEMASK_NEUTRAL (UI64LIT(1)<<(RACE_PANDAREN_NEUTRAL-1))
+
+#define RACEMASK_ALLIANCE                         \
+    ((UI64LIT(1)<<(RACE_HUMAN-1))               | \
+     (UI64LIT(1)<<(RACE_DWARF-1))               | \
+     (UI64LIT(1)<<(RACE_NIGHTELF-1))            | \
+     (UI64LIT(1)<<(RACE_GNOME-1))               | \
+     (UI64LIT(1)<<(RACE_DRAENEI-1))             | \
+     (UI64LIT(1)<<(RACE_WORGEN-1))              | \
+     (UI64LIT(1)<<(RACE_PANDAREN_ALLIANCE-1))   | \
+     (UI64LIT(1)<<(RACE_VOID_ELF-1))            | \
+     (UI64LIT(1)<<(RACE_LIGHTFORGED_DRAENEI-1)) | \
+     (UI64LIT(1)<<(RACE_DARK_IRON_DWARF-1)))
+
+#define RACEMASK_HORDE (RACEMASK_ALL_PLAYABLE & ~RACEMASK_ALLIANCE)
 
 // Class value is index in ChrClasses.dbc
 enum Classes : uint8
@@ -984,6 +994,7 @@ enum CharacterFlags4 : uint32
 {
     CHARACTER_FLAG_4_TRIAL_BOOST        = 0x00000080,
     CHARACTER_FLAG_4_TRIAL_BOOST_LOCKED = 0x00040000,
+    CHARACTER_FLAG_4_EXPANSION_TRIAL    = 0x00080000,
 };
 
 #define PLAYER_CUSTOM_DISPLAY_SIZE 3
@@ -1038,11 +1049,17 @@ enum Language
     LANG_PANDAREN_NEUTRAL  = 42,
     LANG_PANDAREN_ALLIANCE = 43,
     LANG_PANDAREN_HORDE    = 44,
-    LANG_RIKKITUN          = 168,
-    LANG_ADDON             = 0xFFFFFFFF // used by addons, in 2.4.0 not exist, replaced by messagetype?
+    LANG_SPRITE            = 168,
+    LANG_SHATH_YAR         = 178,
+    LANG_NERGLISH          = 179,
+    LANG_MOONKIN           = 180,
+    LANG_SHALASSIAN        = 181,
+    LANG_THALASSIAN_2      = 182,
+    LANG_ADDON             = 183,
+    LANG_ADDON_LOGGED      = 184
 };
 
-#define LANGUAGES_COUNT   25
+#define LANGUAGES_COUNT   31
 
 enum TeamId
 {
@@ -1266,7 +1283,7 @@ enum SpellEffectName
     SPELL_EFFECT_199                                = 199,
     SPELL_EFFECT_HEAL_BATTLEPET_PCT                 = 200, // NYI
     SPELL_EFFECT_ENABLE_BATTLE_PETS                 = 201, // NYI
-    SPELL_EFFECT_202                                = 202,
+    SPELL_EFFECT_202                                = 202, // some sort of apply aura effect
     SPELL_EFFECT_203                                = 203,
     SPELL_EFFECT_CHANGE_BATTLEPET_QUALITY           = 204,
     SPELL_EFFECT_LAUNCH_QUEST_CHOICE                = 205,
@@ -1320,7 +1337,13 @@ enum SpellEffectName
     SPELL_EFFECT_GIVE_HONOR                         = 253,
     SPELL_EFFECT_254                                = 254,
     SPELL_EFFECT_LEARN_TRANSMOG_SET                 = 255,
-    TOTAL_SPELL_EFFECTS                             = 256,
+    SPELL_EFFECT_256                                = 256,
+    SPELL_EFFECT_257                                = 257,
+    SPELL_EFFECT_MODIFY_KEYSTONE                    = 258,
+    SPELL_EFFECT_RESPEC_AZERITE_EMPOWERED_ITEM      = 259,
+    SPELL_EFFECT_SUMMON_STABLED_PET                 = 260,
+    SPELL_EFFECT_SCRAP_ITEM                         = 261,
+    TOTAL_SPELL_EFFECTS
 };
 
 enum SpellCastResult
@@ -1598,23 +1621,29 @@ enum SpellCastResult
     SPELL_FAILED_NOT_WHILE_MERCENARY                            = 270,
     SPELL_FAILED_SPEC_DISABLED                                  = 271,
     SPELL_FAILED_CANT_BE_OBLITERATED                            = 272,
-    SPELL_FAILED_FOLLOWER_CLASS_SPEC_CAP                        = 273,
-    SPELL_FAILED_TRANSPORT_NOT_READY                            = 274,
-    SPELL_FAILED_TRANSMOG_SET_ALREADY_KNOWN                     = 275,
-    SPELL_FAILED_DISABLED_BY_AURA_LABEL                         = 276,
-    SPELL_FAILED_DISABLED_BY_MAX_USABLE_LEVEL                   = 277,
-    SPELL_FAILED_SPELL_ALREADY_KNOWN                            = 278,
-    SPELL_FAILED_MUST_KNOW_SUPERCEDING_SPELL                    = 279,
-    SPELL_FAILED_YOU_CANNOT_USE_THAT_IN_PVP_INSTANCE            = 280,
-    SPELL_FAILED_NO_ARTIFACT_EQUIPPED                           = 281,
-    SPELL_FAILED_WRONG_ARTIFACT_EQUIPPED                        = 282,
-    SPELL_FAILED_TARGET_IS_UNTARGETABLE_BY_ANYONE               = 283,
-    SPELL_FAILED_SPELL_EFFECT_FAILED                            = 284,
-    SPELL_FAILED_NEED_ALL_PARTY_MEMBERS                         = 285,
-    SPELL_FAILED_ARTIFACT_AT_FULL_POWER                         = 286,
-    SPELL_FAILED_AP_ITEM_FROM_PREVIOUS_TIER                     = 287,
-    SPELL_FAILED_AREA_TRIGGER_CREATION                          = 288,
-    SPELL_FAILED_UNKNOWN                                        = 289,
+    SPELL_FAILED_CANT_BE_SCRAPPED                               = 273,
+    SPELL_FAILED_FOLLOWER_CLASS_SPEC_CAP                        = 274,
+    SPELL_FAILED_TRANSPORT_NOT_READY                            = 275,
+    SPELL_FAILED_TRANSMOG_SET_ALREADY_KNOWN                     = 276,
+    SPELL_FAILED_DISABLED_BY_AURA_LABEL                         = 277,
+    SPELL_FAILED_DISABLED_BY_MAX_USABLE_LEVEL                   = 278,
+    SPELL_FAILED_SPELL_ALREADY_KNOWN                            = 279,
+    SPELL_FAILED_MUST_KNOW_SUPERCEDING_SPELL                    = 280,
+    SPELL_FAILED_YOU_CANNOT_USE_THAT_IN_PVP_INSTANCE            = 281,
+    SPELL_FAILED_NO_ARTIFACT_EQUIPPED                           = 282,
+    SPELL_FAILED_WRONG_ARTIFACT_EQUIPPED                        = 283,
+    SPELL_FAILED_TARGET_IS_UNTARGETABLE_BY_ANYONE               = 284,
+    SPELL_FAILED_SPELL_EFFECT_FAILED                            = 285,
+    SPELL_FAILED_NEED_ALL_PARTY_MEMBERS                         = 286,
+    SPELL_FAILED_ARTIFACT_AT_FULL_POWER                         = 287,
+    SPELL_FAILED_AP_ITEM_FROM_PREVIOUS_TIER                     = 288,
+    SPELL_FAILED_AREA_TRIGGER_CREATION                          = 289,
+    SPELL_FAILED_AZERITE_EMPOWERED_ONLY                         = 290,
+    SPELL_FAILED_AZERITE_EMPOWERED_NO_CHOICES_TO_UNDO           = 291,
+    SPELL_FAILED_WRONG_FACTION                                  = 292,
+    SPELL_FAILED_NOT_ENOUGH_CURRENCY                            = 293,
+    SPELL_FAILED_BATTLE_FOR_AZEROTH_RIDING_REQUIREMENT          = 294,
+    SPELL_FAILED_UNKNOWN                                        = 295,
 
     // ok cast value - here in case a future version removes SPELL_FAILED_SUCCESS and we need to use a custom value (not sent to client either way)
     SPELL_CAST_OK                                               = SPELL_FAILED_SUCCESS
@@ -1941,6 +1970,7 @@ enum SpellCustomErrors
     SPELL_CUSTOM_ERROR_CANNOT_RITUAL_OF_DOOM_WHILE_SUMMONING_SITERS     = 317, // You cannot perform the Ritual of Doom while attempting to summon the sisters.
     SPELL_CUSTOM_ERROR_LEARNED_ALL_THAT_YOU_CAN_ABOUT_YOUR_ARTIFACT     = 318, // You have learned all that you can about your artifact.
     SPELL_CUSTOM_ERROR_CANT_CALL_PET_WITH_LONE_WOLF                     = 319, // You cannot use Call Pet while Lone Wolf is active.
+    SPELL_CUSTOM_ERROR_TARGET_CANNOT_ALREADY_HAVE_ORB_OF_POWER          = 320, // Target cannot already have a Orb of Power.
     SPELL_CUSTOM_ERROR_YOU_MUST_BE_IN_AN_INN_TO_STRUM_THAT_GUITAR       = 321, // You must be in an inn to strum that guitar.
     SPELL_CUSTOM_ERROR_YOU_CANNOT_REACH_THE_LATCH                       = 322, // You cannot reach the latch.
     SPELL_CUSTOM_ERROR_REQUIRES_A_BRIMMING_KEYSTONE                     = 323, // Requires a Brimming Keystone.
@@ -1959,22 +1989,41 @@ enum SpellCustomErrors
     SPELL_CUSTOM_ERROR_YOU_DO_NOT_KNOW_HOW_TO_TAME_FEATHERMANES         = 336, // You do not know how to tame Feathermanes.
     SPELL_CUSTOM_ERROR_YOU_MUST_REACH_ARTIFACT_KNOWLEDGE_LEVEL_25       = 337, // You must reach Artifact Knowledge level 25 to use the Tome.
     SPELL_CUSTOM_ERROR_REQUIRES_A_NETHER_PORTAL_DISRUPTOR               = 338, // Requires a Nether Portal Disruptor.
+    SPELL_CUSTOM_ERROR_YOU_ARE_NOT_THE_CORRECT_RANK_TO_USE_THIS_ITEM    = 339, // You are not the correct Rank to use this item.
     SPELL_CUSTOM_ERROR_MUST_BE_STANDING_NEAR_INJURED_CHROMIE_IN_MOUNT_HYJAL = 340, // Must be standing near the injured Chromie in Mount Hyjal.
+    SPELL_CUSTOM_ERROR_THERES_NOTHING_FURTHER_YOU_CAN_LEARN             = 341, // There's nothing further you can learn.
     SPELL_CUSTOM_ERROR_REMOVE_CANNONS_HEAVY_IRON_PLATING_FIRST          = 342, // You should remove the cannon's Heavy Iron Plating first.
     SPELL_CUSTOM_ERROR_REMOVE_CANNONS_ELECTROKINETIC_DEFENSE_GRID_FIRST = 343, // You should remove the cannon's Electrokinetic Defense Grid first.
     SPELL_CUSTOM_ERROR_REQUIRES_THE_ARMORY_KEY_AND_DENDRITE_CLUSTERS    = 344, // You are missing pieces of the Armory Key or do not have enough Dendrite Clusters.
     SPELL_CUSTOM_ERROR_THIS_ITEM_REQUIRES_BASIC_OBLITERUM_TO_UPGRADE    = 345, // This item requires basic Obliterum to upgrade.
     SPELL_CUSTOM_ERROR_THIS_ITEM_REQUIRES_PRIMAL_OBLITERUM_TO_UPGRADE   = 346, // This item requires Primal Obliterum to upgrade.
     SPELL_CUSTOM_ERROR_THIS_ITEM_REQUIRES_FLIGHT_MASTERS_WHISTLE        = 347, // This item requires a Flight Master's Whistle.
+    SPELL_CUSTOM_ERROR_REQUIRES_MORRISONS_MASTER_KEY                    = 348, // Requires Morrison's Master Key.
     SPELL_CUSTOM_ERROR_REQUIRES_POWER_THAT_ECHOES_THAT_OF_THE_AUGARI    = 349, // Will only open to one wielding the power that echoes that of the Augari.
     SPELL_CUSTOM_ERROR_THAT_PLAYER_HAS_A_PENDING_TOTEMIC_REVIVAL        = 350, // That player has a pending Totemic Revival.
     SPELL_CUSTOM_ERROR_YOU_HAVE_NO_FIRE_MINES_DEPLOYED                  = 351, // You have no Fire Mines deployed.
+    SPELL_CUSTOM_ERROR_MUST_BE_AFFECTED_BY_SPIRIT_POWDER                = 352, // You must be affected by the Spirit Powder to take the phylactery.
     SPELL_CUSTOM_ERROR_YOU_ARE_BLOCKED_BY_A_STRUCTURE_ABOVE_YOU         = 353, // You are blocked by a structure above you.
     SPELL_CUSTOM_ERROR_REQUIRES_100_IMP_MEAT                            = 354, // Requires 100 Imp Meat.
     SPELL_CUSTOM_ERROR_YOU_HAVE_NOT_OBTAINED_ANY_BACKGROUND_FILTERS     = 355, // You have not obtained any background filters.
     SPELL_CUSTOM_ERROR_NOTHING_INTERESTING_POSTED_HERE_RIGHT_NOW        = 356, // There is nothing interesting posted here right now.
     SPELL_CUSTOM_ERROR_PARAGON_REPUTATION_REQUIRES_HIGHER_LEVEL         = 357, // Paragon Reputation is not available until a higher level.
     SPELL_CUSTOM_ERROR_UUNA_IS_MISSING                                  = 358, // Uuna is missing.
+    SPELL_CUSTOM_ERROR_ONLY_OTHER_HIVEMIND_MEMBERS_MAY_JOIN             = 359, // Only other members of their Hivemind may join with them.
+    SPELL_CUSTOM_ERROR_NO_VALID_FLASK_PRESENT                           = 360, // No valid flask present.
+    SPELL_CUSTOM_ERROR_NO_WILD_IMPS_TO_SACRIFICE                        = 361, // There are no Wild Imps to sacrifice.
+    SPELL_CUSTOM_ERROR_YOU_ARE_CARRYING_TOO_MUCH_IRON                   = 362, // You are carrying too much Iron
+    SPELL_CUSTOM_ERROR_YOU_HAVE_NO_IRON_TO_COLLECT                      = 363, // You have no Iron to collect
+    SPELL_CUSTOM_ERROR_YOU_HAVE_NO_WILD_IMPS                            = 364, // You have no available Wild Imps.
+    SPELL_CUSTOM_ERROR_NEEDS_REPAIRS                                    = 365, // Needs repairs.
+    SPELL_CUSTOM_ERROR_YOU_ARE_CARRYING_TOO_MUCH_WOOD                   = 366, // You're carrying too much wood.
+    SPELL_CUSTOM_ERROR_YOU_ARE_ALREADY_CARRYING_REPAIR_PARTS            = 367, // You're already carrying repair parts.
+    SPELL_CUSTOM_ERROR_YOU_HAVE_NOT_UNLOCKED_FLIGHT_WHISTLE_FOR_ZONE    = 368, // You have not unlocked the Flight Whistle for this zone.
+    SPELL_CUSTOM_ERROR_THERE_ARE_NO_UNLOCKED_FLIGHT_POINTS_NEARBY       = 369, // There are no unlocked flight points nearby to take you to.
+    SPELL_CUSTOM_ERROR_YOU_MUST_HAVE_A_FELGUARD                         = 370, // You must have a Felguard.
+    SPELL_CUSTOM_ERROR_TARGET_HAS_NO_FESTERING_WOUNDS                   = 371, // The target has no Festering Wounds.
+    SPELL_CUSTOM_ERROR_YOU_DONT_HAVE_DEADLY_OR_WOUND_POISON_ACTIVE      = 372, // You do not have Deadly Poison or Wound Poison active.
+    SPELL_CUSTOM_ERROR_CANNOT_READ_SOLDIER_DOG_TAG_WITHOUT_HEADLAMP_ON  = 373, // You cannot read the soldier's dog tag without your headlamp on.
 };
 
 enum StealthType
@@ -2310,6 +2359,7 @@ enum Targets
     TARGET_UNK_147                     = 147,
     TARGET_UNK_148                     = 148,
     TARGET_UNK_149                     = 149,
+    TARGET_UNIT_OWN_CRITTER            = 150, // own battle pet from UNIT_FIELD_CRITTER
     TOTAL_SPELL_TARGETS
 };
 
@@ -2409,11 +2459,15 @@ enum GameobjectTypes : uint8
     GAMEOBJECT_TYPE_UI_LINK                     = 48,
     GAMEOBJECT_TYPE_KEYSTONE_RECEPTACLE         = 49,
     GAMEOBJECT_TYPE_GATHERING_NODE              = 50,
-    GAMEOBJECT_TYPE_CHALLENGE_MODE_REWARD       = 51
+    GAMEOBJECT_TYPE_CHALLENGE_MODE_REWARD       = 51,
+    GAMEOBJECT_TYPE_MULTI                       = 52,
+    GAMEOBJECT_TYPE_SIEGEABLE_MULTI             = 53,
+    GAMEOBJECT_TYPE_SIEGEABLE_MO                = 54,
+    GAMEOBJECT_TYPE_PVP_REWARD                  = 55,
 };
 
-#define MAX_GAMEOBJECT_TYPE                  52             // sending to client this or greater value can crash client.
-#define MAX_GAMEOBJECT_DATA                  33             // Max number of uint32 vars in gameobject_template data field
+#define MAX_GAMEOBJECT_TYPE                  56             // sending to client this or greater value can crash client.
+#define MAX_GAMEOBJECT_DATA                  34             // Max number of uint32 vars in gameobject_template data field
 
 enum GameObjectFlags
 {
@@ -3827,7 +3881,7 @@ enum LockKeyType
 // LockType.dbc (6.0.2.18988)
 enum LockType
 {
-    LOCKTYPE_PICKLOCK              = 1,
+    LOCKTYPE_LOCKPICKING           = 1,
     LOCKTYPE_HERBALISM             = 2,
     LOCKTYPE_MINING                = 3,
     LOCKTYPE_DISARM_TRAP           = 4,
@@ -3843,14 +3897,34 @@ enum LockType
     LOCKTYPE_OPEN_ATTACKING        = 14,
     LOCKTYPE_GAHZRIDIAN            = 15,
     LOCKTYPE_BLASTING              = 16,
-    LOCKTYPE_SLOW_OPEN             = 17,
-    LOCKTYPE_SLOW_CLOSE            = 18,
+    LOCKTYPE_PVP_OPEN              = 17,
+    LOCKTYPE_PVP_CLOSE             = 18,
     LOCKTYPE_FISHING               = 19,
     LOCKTYPE_INSCRIPTION           = 20,
     LOCKTYPE_OPEN_FROM_VEHICLE     = 21,
-    LOCKTYPE_ARCHAELOGY            = 22,
+    LOCKTYPE_ARCHAEOLOGY           = 22,
     LOCKTYPE_PVP_OPEN_FAST         = 23,
-    LOCKTYPE_LUMBER_MILL           = 28
+    LOCKTYPE_LUMBER_MILL           = 28,
+    LOCKTYPE_SKINNING              = 29,
+    LOCKTYPE_ANCIENT_MANA          = 30,
+    LOCKTYPE_WARBOARD              = 31,
+    LOCKTYPE_CLASSIC_HERBALISM     = 32,
+    LOCKTYPE_OUTLAND_HERBALISM     = 33,
+    LOCKTYPE_NORTHREND_HERBALISM   = 34,
+    LOCKTYPE_CATACLYSM_HERBALISM   = 35,
+    LOCKTYPE_PANDARIA_HERBALISM    = 36,
+    LOCKTYPE_DRAENOR_HERBALISM     = 37,
+    LOCKTYPE_LEGION_HERBALISM      = 38,
+    LOCKTYPE_KUL_TIRAN_HERBALISM   = 39,
+    LOCKTYPE_CLASSIC_MINING        = 40,
+    LOCKTYPE_OUTLAND_MINING        = 41,
+    LOCKTYPE_NORTHREND_MINING      = 42,
+    LOCKTYPE_CATACLYSM_MINING      = 43,
+    LOCKTYPE_PANDARIA_MINING       = 44,
+    LOCKTYPE_DRAENOR_MINING        = 45,
+    LOCKTYPE_LEGION_MINING         = 46,
+    LOCKTYPE_KUL_TIRAN_MINING      = 47,
+    LOCKTYPE_SKINNING_2            = 48
 };
 
 // this is important type for npcs!
@@ -4201,23 +4275,22 @@ enum SkillType
     SKILL_MACES                          = 54,
     SKILL_TWO_HANDED_SWORDS              = 55,
     SKILL_DEFENSE                        = 95,
-    SKILL_LANG_COMMON                    = 98,
+    SKILL_LANGUAGE_COMMON                = 98,
     SKILL_RACIAL_DWARF                   = 101,
-    SKILL_LANG_ORCISH                    = 109,
-    SKILL_LANG_DWARVEN                   = 111,
-    SKILL_LANG_DARNASSIAN                = 113,
-    SKILL_LANG_TAURAHE                   = 115,
+    SKILL_LANGUAGE_ORCISH                = 109,
+    SKILL_LANGUAGE_DWARVEN               = 111,
+    SKILL_LANGUAGE_DARNASSIAN            = 113,
+    SKILL_LANGUAGE_TAURAHE               = 115,
     SKILL_DUAL_WIELD                     = 118,
     SKILL_RACIAL_TAUREN                  = 124,
     SKILL_RACIAL_ORC                     = 125,
     SKILL_RACIAL_NIGHT_ELF               = 126,
-    SKILL_FIRST_AID                      = 129,
     SKILL_STAVES                         = 136,
-    SKILL_LANG_THALASSIAN                = 137,
-    SKILL_LANG_DRACONIC                  = 138,
-    SKILL_LANG_DEMON_TONGUE              = 139,
-    SKILL_LANG_TITAN                     = 140,
-    SKILL_LANG_OLD_TONGUE                = 141,
+    SKILL_LANGUAGE_THALASSIAN            = 137,
+    SKILL_LANGUAGE_DRACONIC              = 138,
+    SKILL_LANGUAGE_DEMON_TONGUE          = 139,
+    SKILL_LANGUAGE_TITAN                 = 140,
+    SKILL_LANGUAGE_OLD_TONGUE            = 141,
     SKILL_SURVIVAL                       = 142,
     SKILL_HORSE_RIDING                   = 148,
     SKILL_WOLF_RIDING                    = 149,
@@ -4262,8 +4335,8 @@ enum SkillType
     SKILL_PET_TURTLE                     = 251,
     SKILL_PET_GENERIC_HUNTER             = 270,
     SKILL_PLATE_MAIL                     = 293,
-    SKILL_LANG_GNOMISH                   = 313,
-    SKILL_LANG_TROLL                     = 315,
+    SKILL_LANGUAGE_GNOMISH               = 313,
+    SKILL_LANGUAGE_TROLL                 = 315,
     SKILL_ENCHANTING                     = 333,
     SKILL_FISHING                        = 356,
     SKILL_SKINNING                       = 393,
@@ -4279,7 +4352,7 @@ enum SkillType
     SKILL_PET_HYENA                      = 654,
     SKILL_PET_BIRD_OF_PREY               = 655,
     SKILL_PET_WIND_SERPENT               = 656,
-    SKILL_LANG_FORSAKEN                  = 673,
+    SKILL_LANGUAGE_FORSAKEN              = 673,
     SKILL_KODO_RIDING                    = 713,
     SKILL_RACIAL_TROLL                   = 733,
     SKILL_RACIAL_GNOME                   = 753,
@@ -4287,7 +4360,7 @@ enum SkillType
     SKILL_JEWELCRAFTING                  = 755,
     SKILL_RACIAL_BLOOD_ELF               = 756,
     SKILL_PET_EVENT_REMOTE_CONTROL       = 758,
-    SKILL_LANG_DRAENEI                   = 759,
+    SKILL_LANGUAGE_DRAENEI               = 759,
     SKILL_RACIAL_DRAENEI                 = 760,
     SKILL_PET_FELGUARD                   = 761,
     SKILL_RIDING                         = 762,
@@ -4313,8 +4386,8 @@ enum SkillType
     SKILL_PET_EXOTIC_SPIRIT_BEAST        = 788,
     SKILL_RACIAL_WORGEN                  = 789,
     SKILL_RACIAL_GOBLIN                  = 790,
-    SKILL_LANG_GILNEAN                   = 791,
-    SKILL_LANG_GOBLIN                    = 792,
+    SKILL_LANGUAGE_GILNEAN               = 791,
+    SKILL_LANGUAGE_GOBLIN                = 792,
     SKILL_ARCHAEOLOGY                    = 794,
     SKILL_HUNTER                         = 795,
     SKILL_DEATH_KNIGHT                   = 796,
@@ -4326,7 +4399,7 @@ enum SkillType
     SKILL_ALL_GLYPHS                     = 810,
     SKILL_PET_DOG                        = 811,
     SKILL_PET_MONKEY                     = 815,
-    SKILL_PET_SHALE_SPIDER               = 817,
+    SKILL_PET_EXOTIC_SHALE_SPIDER        = 817,
     SKILL_BEETLE                         = 818,
     SKILL_ALL_GUILD_PERKS                = 821,
     SKILL_PET_HYDRA                      = 824,
@@ -4335,9 +4408,7 @@ enum SkillType
     SKILL_WARLOCK                        = 849,
     SKILL_RACIAL_PANDAREN                = 899,
     SKILL_MAGE                           = 904,
-    SKILL_LANG_PANDAREN_NEUTRAL          = 905,
-    SKILL_LANG_PANDAREN_ALLIANCE         = 906,
-    SKILL_LANG_PANDAREN_HORDE            = 907,
+    SKILL_LANGUAGE_PANDAREN_NEUTRAL      = 905,
     SKILL_ROGUE                          = 921,
     SKILL_SHAMAN                         = 924,
     SKILL_FEL_IMP                        = 927,
@@ -4357,17 +4428,16 @@ enum SkillType
     SKILL_WAY_OF_THE_BREW                = 980,
     SKILL_APPRENTICE_COOKING             = 981,
     SKILL_JOURNEYMAN_COOKBOOK            = 982,
-    SKILL_PORCUPINE                      = 983,
-    SKILL_CRANE                          = 984,
-    SKILL_WATER_STRIDER                  = 985,
+    SKILL_PET_RODENT                     = 983,
+    SKILL_PET_CRANE                      = 984,
+    SKILL_PET_WATER_STRIDER              = 985,
     SKILL_PET_EXOTIC_QUILEN              = 986,
     SKILL_PET_GOAT                       = 987,
-    SKILL_BASILISK                       = 988,
+    SKILL_PET_BASILISK                   = 988,
     SKILL_NO_PLAYERS                     = 999,
-    SKILL_DIREHORN                       = 1305,
+    SKILL_PET_DIREHORN                   = 1305,
     SKILL_PET_PRIMAL_STORM_ELEMENTAL     = 1748,
     SKILL_PET_WATER_ELEMENTAL_MINOR_TALENT_VERSION = 1777,
-    SKILL_PET_EXOTIC_RYLAK               = 1818,
     SKILL_PET_RIVERBEAST                 = 1819,
     SKILL_UNUSED                         = 1830,
     SKILL_DEMON_HUNTER                   = 1848,
@@ -4379,6 +4449,127 @@ enum SkillType
     SKILL_WARGLAIVES                     = 2152,
     SKILL_PET_MECHANICAL                 = 2189,
     SKILL_PET_ABOMINATION                = 2216,
+    SKILL_PET_OXEN                       = 2279,
+    SKILL_PET_SCALEHIDE                  = 2280,
+    SKILL_PET_FEATHERMANE                = 2361,
+    SKILL_RACIAL_NIGHTBORNE              = 2419,
+    SKILL_RACIAL_HIGHMOUNTAIN_TAUREN     = 2420,
+    SKILL_RACIAL_LIGHTFORGED_DRAENEI     = 2421,
+    SKILL_RACIAL_VOID_ELF                = 2423,
+    SKILL_KUL_TIRAN_BLACKSMITHING        = 2437,
+    SKILL_LEGION_BLACKSMITHING           = 2454,
+    SKILL_LANGUAGE_SHALASSIAN            = 2464,
+    SKILL_LANGUAGE_THALASSIAN_2          = 2465,
+    SKILL_DRAENOR_BLACKSMITHING          = 2472,
+    SKILL_PANDARIA_BLACKSMITHING         = 2473,
+    SKILL_CATACLYSM_BLACKSMITHING        = 2474,
+    SKILL_NORTHREND_BLACKSMITHING        = 2475,
+    SKILL_OUTLAND_BLACKSMITHING          = 2476,
+    SKILL_BLACKSMITHING_2                = 2477,
+    SKILL_KUL_TIRAN_ALCHEMY              = 2478,
+    SKILL_LEGION_ALCHEMY                 = 2479,
+    SKILL_DRAENOR_ALCHEMY                = 2480,
+    SKILL_PANDARIA_ALCHEMY               = 2481,
+    SKILL_CATACLYSM_ALCHEMY              = 2482,
+    SKILL_NORTHREND_ALCHEMY              = 2483,
+    SKILL_OUTLAND_ALCHEMY                = 2484,
+    SKILL_ALCHEMY_2                      = 2485,
+    SKILL_KUL_TIRAN_ENCHANTING           = 2486,
+    SKILL_LEGION_ENCHANTING              = 2487,
+    SKILL_DRAENOR_ENCHANTING             = 2488,
+    SKILL_PANDARIA_ENCHANTING            = 2489,
+    SKILL_CATACLYSM_ENCHANTING           = 2491,
+    SKILL_NORTHREND_ENCHANTING           = 2492,
+    SKILL_OUTLAND_ENCHANTING             = 2493,
+    SKILL_ENCHANTING_2                   = 2494,
+    SKILL_KUL_TIRAN_ENGINEERING          = 2499,
+    SKILL_LEGION_ENGINEERING             = 2500,
+    SKILL_DRAENOR_ENGINEERING            = 2501,
+    SKILL_PANDARIA_ENGINEERING           = 2502,
+    SKILL_CATACLYSM_ENGINEERING          = 2503,
+    SKILL_NORTHREND_ENGINEERING          = 2504,
+    SKILL_OUTLAND_ENGINEERING            = 2505,
+    SKILL_ENGINEERING_2                  = 2506,
+    SKILL_KUL_TIRAN_INSCRIPTION          = 2507,
+    SKILL_LEGION_INSCRIPTION             = 2508,
+    SKILL_DRAENOR_INSCRIPTION            = 2509,
+    SKILL_PANDARIA_INSCRIPTION           = 2510,
+    SKILL_CATACLYSM_INSCRIPTION          = 2511,
+    SKILL_NORTHREND_INSCRIPTION          = 2512,
+    SKILL_OUTLAND_INSCRIPTION            = 2513,
+    SKILL_INSCRIPTION_2                  = 2514,
+    SKILL_KUL_TIRAN_JEWELCRAFTING        = 2517,
+    SKILL_LEGION_JEWELCRAFTING           = 2518,
+    SKILL_DRAENOR_JEWELCRAFTING          = 2519,
+    SKILL_PANDARIA_JEWELCRAFTING         = 2520,
+    SKILL_CATACLYSM_JEWELCRAFTING        = 2521,
+    SKILL_NORTHREND_JEWELCRAFTING        = 2522,
+    SKILL_OUTLAND_JEWELCRAFTING          = 2523,
+    SKILL_JEWELCRAFTING_2                = 2524,
+    SKILL_KUL_TIRAN_LEATHERWORKING       = 2525,
+    SKILL_LEGION_LEATHERWORKING          = 2526,
+    SKILL_DRAENOR_LEATHERWORKING         = 2527,
+    SKILL_PANDARIA_LEATHERWORKING        = 2528,
+    SKILL_CATACLYSM_LEATHERWORKING       = 2529,
+    SKILL_NORTHREND_LEATHERWORKING       = 2530,
+    SKILL_OUTLAND_LEATHERWORKING         = 2531,
+    SKILL_LEATHERWORKING_2               = 2532,
+    SKILL_KUL_TIRAN_TAILORING            = 2533,
+    SKILL_LEGION_TAILORING               = 2534,
+    SKILL_DRAENOR_TAILORING              = 2535,
+    SKILL_PANDARIA_TAILORING             = 2536,
+    SKILL_CATACLYSM_TAILORING            = 2537,
+    SKILL_NORTHREND_TAILORING            = 2538,
+    SKILL_OUTLAND_TAILORING              = 2539,
+    SKILL_TAILORING_2                    = 2540,
+    SKILL_KUL_TIRAN_COOKING              = 2541,
+    SKILL_LEGION_COOKING                 = 2542,
+    SKILL_DRAENOR_COOKING                = 2543,
+    SKILL_PANDARIA_COOKING               = 2544,
+    SKILL_CATACLYSM_COOKING              = 2545,
+    SKILL_NORTHREND_COOKING              = 2546,
+    SKILL_OUTLAND_COOKING                = 2547,
+    SKILL_COOKING_2                      = 2548,
+    SKILL_KUL_TIRAN_HERBALISM            = 2549,
+    SKILL_LEGION_HERBALISM               = 2550,
+    SKILL_DRAENOR_HERBALISM              = 2551,
+    SKILL_PANDARIA_HERBALISM             = 2552,
+    SKILL_CATACLYSM_HERBALISM            = 2553,
+    SKILL_NORTHREND_HERBALISM            = 2554,
+    SKILL_OUTLAND_HERBALISM              = 2555,
+    SKILL_HERBALISM_2                    = 2556,
+    SKILL_KUL_TIRAN_SKINNING             = 2557,
+    SKILL_LEGION_SKINNING                = 2558,
+    SKILL_DRAENOR_SKINNING               = 2559,
+    SKILL_PANDARIA_SKINNING              = 2560,
+    SKILL_CATACLYSM_SKINNING             = 2561,
+    SKILL_NORTHREND_SKINNING             = 2562,
+    SKILL_OUTLAND_SKINNING               = 2563,
+    SKILL_SKINNING_2                     = 2564,
+    SKILL_KUL_TIRAN_MINING               = 2565,
+    SKILL_LEGION_MINING                  = 2566,
+    SKILL_DRAENOR_MINING                 = 2567,
+    SKILL_PANDARIA_MINING                = 2568,
+    SKILL_CATACLYSM_MINING               = 2569,
+    SKILL_NORTHREND_MINING               = 2570,
+    SKILL_OUTLAND_MINING                 = 2571,
+    SKILL_MINING_2                       = 2572,
+    SKILL_KUL_TIRAN_FISHING              = 2585,
+    SKILL_LEGION_FISHING                 = 2586,
+    SKILL_DRAENOR_FISHING                = 2587,
+    SKILL_PANDARIA_FISHING               = 2588,
+    SKILL_CATACLYSM_FISHING              = 2589,
+    SKILL_NORTHREND_FISHING              = 2590,
+    SKILL_OUTLAND_FISHING                = 2591,
+    SKILL_FISHING_2                      = 2592,
+    SKILL_RACIAL_DARK_IRON_DWARF         = 2597,
+    SKILL_RACIAL_MAG_HAR_ORC             = 2598,
+    SKILL_PET_LIZARD                     = 2703,
+    SKILL_PET_HORSE                      = 2704,
+    SKILL_PET_EXOTIC_PTERRORDAX          = 2705,
+    SKILL_PET_TOAD                       = 2706,
+    SKILL_PET_EXOTIC_KROLUSK             = 2707,
+    SKILL_SECOND_PET_HUNTER              = 2716
 };
 
 inline SkillType SkillByLockType(LockType locktype)
@@ -4389,8 +4580,24 @@ inline SkillType SkillByLockType(LockType locktype)
         case LOCKTYPE_MINING:      return SKILL_MINING;
         case LOCKTYPE_FISHING:     return SKILL_FISHING;
         case LOCKTYPE_INSCRIPTION: return SKILL_INSCRIPTION;
-        case LOCKTYPE_ARCHAELOGY:  return SKILL_ARCHAEOLOGY;
+        case LOCKTYPE_ARCHAEOLOGY: return SKILL_ARCHAEOLOGY;
         case LOCKTYPE_LUMBER_MILL: return SKILL_LOGGING;
+        case LOCKTYPE_CLASSIC_HERBALISM: return SKILL_HERBALISM_2;
+        case LOCKTYPE_OUTLAND_HERBALISM: return SKILL_OUTLAND_HERBALISM;
+        case LOCKTYPE_NORTHREND_HERBALISM: return SKILL_NORTHREND_HERBALISM;
+        case LOCKTYPE_CATACLYSM_HERBALISM: return SKILL_CATACLYSM_HERBALISM;
+        case LOCKTYPE_PANDARIA_HERBALISM: return SKILL_PANDARIA_HERBALISM;
+        case LOCKTYPE_DRAENOR_HERBALISM: return SKILL_DRAENOR_HERBALISM;
+        case LOCKTYPE_LEGION_HERBALISM: return SKILL_LEGION_HERBALISM;
+        case LOCKTYPE_KUL_TIRAN_HERBALISM: return SKILL_KUL_TIRAN_HERBALISM;
+        case LOCKTYPE_CLASSIC_MINING: return SKILL_MINING_2;
+        case LOCKTYPE_OUTLAND_MINING: return SKILL_OUTLAND_MINING;
+        case LOCKTYPE_NORTHREND_MINING: return SKILL_NORTHREND_MINING;
+        case LOCKTYPE_CATACLYSM_MINING: return SKILL_CATACLYSM_MINING;
+        case LOCKTYPE_PANDARIA_MINING: return SKILL_PANDARIA_MINING;
+        case LOCKTYPE_DRAENOR_MINING: return SKILL_DRAENOR_MINING;
+        case LOCKTYPE_LEGION_MINING: return SKILL_LEGION_MINING;
+        case LOCKTYPE_KUL_TIRAN_MINING: return SKILL_KUL_TIRAN_MINING;
         default: break;
     }
     return SKILL_NONE;
@@ -4408,7 +4615,6 @@ inline uint32 SkillByQuestSort(int32 QuestSort)
         case QUEST_SORT_ENGINEERING:    return SKILL_ENGINEERING;
         case QUEST_SORT_TAILORING:      return SKILL_TAILORING;
         case QUEST_SORT_COOKING:        return SKILL_COOKING;
-        case QUEST_SORT_FIRST_AID:      return SKILL_FIRST_AID;
         case QUEST_SORT_JEWELCRAFTING:  return SKILL_JEWELCRAFTING;
         case QUEST_SORT_INSCRIPTION:    return SKILL_INSCRIPTION;
         case QUEST_SORT_ARCHAEOLOGY:    return SKILL_ARCHAEOLOGY;
@@ -4500,9 +4706,9 @@ enum WeatherType
 
 #define MAX_WEATHER_TYPE 4
 
-enum ChatMsg
+enum ChatMsg : int32
 {
-    CHAT_MSG_ADDON                              = 0xFFFFFFFF, // -1
+    CHAT_MSG_ADDON                              = -1,
     CHAT_MSG_SYSTEM                             = 0x00,
     CHAT_MSG_SAY                                = 0x01,
     CHAT_MSG_PARTY                              = 0x02,
@@ -4755,52 +4961,54 @@ enum ResponseCodes
     CHAR_CREATE_THROTTLE                                   = 49,
     CHAR_CREATE_ALLIED_RACE_ACHIEVEMENT                    = 50,
     CHAR_CREATE_LEVEL_REQUIREMENT_DEMON_HUNTER             = 51,
-
-    CHAR_DELETE_IN_PROGRESS                                = 52,
-    CHAR_DELETE_SUCCESS                                    = 53,
-    CHAR_DELETE_FAILED                                     = 54,
-    CHAR_DELETE_FAILED_LOCKED_FOR_TRANSFER                 = 55,
-    CHAR_DELETE_FAILED_GUILD_LEADER                        = 56,
-    CHAR_DELETE_FAILED_ARENA_CAPTAIN                       = 57,
-    CHAR_DELETE_FAILED_HAS_HEIRLOOM_OR_MAIL                = 58,
-    CHAR_DELETE_FAILED_UPGRADE_IN_PROGRESS                 = 59,
-    CHAR_DELETE_FAILED_HAS_WOW_TOKEN                       = 60,
-    CHAR_DELETE_FAILED_VAS_TRANSACTION_IN_PROGRESS         = 61,
-
-    CHAR_LOGIN_IN_PROGRESS                                 = 62,
-    CHAR_LOGIN_SUCCESS                                     = 63,
-    CHAR_LOGIN_NO_WORLD                                    = 64,
-    CHAR_LOGIN_DUPLICATE_CHARACTER                         = 65,
-    CHAR_LOGIN_NO_INSTANCES                                = 66,
-    CHAR_LOGIN_FAILED                                      = 67,
-    CHAR_LOGIN_DISABLED                                    = 68,
-    CHAR_LOGIN_NO_CHARACTER                                = 69,
-    CHAR_LOGIN_LOCKED_FOR_TRANSFER                         = 70,
-    CHAR_LOGIN_LOCKED_BY_BILLING                           = 71,
-    CHAR_LOGIN_LOCKED_BY_MOBILE_AH                         = 72,
-    CHAR_LOGIN_TEMPORARY_GM_LOCK                           = 73,
-    CHAR_LOGIN_LOCKED_BY_CHARACTER_UPGRADE                 = 74,
-    CHAR_LOGIN_LOCKED_BY_REVOKED_CHARACTER_UPGRADE         = 75,
-    CHAR_LOGIN_LOCKED_BY_REVOKED_VAS_TRANSACTION           = 76,
-    CHAR_LOGIN_LOCKED_BY_RESTRICTION                       = 77,
-
-    CHAR_NAME_SUCCESS                                      = 78,
-    CHAR_NAME_FAILURE                                      = 79,
-    CHAR_NAME_NO_NAME                                      = 80,
-    CHAR_NAME_TOO_SHORT                                    = 81,
-    CHAR_NAME_TOO_LONG                                     = 82,
-    CHAR_NAME_INVALID_CHARACTER                            = 83,
-    CHAR_NAME_MIXED_LANGUAGES                              = 84,
-    CHAR_NAME_PROFANE                                      = 85,
-    CHAR_NAME_RESERVED                                     = 86,
-    CHAR_NAME_INVALID_APOSTROPHE                           = 87,
-    CHAR_NAME_MULTIPLE_APOSTROPHES                         = 88,
-    CHAR_NAME_THREE_CONSECUTIVE                            = 89,
-    CHAR_NAME_INVALID_SPACE                                = 90,
-    CHAR_NAME_CONSECUTIVE_SPACES                           = 91,
-    CHAR_NAME_RUSSIAN_CONSECUTIVE_SILENT_CHARACTERS        = 92,
-    CHAR_NAME_RUSSIAN_SILENT_CHARACTER_AT_BEGINNING_OR_END = 93,
-    CHAR_NAME_DECLENSION_DOESNT_MATCH_BASE_NAME            = 94
+    CHAR_CREATE_CHARACTER_IN_COMMUNITY                     = 52,
+
+    CHAR_DELETE_IN_PROGRESS                                = 53,
+    CHAR_DELETE_SUCCESS                                    = 54,
+    CHAR_DELETE_FAILED                                     = 55,
+    CHAR_DELETE_FAILED_LOCKED_FOR_TRANSFER                 = 56,
+    CHAR_DELETE_FAILED_GUILD_LEADER                        = 57,
+    CHAR_DELETE_FAILED_ARENA_CAPTAIN                       = 58,
+    CHAR_DELETE_FAILED_HAS_HEIRLOOM_OR_MAIL                = 59,
+    CHAR_DELETE_FAILED_UPGRADE_IN_PROGRESS                 = 60,
+    CHAR_DELETE_FAILED_HAS_WOW_TOKEN                       = 61,
+    CHAR_DELETE_FAILED_VAS_TRANSACTION_IN_PROGRESS         = 62,
+    CHAR_DELETE_FAILED_COMMUNITY_OWNER                     = 63,
+
+    CHAR_LOGIN_IN_PROGRESS                                 = 64,
+    CHAR_LOGIN_SUCCESS                                     = 65,
+    CHAR_LOGIN_NO_WORLD                                    = 66,
+    CHAR_LOGIN_DUPLICATE_CHARACTER                         = 67,
+    CHAR_LOGIN_NO_INSTANCES                                = 68,
+    CHAR_LOGIN_FAILED                                      = 69,
+    CHAR_LOGIN_DISABLED                                    = 70,
+    CHAR_LOGIN_NO_CHARACTER                                = 71,
+    CHAR_LOGIN_LOCKED_FOR_TRANSFER                         = 72,
+    CHAR_LOGIN_LOCKED_BY_BILLING                           = 73,
+    CHAR_LOGIN_LOCKED_BY_MOBILE_AH                         = 74,
+    CHAR_LOGIN_TEMPORARY_GM_LOCK                           = 75,
+    CHAR_LOGIN_LOCKED_BY_CHARACTER_UPGRADE                 = 76,
+    CHAR_LOGIN_LOCKED_BY_REVOKED_CHARACTER_UPGRADE         = 77,
+    CHAR_LOGIN_LOCKED_BY_REVOKED_VAS_TRANSACTION           = 78,
+    CHAR_LOGIN_LOCKED_BY_RESTRICTION                       = 79,
+
+    CHAR_NAME_SUCCESS                                      = 80,
+    CHAR_NAME_FAILURE                                      = 81,
+    CHAR_NAME_NO_NAME                                      = 82,
+    CHAR_NAME_TOO_SHORT                                    = 83,
+    CHAR_NAME_TOO_LONG                                     = 84,
+    CHAR_NAME_INVALID_CHARACTER                            = 85,
+    CHAR_NAME_MIXED_LANGUAGES                              = 86,
+    CHAR_NAME_PROFANE                                      = 87,
+    CHAR_NAME_RESERVED                                     = 88,
+    CHAR_NAME_INVALID_APOSTROPHE                           = 89,
+    CHAR_NAME_MULTIPLE_APOSTROPHES                         = 90,
+    CHAR_NAME_THREE_CONSECUTIVE                            = 91,
+    CHAR_NAME_INVALID_SPACE                                = 92,
+    CHAR_NAME_CONSECUTIVE_SPACES                           = 93,
+    CHAR_NAME_RUSSIAN_CONSECUTIVE_SILENT_CHARACTERS        = 94,
+    CHAR_NAME_RUSSIAN_SILENT_CHARACTER_AT_BEGINNING_OR_END = 95,
+    CHAR_NAME_DECLENSION_DOESNT_MATCH_BASE_NAME            = 96
 };
 
 enum CharacterUndeleteResult
@@ -5393,842 +5601,864 @@ enum class GameError : uint32
     ERR_OUT_OF_RANGE                                        = 149,
     ERR_PLAYER_DEAD                                         = 150,
     ERR_CLIENT_LOCKED_OUT                                   = 151,
-    ERR_KILLED_BY_S                                         = 152,
-    ERR_LOOT_LOCKED                                         = 153,
-    ERR_LOOT_TOO_FAR                                        = 154,
-    ERR_LOOT_DIDNT_KILL                                     = 155,
-    ERR_LOOT_BAD_FACING                                     = 156,
-    ERR_LOOT_NOTSTANDING                                    = 157,
-    ERR_LOOT_STUNNED                                        = 158,
-    ERR_LOOT_NO_UI                                          = 159,
-    ERR_LOOT_WHILE_INVULNERABLE                             = 160,
-    ERR_NO_LOOT                                             = 161,
-    ERR_QUEST_ACCEPTED_S                                    = 162,
-    ERR_QUEST_COMPLETE_S                                    = 163,
-    ERR_QUEST_FAILED_S                                      = 164,
-    ERR_QUEST_FAILED_BAG_FULL_S                             = 165,
-    ERR_QUEST_FAILED_MAX_COUNT_S                            = 166,
-    ERR_QUEST_FAILED_LOW_LEVEL                              = 167,
-    ERR_QUEST_FAILED_MISSING_ITEMS                          = 168,
-    ERR_QUEST_FAILED_WRONG_RACE                             = 169,
-    ERR_QUEST_FAILED_NOT_ENOUGH_MONEY                       = 170,
-    ERR_QUEST_FAILED_EXPANSION                              = 171,
-    ERR_QUEST_ONLY_ONE_TIMED                                = 172,
-    ERR_QUEST_NEED_PREREQS                                  = 173,
-    ERR_QUEST_NEED_PREREQS_CUSTOM                           = 174,
-    ERR_QUEST_ALREADY_ON                                    = 175,
-    ERR_QUEST_ALREADY_DONE                                  = 176,
-    ERR_QUEST_ALREADY_DONE_DAILY                            = 177,
-    ERR_QUEST_HAS_IN_PROGRESS                               = 178,
-    ERR_QUEST_REWARD_EXP_I                                  = 179,
-    ERR_QUEST_REWARD_MONEY_S                                = 180,
-    ERR_QUEST_MUST_CHOOSE                                   = 181,
-    ERR_QUEST_LOG_FULL                                      = 182,
-    ERR_COMBAT_DAMAGE_SSI                                   = 183,
-    ERR_INSPECT_S                                           = 184,
-    ERR_CANT_USE_ITEM                                       = 185,
-    ERR_CANT_USE_ITEM_IN_ARENA                              = 186,
-    ERR_CANT_USE_ITEM_IN_RATED_BATTLEGROUND                 = 187,
-    ERR_MUST_EQUIP_ITEM                                     = 188,
-    ERR_PASSIVE_ABILITY                                     = 189,
-    ERR_2HSKILLNOTFOUND                                     = 190,
-    ERR_NO_ATTACK_TARGET                                    = 191,
-    ERR_INVALID_ATTACK_TARGET                               = 192,
-    ERR_ATTACK_PVP_TARGET_WHILE_UNFLAGGED                   = 193,
-    ERR_ATTACK_STUNNED                                      = 194,
-    ERR_ATTACK_PACIFIED                                     = 195,
-    ERR_ATTACK_MOUNTED                                      = 196,
-    ERR_ATTACK_FLEEING                                      = 197,
-    ERR_ATTACK_CONFUSED                                     = 198,
-    ERR_ATTACK_CHARMED                                      = 199,
-    ERR_ATTACK_DEAD                                         = 200,
-    ERR_ATTACK_PREVENTED_BY_MECHANIC_S                      = 201,
-    ERR_ATTACK_CHANNEL                                      = 202,
-    ERR_TAXISAMENODE                                        = 203,
-    ERR_TAXINOSUCHPATH                                      = 204,
-    ERR_TAXIUNSPECIFIEDSERVERERROR                          = 205,
-    ERR_TAXINOTENOUGHMONEY                                  = 206,
-    ERR_TAXITOOFARAWAY                                      = 207,
-    ERR_TAXINOVENDORNEARBY                                  = 208,
-    ERR_TAXINOTVISITED                                      = 209,
-    ERR_TAXIPLAYERBUSY                                      = 210,
-    ERR_TAXIPLAYERALREADYMOUNTED                            = 211,
-    ERR_TAXIPLAYERSHAPESHIFTED                              = 212,
-    ERR_TAXIPLAYERMOVING                                    = 213,
-    ERR_TAXINOPATHS                                         = 214,
-    ERR_TAXINOTELIGIBLE                                     = 215,
-    ERR_TAXINOTSTANDING                                     = 216,
-    ERR_NO_REPLY_TARGET                                     = 217,
-    ERR_GENERIC_NO_TARGET                                   = 218,
-    ERR_INITIATE_TRADE_S                                    = 219,
-    ERR_TRADE_REQUEST_S                                     = 220,
-    ERR_TRADE_BLOCKED_S                                     = 221,
-    ERR_TRADE_TARGET_DEAD                                   = 222,
-    ERR_TRADE_TOO_FAR                                       = 223,
-    ERR_TRADE_CANCELLED                                     = 224,
-    ERR_TRADE_COMPLETE                                      = 225,
-    ERR_TRADE_BAG_FULL                                      = 226,
-    ERR_TRADE_TARGET_BAG_FULL                               = 227,
-    ERR_TRADE_MAX_COUNT_EXCEEDED                            = 228,
-    ERR_TRADE_TARGET_MAX_COUNT_EXCEEDED                     = 229,
-    ERR_ALREADY_TRADING                                     = 230,
-    ERR_MOUNT_INVALIDMOUNTEE                                = 231,
-    ERR_MOUNT_TOOFARAWAY                                    = 232,
-    ERR_MOUNT_ALREADYMOUNTED                                = 233,
-    ERR_MOUNT_NOTMOUNTABLE                                  = 234,
-    ERR_MOUNT_NOTYOURPET                                    = 235,
-    ERR_MOUNT_OTHER                                         = 236,
-    ERR_MOUNT_LOOTING                                       = 237,
-    ERR_MOUNT_RACECANTMOUNT                                 = 238,
-    ERR_MOUNT_SHAPESHIFTED                                  = 239,
-    ERR_MOUNT_NO_FAVORITES                                  = 240,
-    ERR_DISMOUNT_NOPET                                      = 241,
-    ERR_DISMOUNT_NOTMOUNTED                                 = 242,
-    ERR_DISMOUNT_NOTYOURPET                                 = 243,
-    ERR_SPELL_FAILED_TOTEMS                                 = 244,
-    ERR_SPELL_FAILED_REAGENTS                               = 245,
-    ERR_SPELL_FAILED_REAGENTS_GENERIC                       = 246,
-    ERR_SPELL_FAILED_EQUIPPED_ITEM                          = 247,
-    ERR_SPELL_FAILED_EQUIPPED_ITEM_CLASS_S                  = 248,
-    ERR_SPELL_FAILED_SHAPESHIFT_FORM_S                      = 249,
-    ERR_SPELL_FAILED_ANOTHER_IN_PROGRESS                    = 250,
-    ERR_BADATTACKFACING                                     = 251,
-    ERR_BADATTACKPOS                                        = 252,
-    ERR_CHEST_IN_USE                                        = 253,
-    ERR_USE_CANT_OPEN                                       = 254,
-    ERR_USE_LOCKED                                          = 255,
-    ERR_DOOR_LOCKED                                         = 256,
-    ERR_BUTTON_LOCKED                                       = 257,
-    ERR_USE_LOCKED_WITH_ITEM_S                              = 258,
-    ERR_USE_LOCKED_WITH_SPELL_S                             = 259,
-    ERR_USE_LOCKED_WITH_SPELL_KNOWN_SI                      = 260,
-    ERR_USE_TOO_FAR                                         = 261,
-    ERR_USE_BAD_ANGLE                                       = 262,
-    ERR_USE_OBJECT_MOVING                                   = 263,
-    ERR_USE_SPELL_FOCUS                                     = 264,
-    ERR_USE_DESTROYED                                       = 265,
-    ERR_SET_LOOT_FREEFORALL                                 = 266,
-    ERR_SET_LOOT_ROUNDROBIN                                 = 267,
-    ERR_SET_LOOT_MASTER                                     = 268,
-    ERR_SET_LOOT_GROUP                                      = 269,
-    ERR_SET_LOOT_THRESHOLD_S                                = 270,
-    ERR_NEW_LOOT_MASTER_S                                   = 271,
-    ERR_SPECIFY_MASTER_LOOTER                               = 272,
-    ERR_LOOT_SPEC_CHANGED_S                                 = 273,
-    ERR_TAME_FAILED                                         = 274,
-    ERR_CHAT_WHILE_DEAD                                     = 275,
-    ERR_CHAT_PLAYER_NOT_FOUND_S                             = 276,
-    ERR_NEWTAXIPATH                                         = 277,
-    ERR_NO_PET                                              = 278,
-    ERR_NOTYOURPET                                          = 279,
-    ERR_PET_NOT_RENAMEABLE                                  = 280,
-    ERR_QUEST_OBJECTIVE_COMPLETE_S                          = 281,
-    ERR_QUEST_UNKNOWN_COMPLETE                              = 282,
-    ERR_QUEST_ADD_KILL_SII                                  = 283,
-    ERR_QUEST_ADD_FOUND_SII                                 = 284,
-    ERR_QUEST_ADD_ITEM_SII                                  = 285,
-    ERR_QUEST_ADD_PLAYER_KILL_SII                           = 286,
-    ERR_CANNOTCREATEDIRECTORY                               = 287,
-    ERR_CANNOTCREATEFILE                                    = 288,
-    ERR_PLAYER_WRONG_FACTION                                = 289,
-    ERR_PLAYER_IS_NEUTRAL                                   = 290,
-    ERR_BANKSLOT_FAILED_TOO_MANY                            = 291,
-    ERR_BANKSLOT_INSUFFICIENT_FUNDS                         = 292,
-    ERR_BANKSLOT_NOTBANKER                                  = 293,
-    ERR_FRIEND_DB_ERROR                                     = 294,
-    ERR_FRIEND_LIST_FULL                                    = 295,
-    ERR_FRIEND_ADDED_S                                      = 296,
-    ERR_BATTLETAG_FRIEND_ADDED_S                            = 297,
-    ERR_FRIEND_ONLINE_SS                                    = 298,
-    ERR_FRIEND_OFFLINE_S                                    = 299,
-    ERR_FRIEND_NOT_FOUND                                    = 300,
-    ERR_FRIEND_WRONG_FACTION                                = 301,
-    ERR_FRIEND_REMOVED_S                                    = 302,
-    ERR_BATTLETAG_FRIEND_REMOVED_S                          = 303,
-    ERR_FRIEND_ERROR                                        = 304,
-    ERR_FRIEND_ALREADY_S                                    = 305,
-    ERR_FRIEND_SELF                                         = 306,
-    ERR_FRIEND_DELETED                                      = 307,
-    ERR_IGNORE_FULL                                         = 308,
-    ERR_IGNORE_SELF                                         = 309,
-    ERR_IGNORE_NOT_FOUND                                    = 310,
-    ERR_IGNORE_ALREADY_S                                    = 311,
-    ERR_IGNORE_ADDED_S                                      = 312,
-    ERR_IGNORE_REMOVED_S                                    = 313,
-    ERR_IGNORE_AMBIGUOUS                                    = 314,
-    ERR_IGNORE_DELETED                                      = 315,
-    ERR_ONLY_ONE_BOLT                                       = 316,
-    ERR_ONLY_ONE_AMMO                                       = 317,
-    ERR_SPELL_FAILED_EQUIPPED_SPECIFIC_ITEM                 = 318,
-    ERR_WRONG_BAG_TYPE_SUBCLASS                             = 319,
-    ERR_CANT_WRAP_STACKABLE                                 = 320,
-    ERR_CANT_WRAP_EQUIPPED                                  = 321,
-    ERR_CANT_WRAP_WRAPPED                                   = 322,
-    ERR_CANT_WRAP_BOUND                                     = 323,
-    ERR_CANT_WRAP_UNIQUE                                    = 324,
-    ERR_CANT_WRAP_BAGS                                      = 325,
-    ERR_OUT_OF_MANA                                         = 326,
-    ERR_OUT_OF_RAGE                                         = 327,
-    ERR_OUT_OF_FOCUS                                        = 328,
-    ERR_OUT_OF_ENERGY                                       = 329,
-    ERR_OUT_OF_CHI                                          = 330,
-    ERR_OUT_OF_HEALTH                                       = 331,
-    ERR_OUT_OF_RUNES                                        = 332,
-    ERR_OUT_OF_RUNIC_POWER                                  = 333,
-    ERR_OUT_OF_SOUL_SHARDS                                  = 334,
-    ERR_OUT_OF_LUNAR_POWER                                  = 335,
-    ERR_OUT_OF_HOLY_POWER                                   = 336,
-    ERR_OUT_OF_MAELSTROM                                    = 337,
-    ERR_OUT_OF_COMBO_POINTS                                 = 338,
-    ERR_OUT_OF_INSANITY                                     = 339,
-    ERR_OUT_OF_ARCANE_CHARGES                               = 340,
-    ERR_OUT_OF_FURY                                         = 341,
-    ERR_OUT_OF_PAIN                                         = 342,
-    ERR_OUT_OF_POWER_DISPLAY                                = 343,
-    ERR_LOOT_GONE                                           = 344,
-    ERR_MOUNT_FORCEDDISMOUNT                                = 345,
-    ERR_AUTOFOLLOW_TOO_FAR                                  = 346,
-    ERR_UNIT_NOT_FOUND                                      = 347,
-    ERR_INVALID_FOLLOW_TARGET                               = 348,
-    ERR_INVALID_INSPECT_TARGET                              = 349,
-    ERR_GUILDEMBLEM_SUCCESS                                 = 350,
-    ERR_GUILDEMBLEM_INVALID_TABARD_COLORS                   = 351,
-    ERR_GUILDEMBLEM_NOGUILD                                 = 352,
-    ERR_GUILDEMBLEM_NOTGUILDMASTER                          = 353,
-    ERR_GUILDEMBLEM_NOTENOUGHMONEY                          = 354,
-    ERR_GUILDEMBLEM_INVALIDVENDOR                           = 355,
-    ERR_EMBLEMERROR_NOTABARDGEOSET                          = 356,
-    ERR_SPELL_OUT_OF_RANGE                                  = 357,
-    ERR_COMMAND_NEEDS_TARGET                                = 358,
-    ERR_NOAMMO_S                                            = 359,
-    ERR_TOOBUSYTOFOLLOW                                     = 360,
-    ERR_DUEL_REQUESTED                                      = 361,
-    ERR_DUEL_CANCELLED                                      = 362,
-    ERR_DEATHBINDALREADYBOUND                               = 363,
-    ERR_DEATHBIND_SUCCESS_S                                 = 364,
-    ERR_NOEMOTEWHILERUNNING                                 = 365,
-    ERR_ZONE_EXPLORED                                       = 366,
-    ERR_ZONE_EXPLORED_XP                                    = 367,
-    ERR_INVALID_ITEM_TARGET                                 = 368,
-    ERR_INVALID_QUEST_TARGET                                = 369,
-    ERR_IGNORING_YOU_S                                      = 370,
-    ERR_FISH_NOT_HOOKED                                     = 371,
-    ERR_FISH_ESCAPED                                        = 372,
-    ERR_SPELL_FAILED_NOTUNSHEATHED                          = 373,
-    ERR_PETITION_OFFERED_S                                  = 374,
-    ERR_PETITION_SIGNED                                     = 375,
-    ERR_PETITION_SIGNED_S                                   = 376,
-    ERR_PETITION_DECLINED_S                                 = 377,
-    ERR_PETITION_ALREADY_SIGNED                             = 378,
-    ERR_PETITION_RESTRICTED_ACCOUNT_TRIAL                   = 379,
-    ERR_PETITION_ALREADY_SIGNED_OTHER                       = 380,
-    ERR_PETITION_IN_GUILD                                   = 381,
-    ERR_PETITION_CREATOR                                    = 382,
-    ERR_PETITION_NOT_ENOUGH_SIGNATURES                      = 383,
-    ERR_PETITION_NOT_SAME_SERVER                            = 384,
-    ERR_PETITION_FULL                                       = 385,
-    ERR_PETITION_ALREADY_SIGNED_BY_S                        = 386,
-    ERR_GUILD_NAME_INVALID                                  = 387,
-    ERR_SPELL_UNLEARNED_S                                   = 388,
-    ERR_PET_SPELL_ROOTED                                    = 389,
-    ERR_PET_SPELL_AFFECTING_COMBAT                          = 390,
-    ERR_PET_SPELL_OUT_OF_RANGE                              = 391,
-    ERR_PET_SPELL_NOT_BEHIND                                = 392,
-    ERR_PET_SPELL_TARGETS_DEAD                              = 393,
-    ERR_PET_SPELL_DEAD                                      = 394,
-    ERR_PET_SPELL_NOPATH                                    = 395,
-    ERR_ITEM_CANT_BE_DESTROYED                              = 396,
-    ERR_TICKET_ALREADY_EXISTS                               = 397,
-    ERR_TICKET_CREATE_ERROR                                 = 398,
-    ERR_TICKET_UPDATE_ERROR                                 = 399,
-    ERR_TICKET_DB_ERROR                                     = 400,
-    ERR_TICKET_NO_TEXT                                      = 401,
-    ERR_TICKET_TEXT_TOO_LONG                                = 402,
-    ERR_OBJECT_IS_BUSY                                      = 403,
-    ERR_EXHAUSTION_WELLRESTED                               = 404,
-    ERR_EXHAUSTION_RESTED                                   = 405,
-    ERR_EXHAUSTION_NORMAL                                   = 406,
-    ERR_EXHAUSTION_TIRED                                    = 407,
-    ERR_EXHAUSTION_EXHAUSTED                                = 408,
-    ERR_NO_ITEMS_WHILE_SHAPESHIFTED                         = 409,
-    ERR_CANT_INTERACT_SHAPESHIFTED                          = 410,
-    ERR_REALM_NOT_FOUND                                     = 411,
-    ERR_MAIL_QUEST_ITEM                                     = 412,
-    ERR_MAIL_BOUND_ITEM                                     = 413,
-    ERR_MAIL_CONJURED_ITEM                                  = 414,
-    ERR_MAIL_BAG                                            = 415,
-    ERR_MAIL_TO_SELF                                        = 416,
-    ERR_MAIL_TARGET_NOT_FOUND                               = 417,
-    ERR_MAIL_DATABASE_ERROR                                 = 418,
-    ERR_MAIL_DELETE_ITEM_ERROR                              = 419,
-    ERR_MAIL_WRAPPED_COD                                    = 420,
-    ERR_MAIL_CANT_SEND_REALM                                = 421,
-    ERR_MAIL_SENT                                           = 422,
-    ERR_NOT_HAPPY_ENOUGH                                    = 423,
-    ERR_USE_CANT_IMMUNE                                     = 424,
-    ERR_CANT_BE_DISENCHANTED                                = 425,
-    ERR_CANT_USE_DISARMED                                   = 426,
-    ERR_AUCTION_QUEST_ITEM                                  = 427,
-    ERR_AUCTION_BOUND_ITEM                                  = 428,
-    ERR_AUCTION_CONJURED_ITEM                               = 429,
-    ERR_AUCTION_LIMITED_DURATION_ITEM                       = 430,
-    ERR_AUCTION_WRAPPED_ITEM                                = 431,
-    ERR_AUCTION_LOOT_ITEM                                   = 432,
-    ERR_AUCTION_BAG                                         = 433,
-    ERR_AUCTION_EQUIPPED_BAG                                = 434,
-    ERR_AUCTION_DATABASE_ERROR                              = 435,
-    ERR_AUCTION_BID_OWN                                     = 436,
-    ERR_AUCTION_BID_INCREMENT                               = 437,
-    ERR_AUCTION_HIGHER_BID                                  = 438,
-    ERR_AUCTION_MIN_BID                                     = 439,
-    ERR_AUCTION_REPAIR_ITEM                                 = 440,
-    ERR_AUCTION_USED_CHARGES                                = 441,
-    ERR_AUCTION_ALREADY_BID                                 = 442,
-    ERR_AUCTION_STARTED                                     = 443,
-    ERR_AUCTION_REMOVED                                     = 444,
-    ERR_AUCTION_OUTBID_S                                    = 445,
-    ERR_AUCTION_WON_S                                       = 446,
-    ERR_AUCTION_SOLD_S                                      = 447,
-    ERR_AUCTION_EXPIRED_S                                   = 448,
-    ERR_AUCTION_REMOVED_S                                   = 449,
-    ERR_AUCTION_BID_PLACED                                  = 450,
-    ERR_LOGOUT_FAILED                                       = 451,
-    ERR_QUEST_PUSH_SUCCESS_S                                = 452,
-    ERR_QUEST_PUSH_INVALID_S                                = 453,
-    ERR_QUEST_PUSH_ACCEPTED_S                               = 454,
-    ERR_QUEST_PUSH_DECLINED_S                               = 455,
-    ERR_QUEST_PUSH_BUSY_S                                   = 456,
-    ERR_QUEST_PUSH_DEAD_S                                   = 457,
-    ERR_QUEST_PUSH_LOG_FULL_S                               = 458,
-    ERR_QUEST_PUSH_ONQUEST_S                                = 459,
-    ERR_QUEST_PUSH_ALREADY_DONE_S                           = 460,
-    ERR_QUEST_PUSH_NOT_DAILY_S                              = 461,
-    ERR_QUEST_PUSH_TIMER_EXPIRED_S                          = 462,
-    ERR_QUEST_PUSH_NOT_IN_PARTY_S                           = 463,
-    ERR_QUEST_PUSH_DIFFERENT_SERVER_DAILY_S                 = 464,
-    ERR_QUEST_PUSH_NOT_ALLOWED_S                            = 465,
-    ERR_RAID_GROUP_LOWLEVEL                                 = 466,
-    ERR_RAID_GROUP_ONLY                                     = 467,
-    ERR_RAID_GROUP_FULL                                     = 468,
-    ERR_RAID_GROUP_REQUIREMENTS_UNMATCH                     = 469,
-    ERR_CORPSE_IS_NOT_IN_INSTANCE                           = 470,
-    ERR_PVP_KILL_HONORABLE                                  = 471,
-    ERR_PVP_KILL_DISHONORABLE                               = 472,
-    ERR_SPELL_FAILED_ALREADY_AT_FULL_HEALTH                 = 473,
-    ERR_SPELL_FAILED_ALREADY_AT_FULL_MANA                   = 474,
-    ERR_SPELL_FAILED_ALREADY_AT_FULL_POWER_S                = 475,
-    ERR_AUTOLOOT_MONEY_S                                    = 476,
-    ERR_GENERIC_STUNNED                                     = 477,
-    ERR_TARGET_STUNNED                                      = 478,
-    ERR_MUST_REPAIR_DURABILITY                              = 479,
-    ERR_RAID_YOU_JOINED                                     = 480,
-    ERR_RAID_YOU_LEFT                                       = 481,
-    ERR_INSTANCE_GROUP_JOINED_WITH_PARTY                    = 482,
-    ERR_INSTANCE_GROUP_JOINED_WITH_RAID                     = 483,
-    ERR_RAID_MEMBER_ADDED_S                                 = 484,
-    ERR_RAID_MEMBER_REMOVED_S                               = 485,
-    ERR_INSTANCE_GROUP_ADDED_S                              = 486,
-    ERR_INSTANCE_GROUP_REMOVED_S                            = 487,
-    ERR_CLICK_ON_ITEM_TO_FEED                               = 488,
-    ERR_TOO_MANY_CHAT_CHANNELS                              = 489,
-    ERR_LOOT_ROLL_PENDING                                   = 490,
-    ERR_LOOT_PLAYER_NOT_FOUND                               = 491,
-    ERR_NOT_IN_RAID                                         = 492,
-    ERR_LOGGING_OUT                                         = 493,
-    ERR_TARGET_LOGGING_OUT                                  = 494,
-    ERR_NOT_WHILE_MOUNTED                                   = 495,
-    ERR_NOT_WHILE_SHAPESHIFTED                              = 496,
-    ERR_NOT_IN_COMBAT                                       = 497,
-    ERR_NOT_WHILE_DISARMED                                  = 498,
-    ERR_PET_BROKEN                                          = 499,
-    ERR_TALENT_WIPE_ERROR                                   = 500,
-    ERR_SPEC_WIPE_ERROR                                     = 501,
-    ERR_GLYPH_WIPE_ERROR                                    = 502,
-    ERR_PET_SPEC_WIPE_ERROR                                 = 503,
-    ERR_FEIGN_DEATH_RESISTED                                = 504,
-    ERR_MEETING_STONE_IN_QUEUE_S                            = 505,
-    ERR_MEETING_STONE_LEFT_QUEUE_S                          = 506,
-    ERR_MEETING_STONE_OTHER_MEMBER_LEFT                     = 507,
-    ERR_MEETING_STONE_PARTY_KICKED_FROM_QUEUE               = 508,
-    ERR_MEETING_STONE_MEMBER_STILL_IN_QUEUE                 = 509,
-    ERR_MEETING_STONE_SUCCESS                               = 510,
-    ERR_MEETING_STONE_IN_PROGRESS                           = 511,
-    ERR_MEETING_STONE_MEMBER_ADDED_S                        = 512,
-    ERR_MEETING_STONE_GROUP_FULL                            = 513,
-    ERR_MEETING_STONE_NOT_LEADER                            = 514,
-    ERR_MEETING_STONE_INVALID_LEVEL                         = 515,
-    ERR_MEETING_STONE_TARGET_NOT_IN_PARTY                   = 516,
-    ERR_MEETING_STONE_TARGET_INVALID_LEVEL                  = 517,
-    ERR_MEETING_STONE_MUST_BE_LEADER                        = 518,
-    ERR_MEETING_STONE_NO_RAID_GROUP                         = 519,
-    ERR_MEETING_STONE_NEED_PARTY                            = 520,
-    ERR_MEETING_STONE_NOT_FOUND                             = 521,
-    ERR_GUILDEMBLEM_SAME                                    = 522,
-    ERR_EQUIP_TRADE_ITEM                                    = 523,
-    ERR_PVP_TOGGLE_ON                                       = 524,
-    ERR_PVP_TOGGLE_OFF                                      = 525,
-    ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS                   = 526,
-    ERR_GROUP_JOIN_BATTLEGROUND_DEAD                        = 527,
-    ERR_GROUP_JOIN_BATTLEGROUND_S                           = 528,
-    ERR_GROUP_JOIN_BATTLEGROUND_FAIL                        = 529,
-    ERR_GROUP_JOIN_BATTLEGROUND_TOO_MANY                    = 530,
-    ERR_SOLO_JOIN_BATTLEGROUND_S                            = 531,
-    ERR_BATTLEGROUND_TOO_MANY_QUEUES                        = 532,
-    ERR_BATTLEGROUND_CANNOT_QUEUE_FOR_RATED                 = 533,
-    ERR_BATTLEDGROUND_QUEUED_FOR_RATED                      = 534,
-    ERR_BATTLEGROUND_TEAM_LEFT_QUEUE                        = 535,
-    ERR_BATTLEGROUND_NOT_IN_BATTLEGROUND                    = 536,
-    ERR_ALREADY_IN_ARENA_TEAM_S                             = 537,
-    ERR_INVALID_PROMOTION_CODE                              = 538,
-    ERR_BG_PLAYER_JOINED_SS                                 = 539,
-    ERR_BG_PLAYER_LEFT_S                                    = 540,
-    ERR_RESTRICTED_ACCOUNT                                  = 541,
-    ERR_RESTRICTED_ACCOUNT_TRIAL                            = 542,
-    ERR_PLAY_TIME_EXCEEDED                                  = 543,
-    ERR_APPROACHING_PARTIAL_PLAY_TIME                       = 544,
-    ERR_APPROACHING_PARTIAL_PLAY_TIME_2                     = 545,
-    ERR_APPROACHING_NO_PLAY_TIME                            = 546,
-    ERR_APPROACHING_NO_PLAY_TIME_2                          = 547,
-    ERR_UNHEALTHY_TIME                                      = 548,
-    ERR_CHAT_RESTRICTED_TRIAL                               = 549,
-    ERR_CHAT_THROTTLED                                      = 550,
-    ERR_MAIL_REACHED_CAP                                    = 551,
-    ERR_INVALID_RAID_TARGET                                 = 552,
-    ERR_RAID_LEADER_READY_CHECK_START_S                     = 553,
-    ERR_READY_CHECK_IN_PROGRESS                             = 554,
-    ERR_READY_CHECK_THROTTLED                               = 555,
-    ERR_DUNGEON_DIFFICULTY_FAILED                           = 556,
-    ERR_DUNGEON_DIFFICULTY_CHANGED_S                        = 557,
-    ERR_TRADE_WRONG_REALM                                   = 558,
-    ERR_TRADE_NOT_ON_TAPLIST                                = 559,
-    ERR_CHAT_PLAYER_AMBIGUOUS_S                             = 560,
-    ERR_LOOT_CANT_LOOT_THAT_NOW                             = 561,
-    ERR_LOOT_MASTER_INV_FULL                                = 562,
-    ERR_LOOT_MASTER_UNIQUE_ITEM                             = 563,
-    ERR_LOOT_MASTER_OTHER                                   = 564,
-    ERR_FILTERING_YOU_S                                     = 565,
-    ERR_USE_PREVENTED_BY_MECHANIC_S                         = 566,
-    ERR_ITEM_UNIQUE_EQUIPPABLE                              = 567,
-    ERR_LFG_LEADER_IS_LFM_S                                 = 568,
-    ERR_LFG_PENDING                                         = 569,
-    ERR_CANT_SPEAK_LANGAGE                                  = 570,
-    ERR_VENDOR_MISSING_TURNINS                              = 571,
-    ERR_BATTLEGROUND_NOT_IN_TEAM                            = 572,
-    ERR_NOT_IN_BATTLEGROUND                                 = 573,
-    ERR_NOT_ENOUGH_HONOR_POINTS                             = 574,
-    ERR_NOT_ENOUGH_ARENA_POINTS                             = 575,
-    ERR_SOCKETING_REQUIRES_META_GEM                         = 576,
-    ERR_SOCKETING_META_GEM_ONLY_IN_METASLOT                 = 577,
-    ERR_SOCKETING_REQUIRES_HYDRAULIC_GEM                    = 578,
-    ERR_SOCKETING_HYDRAULIC_GEM_ONLY_IN_HYDRAULICSLOT       = 579,
-    ERR_SOCKETING_REQUIRES_COGWHEEL_GEM                     = 580,
-    ERR_SOCKETING_COGWHEEL_GEM_ONLY_IN_COGWHEELSLOT         = 581,
-    ERR_SOCKETING_ITEM_TOO_LOW_LEVEL                        = 582,
-    ERR_ITEM_MAX_COUNT_SOCKETED                             = 583,
-    ERR_SYSTEM_DISABLED                                     = 584,
-    ERR_QUEST_FAILED_TOO_MANY_DAILY_QUESTS_I                = 585,
-    ERR_ITEM_MAX_COUNT_EQUIPPED_SOCKETED                    = 586,
-    ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED                     = 587,
-    ERR_USER_SQUELCHED                                      = 588,
-    ERR_TOO_MUCH_GOLD                                       = 589,
-    ERR_NOT_BARBER_SITTING                                  = 590,
-    ERR_QUEST_FAILED_CAIS                                   = 591,
-    ERR_INVITE_RESTRICTED_TRIAL                             = 592,
-    ERR_VOICE_IGNORE_FULL                                   = 593,
-    ERR_VOICE_IGNORE_SELF                                   = 594,
-    ERR_VOICE_IGNORE_NOT_FOUND                              = 595,
-    ERR_VOICE_IGNORE_ALREADY_S                              = 596,
-    ERR_VOICE_IGNORE_ADDED_S                                = 597,
-    ERR_VOICE_IGNORE_REMOVED_S                              = 598,
-    ERR_VOICE_IGNORE_AMBIGUOUS                              = 599,
-    ERR_VOICE_IGNORE_DELETED                                = 600,
-    ERR_UNKNOWN_MACRO_OPTION_S                              = 601,
-    ERR_NOT_DURING_ARENA_MATCH                              = 602,
-    ERR_PLAYER_SILENCED                                     = 603,
-    ERR_PLAYER_UNSILENCED                                   = 604,
-    ERR_COMSAT_DISCONNECT                                   = 605,
-    ERR_COMSAT_RECONNECT_ATTEMPT                            = 606,
-    ERR_COMSAT_CONNECT_FAIL                                 = 607,
-    ERR_MAIL_INVALID_ATTACHMENT_SLOT                        = 608,
-    ERR_MAIL_TOO_MANY_ATTACHMENTS                           = 609,
-    ERR_MAIL_INVALID_ATTACHMENT                             = 610,
-    ERR_MAIL_ATTACHMENT_EXPIRED                             = 611,
-    ERR_VOICE_CHAT_PARENTAL_DISABLE_ALL                     = 612,
-    ERR_VOICE_CHAT_PARENTAL_DISABLE_MIC                     = 613,
-    ERR_PROFANE_CHAT_NAME                                   = 614,
-    ERR_PLAYER_SILENCED_ECHO                                = 615,
-    ERR_PLAYER_UNSILENCED_ECHO                              = 616,
-    ERR_VOICESESSION_FULL                                   = 617,
-    ERR_LOOT_CANT_LOOT_THAT                                 = 618,
-    ERR_ARENA_EXPIRED_CAIS                                  = 619,
-    ERR_GROUP_ACTION_THROTTLED                              = 620,
-    ERR_ALREADY_PICKPOCKETED                                = 621,
-    ERR_NAME_INVALID                                        = 622,
-    ERR_NAME_NO_NAME                                        = 623,
-    ERR_NAME_TOO_SHORT                                      = 624,
-    ERR_NAME_TOO_LONG                                       = 625,
-    ERR_NAME_MIXED_LANGUAGES                                = 626,
-    ERR_NAME_PROFANE                                        = 627,
-    ERR_NAME_RESERVED                                       = 628,
-    ERR_NAME_THREE_CONSECUTIVE                              = 629,
-    ERR_NAME_INVALID_SPACE                                  = 630,
-    ERR_NAME_CONSECUTIVE_SPACES                             = 631,
-    ERR_NAME_RUSSIAN_CONSECUTIVE_SILENT_CHARACTERS          = 632,
-    ERR_NAME_RUSSIAN_SILENT_CHARACTER_AT_BEGINNING_OR_END   = 633,
-    ERR_NAME_DECLENSION_DOESNT_MATCH_BASE_NAME              = 634,
-    ERR_REFER_A_FRIEND_NOT_REFERRED_BY                      = 635,
-    ERR_REFER_A_FRIEND_TARGET_TOO_HIGH                      = 636,
-    ERR_REFER_A_FRIEND_INSUFFICIENT_GRANTABLE_LEVELS        = 637,
-    ERR_REFER_A_FRIEND_TOO_FAR                              = 638,
-    ERR_REFER_A_FRIEND_DIFFERENT_FACTION                    = 639,
-    ERR_REFER_A_FRIEND_NOT_NOW                              = 640,
-    ERR_REFER_A_FRIEND_GRANT_LEVEL_MAX_I                    = 641,
-    ERR_REFER_A_FRIEND_SUMMON_LEVEL_MAX_I                   = 642,
-    ERR_REFER_A_FRIEND_SUMMON_COOLDOWN                      = 643,
-    ERR_REFER_A_FRIEND_SUMMON_OFFLINE_S                     = 644,
-    ERR_REFER_A_FRIEND_INSUF_EXPAN_LVL                      = 645,
-    ERR_REFER_A_FRIEND_NOT_IN_LFG                           = 646,
-    ERR_REFER_A_FRIEND_NO_XREALM                            = 647,
-    ERR_REFER_A_FRIEND_MAP_INCOMING_TRANSFER_NOT_ALLOWED    = 648,
-    ERR_NOT_SAME_ACCOUNT                                    = 649,
-    ERR_BAD_ON_USE_ENCHANT                                  = 650,
-    ERR_TRADE_SELF                                          = 651,
-    ERR_TOO_MANY_SOCKETS                                    = 652,
-    ERR_ITEM_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS           = 653,
-    ERR_TRADE_TARGET_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS   = 654,
-    ERR_ITEM_MAX_LIMIT_CATEGORY_SOCKETED_EXCEEDED_IS        = 655,
-    ERR_ITEM_MAX_LIMIT_CATEGORY_EQUIPPED_EXCEEDED_IS        = 656,
-    ERR_SHAPESHIFT_FORM_CANNOT_EQUIP                        = 657,
-    ERR_ITEM_INVENTORY_FULL_SATCHEL                         = 658,
-    ERR_SCALING_STAT_ITEM_LEVEL_EXCEEDED                    = 659,
-    ERR_SCALING_STAT_ITEM_LEVEL_TOO_LOW                     = 660,
-    ERR_PURCHASE_LEVEL_TOO_LOW                              = 661,
-    ERR_GROUP_SWAP_FAILED                                   = 662,
-    ERR_INVITE_IN_COMBAT                                    = 663,
-    ERR_INVALID_GLYPH_SLOT                                  = 664,
-    ERR_GENERIC_NO_VALID_TARGETS                            = 665,
-    ERR_CALENDAR_EVENT_ALERT_S                              = 666,
-    ERR_PET_LEARN_SPELL_S                                   = 667,
-    ERR_PET_LEARN_ABILITY_S                                 = 668,
-    ERR_PET_SPELL_UNLEARNED_S                               = 669,
-    ERR_INVITE_UNKNOWN_REALM                                = 670,
-    ERR_INVITE_NO_PARTY_SERVER                              = 671,
-    ERR_INVITE_PARTY_BUSY                                   = 672,
-    ERR_PARTY_TARGET_AMBIGUOUS                              = 673,
-    ERR_PARTY_LFG_INVITE_RAID_LOCKED                        = 674,
-    ERR_PARTY_LFG_BOOT_LIMIT                                = 675,
-    ERR_PARTY_LFG_BOOT_COOLDOWN_S                           = 676,
-    ERR_PARTY_LFG_BOOT_NOT_ELIGIBLE_S                       = 677,
-    ERR_PARTY_LFG_BOOT_INPATIENT_TIMER_S                    = 678,
-    ERR_PARTY_LFG_BOOT_IN_PROGRESS                          = 679,
-    ERR_PARTY_LFG_BOOT_TOO_FEW_PLAYERS                      = 680,
-    ERR_PARTY_LFG_BOOT_VOTE_SUCCEEDED                       = 681,
-    ERR_PARTY_LFG_BOOT_VOTE_FAILED                          = 682,
-    ERR_PARTY_LFG_BOOT_IN_COMBAT                            = 683,
-    ERR_PARTY_LFG_BOOT_DUNGEON_COMPLETE                     = 684,
-    ERR_PARTY_LFG_BOOT_LOOT_ROLLS                           = 685,
-    ERR_PARTY_LFG_BOOT_VOTE_REGISTERED                      = 686,
-    ERR_PARTY_PRIVATE_GROUP_ONLY                            = 687,
-    ERR_PARTY_LFG_TELEPORT_IN_COMBAT                        = 688,
-    ERR_RAID_DISALLOWED_BY_LEVEL                            = 689,
-    ERR_RAID_DISALLOWED_BY_CROSS_REALM                      = 690,
-    ERR_PARTY_ROLE_NOT_AVAILABLE                            = 691,
-    ERR_JOIN_LFG_OBJECT_FAILED                              = 692,
-    ERR_LFG_REMOVED_LEVELUP                                 = 693,
-    ERR_LFG_REMOVED_XP_TOGGLE                               = 694,
-    ERR_LFG_REMOVED_FACTION_CHANGE                          = 695,
-    ERR_BATTLEGROUND_INFO_THROTTLED                         = 696,
-    ERR_BATTLEGROUND_ALREADY_IN                             = 697,
-    ERR_ARENA_TEAM_CHANGE_FAILED_QUEUED                     = 698,
-    ERR_ARENA_TEAM_PERMISSIONS                              = 699,
-    ERR_NOT_WHILE_FALLING                                   = 700,
-    ERR_NOT_WHILE_MOVING                                    = 701,
-    ERR_NOT_WHILE_FATIGUED                                  = 702,
-    ERR_MAX_SOCKETS                                         = 703,
-    ERR_MULTI_CAST_ACTION_TOTEM_S                           = 704,
-    ERR_BATTLEGROUND_JOIN_LEVELUP                           = 705,
-    ERR_REMOVE_FROM_PVP_QUEUE_XP_GAIN                       = 706,
-    ERR_BATTLEGROUND_JOIN_XP_GAIN                           = 707,
-    ERR_BATTLEGROUND_JOIN_MERCENARY                         = 708,
-    ERR_BATTLEGROUND_JOIN_TOO_MANY_HEALERS                  = 709,
-    ERR_BATTLEGROUND_JOIN_TOO_MANY_TANKS                    = 710,
-    ERR_BATTLEGROUND_JOIN_TOO_MANY_DAMAGE                   = 711,
-    ERR_RAID_DIFFICULTY_FAILED                              = 712,
-    ERR_RAID_DIFFICULTY_CHANGED_S                           = 713,
-    ERR_LEGACY_RAID_DIFFICULTY_CHANGED_S                    = 714,
-    ERR_RAID_LOCKOUT_CHANGED_S                              = 715,
-    ERR_RAID_CONVERTED_TO_PARTY                             = 716,
-    ERR_PARTY_CONVERTED_TO_RAID                             = 717,
-    ERR_PLAYER_DIFFICULTY_CHANGED_S                         = 718,
-    ERR_GMRESPONSE_DB_ERROR                                 = 719,
-    ERR_BATTLEGROUND_JOIN_RANGE_INDEX                       = 720,
-    ERR_ARENA_JOIN_RANGE_INDEX                              = 721,
-    ERR_REMOVE_FROM_PVP_QUEUE_FACTION_CHANGE                = 722,
-    ERR_BATTLEGROUND_JOIN_FAILED                            = 723,
-    ERR_BATTLEGROUND_JOIN_NO_VALID_SPEC_FOR_ROLE            = 724,
-    ERR_BATTLEGROUND_JOIN_RESPEC                            = 725,
-    ERR_BATTLEGROUND_INVITATION_DECLINED                    = 726,
-    ERR_BATTLEGROUND_JOIN_TIMED_OUT                         = 727,
-    ERR_BATTLEGROUND_DUPE_QUEUE                             = 728,
-    ERR_BATTLEGROUND_JOIN_MUST_COMPLETE_QUEST               = 729,
-    ERR_IN_BATTLEGROUND_RESPEC                              = 730,
-    ERR_MAIL_LIMITED_DURATION_ITEM                          = 731,
-    ERR_YELL_RESTRICTED_TRIAL                               = 732,
-    ERR_CHAT_RAID_RESTRICTED_TRIAL                          = 733,
-    ERR_LFG_ROLE_CHECK_FAILED                               = 734,
-    ERR_LFG_ROLE_CHECK_FAILED_TIMEOUT                       = 735,
-    ERR_LFG_ROLE_CHECK_FAILED_NOT_VIABLE                    = 736,
-    ERR_LFG_READY_CHECK_FAILED                              = 737,
-    ERR_LFG_READY_CHECK_FAILED_TIMEOUT                      = 738,
-    ERR_LFG_GROUP_FULL                                      = 739,
-    ERR_LFG_NO_LFG_OBJECT                                   = 740,
-    ERR_LFG_NO_SLOTS_PLAYER                                 = 741,
-    ERR_LFG_NO_SLOTS_PARTY                                  = 742,
-    ERR_LFG_NO_SPEC                                         = 743,
-    ERR_LFG_MISMATCHED_SLOTS                                = 744,
-    ERR_LFG_MISMATCHED_SLOTS_LOCAL_XREALM                   = 745,
-    ERR_LFG_PARTY_PLAYERS_FROM_DIFFERENT_REALMS             = 746,
-    ERR_LFG_MEMBERS_NOT_PRESENT                             = 747,
-    ERR_LFG_GET_INFO_TIMEOUT                                = 748,
-    ERR_LFG_INVALID_SLOT                                    = 749,
-    ERR_LFG_DESERTER_PLAYER                                 = 750,
-    ERR_LFG_DESERTER_PARTY                                  = 751,
-    ERR_LFG_DEAD                                            = 752,
-    ERR_LFG_RANDOM_COOLDOWN_PLAYER                          = 753,
-    ERR_LFG_RANDOM_COOLDOWN_PARTY                           = 754,
-    ERR_LFG_TOO_MANY_MEMBERS                                = 755,
-    ERR_LFG_TOO_FEW_MEMBERS                                 = 756,
-    ERR_LFG_PROPOSAL_FAILED                                 = 757,
-    ERR_LFG_PROPOSAL_DECLINED_SELF                          = 758,
-    ERR_LFG_PROPOSAL_DECLINED_PARTY                         = 759,
-    ERR_LFG_NO_SLOTS_SELECTED                               = 760,
-    ERR_LFG_NO_ROLES_SELECTED                               = 761,
-    ERR_LFG_ROLE_CHECK_INITIATED                            = 762,
-    ERR_LFG_READY_CHECK_INITIATED                           = 763,
-    ERR_LFG_PLAYER_DECLINED_ROLE_CHECK                      = 764,
-    ERR_LFG_PLAYER_DECLINED_READY_CHECK                     = 765,
-    ERR_LFG_JOINED_QUEUE                                    = 766,
-    ERR_LFG_JOINED_FLEX_QUEUE                               = 767,
-    ERR_LFG_JOINED_RF_QUEUE                                 = 768,
-    ERR_LFG_JOINED_SCENARIO_QUEUE                           = 769,
-    ERR_LFG_JOINED_WORLD_PVP_QUEUE                          = 770,
-    ERR_LFG_JOINED_BATTLEFIELD_QUEUE                        = 771,
-    ERR_LFG_JOINED_LIST                                     = 772,
-    ERR_LFG_LEFT_QUEUE                                      = 773,
-    ERR_LFG_LEFT_LIST                                       = 774,
-    ERR_LFG_ROLE_CHECK_ABORTED                              = 775,
-    ERR_LFG_READY_CHECK_ABORTED                             = 776,
-    ERR_LFG_CANT_USE_BATTLEGROUND                           = 777,
-    ERR_LFG_CANT_USE_DUNGEONS                               = 778,
-    ERR_LFG_REASON_TOO_MANY_LFG                             = 779,
-    ERR_INVALID_TELEPORT_LOCATION                           = 780,
-    ERR_TOO_FAR_TO_INTERACT                                 = 781,
-    ERR_BATTLEGROUND_PLAYERS_FROM_DIFFERENT_REALMS          = 782,
-    ERR_DIFFICULTY_CHANGE_COOLDOWN_S                        = 783,
-    ERR_DIFFICULTY_CHANGE_COMBAT_COOLDOWN_S                 = 784,
-    ERR_DIFFICULTY_CHANGE_WORLDSTATE                        = 785,
-    ERR_DIFFICULTY_CHANGE_ENCOUNTER                         = 786,
-    ERR_DIFFICULTY_CHANGE_COMBAT                            = 787,
-    ERR_DIFFICULTY_CHANGE_PLAYER_BUSY                       = 788,
-    ERR_DIFFICULTY_CHANGE_ALREADY_STARTED                   = 789,
-    ERR_DIFFICULTY_CHANGE_OTHER_HEROIC_S                    = 790,
-    ERR_DIFFICULTY_CHANGE_HEROIC_INSTANCE_ALREADY_RUNNING   = 791,
-    ERR_ARENA_TEAM_PARTY_SIZE                               = 792,
-    ERR_QUEST_FORCE_REMOVED_S                               = 793,
-    ERR_ATTACK_NO_ACTIONS                                   = 794,
-    ERR_IN_RANDOM_BG                                        = 795,
-    ERR_IN_NON_RANDOM_BG                                    = 796,
-    ERR_AUCTION_ENOUGH_ITEMS                                = 797,
-    ERR_BN_FRIEND_SELF                                      = 798,
-    ERR_BN_FRIEND_ALREADY                                   = 799,
-    ERR_BN_FRIEND_BLOCKED                                   = 800,
-    ERR_BN_FRIEND_LIST_FULL                                 = 801,
-    ERR_BN_FRIEND_REQUEST_SENT                              = 802,
-    ERR_BN_BROADCAST_THROTTLE                               = 803,
-    ERR_BG_DEVELOPER_ONLY                                   = 804,
-    ERR_CURRENCY_SPELL_SLOT_MISMATCH                        = 805,
-    ERR_CURRENCY_NOT_TRADABLE                               = 806,
-    ERR_REQUIRES_EXPANSION_S                                = 807,
-    ERR_QUEST_FAILED_SPELL                                  = 808,
-    ERR_TALENT_FAILED_NOT_ENOUGH_TALENTS_IN_PRIMARY_TREE    = 809,
-    ERR_TALENT_FAILED_NO_PRIMARY_TREE_SELECTED              = 810,
-    ERR_TALENT_FAILED_CANT_REMOVE_TALENT                    = 811,
-    ERR_TALENT_FAILED_UNKNOWN                               = 812,
-    ERR_WARGAME_REQUEST_FAILURE                             = 813,
-    ERR_RANK_REQUIRES_AUTHENTICATOR                         = 814,
-    ERR_GUILD_BANK_VOUCHER_FAILED                           = 815,
-    ERR_WARGAME_REQUEST_SENT                                = 816,
-    ERR_REQUIRES_ACHIEVEMENT_I                              = 817,
-    ERR_REFUND_RESULT_EXCEED_MAX_CURRENCY                   = 818,
-    ERR_CANT_BUY_QUANTITY                                   = 819,
-    ERR_ITEM_IS_BATTLE_PAY_LOCKED                           = 820,
-    ERR_PARTY_ALREADY_IN_BATTLEGROUND_QUEUE                 = 821,
-    ERR_PARTY_CONFIRMING_BATTLEGROUND_QUEUE                 = 822,
-    ERR_BATTLEFIELD_TEAM_PARTY_SIZE                         = 823,
-    ERR_INSUFF_TRACKED_CURRENCY_IS                          = 824,
-    ERR_NOT_ON_TOURNAMENT_REALM                             = 825,
-    ERR_GUILD_TRIAL_ACCOUNT_TRIAL                           = 826,
-    ERR_GUILD_TRIAL_ACCOUNT_VETERAN                         = 827,
-    ERR_GUILD_UNDELETABLE_DUE_TO_LEVEL                      = 828,
-    ERR_CANT_DO_THAT_IN_A_GROUP                             = 829,
-    ERR_GUILD_LEADER_REPLACED                               = 830,
-    ERR_TRANSMOGRIFY_CANT_EQUIP                             = 831,
-    ERR_TRANSMOGRIFY_INVALID_ITEM_TYPE                      = 832,
-    ERR_TRANSMOGRIFY_NOT_SOULBOUND                          = 833,
-    ERR_TRANSMOGRIFY_INVALID_SOURCE                         = 834,
-    ERR_TRANSMOGRIFY_INVALID_DESTINATION                    = 835,
-    ERR_TRANSMOGRIFY_MISMATCH                               = 836,
-    ERR_TRANSMOGRIFY_LEGENDARY                              = 837,
-    ERR_TRANSMOGRIFY_SAME_ITEM                              = 838,
-    ERR_TRANSMOGRIFY_SAME_APPEARANCE                        = 839,
-    ERR_TRANSMOGRIFY_NOT_EQUIPPED                           = 840,
-    ERR_VOID_DEPOSIT_FULL                                   = 841,
-    ERR_VOID_WITHDRAW_FULL                                  = 842,
-    ERR_VOID_STORAGE_WRAPPED                                = 843,
-    ERR_VOID_STORAGE_STACKABLE                              = 844,
-    ERR_VOID_STORAGE_UNBOUND                                = 845,
-    ERR_VOID_STORAGE_REPAIR                                 = 846,
-    ERR_VOID_STORAGE_CHARGES                                = 847,
-    ERR_VOID_STORAGE_QUEST                                  = 848,
-    ERR_VOID_STORAGE_CONJURED                               = 849,
-    ERR_VOID_STORAGE_MAIL                                   = 850,
-    ERR_VOID_STORAGE_BAG                                    = 851,
-    ERR_VOID_TRANSFER_STORAGE_FULL                          = 852,
-    ERR_VOID_TRANSFER_INV_FULL                              = 853,
-    ERR_VOID_TRANSFER_INTERNAL_ERROR                        = 854,
-    ERR_VOID_TRANSFER_ITEM_INVALID                          = 855,
-    ERR_DIFFICULTY_DISABLED_IN_LFG                          = 856,
-    ERR_VOID_STORAGE_UNIQUE                                 = 857,
-    ERR_VOID_STORAGE_LOOT                                   = 858,
-    ERR_VOID_STORAGE_HOLIDAY                                = 859,
-    ERR_VOID_STORAGE_DURATION                               = 860,
-    ERR_VOID_STORAGE_LOAD_FAILED                            = 861,
-    ERR_VOID_STORAGE_INVALID_ITEM                           = 862,
-    ERR_PARENTAL_CONTROLS_CHAT_MUTED                        = 863,
-    ERR_SOR_START_EXPERIENCE_INCOMPLETE                     = 864,
-    ERR_SOR_INVALID_EMAIL                                   = 865,
-    ERR_SOR_INVALID_COMMENT                                 = 866,
-    ERR_CHALLENGE_MODE_RESET_COOLDOWN_S                     = 867,
-    ERR_CHALLENGE_MODE_RESET_KEYSTONE                       = 868,
-    ERR_PET_JOURNAL_ALREADY_IN_LOADOUT                      = 869,
-    ERR_REPORT_SUBMITTED_SUCCESSFULLY                       = 870,
-    ERR_REPORT_SUBMISSION_FAILED                            = 871,
-    ERR_SUGGESTION_SUBMITTED_SUCCESSFULLY                   = 872,
-    ERR_BUG_SUBMITTED_SUCCESSFULLY                          = 873,
-    ERR_CHALLENGE_MODE_ENABLED                              = 874,
-    ERR_CHALLENGE_MODE_DISABLED                             = 875,
-    ERR_PETBATTLE_CREATE_FAILED                             = 876,
-    ERR_PETBATTLE_NOT_HERE                                  = 877,
-    ERR_PETBATTLE_NOT_HERE_ON_TRANSPORT                     = 878,
-    ERR_PETBATTLE_NOT_HERE_UNEVEN_GROUND                    = 879,
-    ERR_PETBATTLE_NOT_HERE_OBSTRUCTED                       = 880,
-    ERR_PETBATTLE_NOT_WHILE_IN_COMBAT                       = 881,
-    ERR_PETBATTLE_NOT_WHILE_DEAD                            = 882,
-    ERR_PETBATTLE_NOT_WHILE_FLYING                          = 883,
-    ERR_PETBATTLE_TARGET_INVALID                            = 884,
-    ERR_PETBATTLE_TARGET_OUT_OF_RANGE                       = 885,
-    ERR_PETBATTLE_TARGET_NOT_CAPTURABLE                     = 886,
-    ERR_PETBATTLE_NOT_A_TRAINER                             = 887,
-    ERR_PETBATTLE_DECLINED                                  = 888,
-    ERR_PETBATTLE_IN_BATTLE                                 = 889,
-    ERR_PETBATTLE_INVALID_LOADOUT                           = 890,
-    ERR_PETBATTLE_ALL_PETS_DEAD                             = 891,
-    ERR_PETBATTLE_NO_PETS_IN_SLOTS                          = 892,
-    ERR_PETBATTLE_NO_ACCOUNT_LOCK                           = 893,
-    ERR_PETBATTLE_WILD_PET_TAPPED                           = 894,
-    ERR_PETBATTLE_RESTRICTED_ACCOUNT                        = 895,
-    ERR_PETBATTLE_NOT_WHILE_IN_MATCHED_BATTLE               = 896,
-    ERR_CANT_HAVE_MORE_PETS_OF_THAT_TYPE                    = 897,
-    ERR_CANT_HAVE_MORE_PETS                                 = 898,
-    ERR_PVP_MAP_NOT_FOUND                                   = 899,
-    ERR_PVP_MAP_NOT_SET                                     = 900,
-    ERR_PETBATTLE_QUEUE_QUEUED                              = 901,
-    ERR_PETBATTLE_QUEUE_ALREADY_QUEUED                      = 902,
-    ERR_PETBATTLE_QUEUE_JOIN_FAILED                         = 903,
-    ERR_PETBATTLE_QUEUE_JOURNAL_LOCK                        = 904,
-    ERR_PETBATTLE_QUEUE_REMOVED                             = 905,
-    ERR_PETBATTLE_QUEUE_PROPOSAL_DECLINED                   = 906,
-    ERR_PETBATTLE_QUEUE_PROPOSAL_TIMEOUT                    = 907,
-    ERR_PETBATTLE_QUEUE_OPPONENT_DECLINED                   = 908,
-    ERR_PETBATTLE_QUEUE_REQUEUED_INTERNAL                   = 909,
-    ERR_PETBATTLE_QUEUE_REQUEUED_REMOVED                    = 910,
-    ERR_PETBATTLE_QUEUE_SLOT_LOCKED                         = 911,
-    ERR_PETBATTLE_QUEUE_SLOT_EMPTY                          = 912,
-    ERR_PETBATTLE_QUEUE_SLOT_NO_TRACKER                     = 913,
-    ERR_PETBATTLE_QUEUE_SLOT_NO_SPECIES                     = 914,
-    ERR_PETBATTLE_QUEUE_SLOT_CANT_BATTLE                    = 915,
-    ERR_PETBATTLE_QUEUE_SLOT_REVOKED                        = 916,
-    ERR_PETBATTLE_QUEUE_SLOT_DEAD                           = 917,
-    ERR_PETBATTLE_QUEUE_SLOT_NO_PET                         = 918,
-    ERR_PETBATTLE_QUEUE_NOT_WHILE_NEUTRAL                   = 919,
-    ERR_PETBATTLE_GAME_TIME_LIMIT_WARNING                   = 920,
-    ERR_PETBATTLE_GAME_ROUNDS_LIMIT_WARNING                 = 921,
-    ERR_HAS_RESTRICTION                                     = 922,
-    ERR_ITEM_UPGRADE_ITEM_TOO_LOW_LEVEL                     = 923,
-    ERR_ITEM_UPGRADE_NO_PATH                                = 924,
-    ERR_ITEM_UPGRADE_NO_MORE_UPGRADES                       = 925,
-    ERR_BONUS_ROLL_EMPTY                                    = 926,
-    ERR_CHALLENGE_MODE_FULL                                 = 927,
-    ERR_CHALLENGE_MODE_IN_PROGRESS                          = 928,
-    ERR_CHALLENGE_MODE_INCORRECT_KEYSTONE                   = 929,
-    ERR_BATTLETAG_FRIEND_NOT_FOUND                          = 930,
-    ERR_BATTLETAG_FRIEND_NOT_VALID                          = 931,
-    ERR_BATTLETAG_FRIEND_NOT_ALLOWED                        = 932,
-    ERR_BATTLETAG_FRIEND_THROTTLED                          = 933,
-    ERR_BATTLETAG_FRIEND_SUCCESS                            = 934,
-    ERR_PET_TOO_HIGH_LEVEL_TO_UNCAGE                        = 935,
-    ERR_PETBATTLE_INTERNAL                                  = 936,
-    ERR_CANT_CAGE_PET_YET                                   = 937,
-    ERR_NO_LOOT_IN_CHALLENGE_MODE                           = 938,
-    ERR_QUEST_PET_BATTLE_VICTORIES_PVP_II                   = 939,
-    ERR_ROLE_CHECK_ALREADY_IN_PROGRESS                      = 940,
-    ERR_RECRUIT_A_FRIEND_ACCOUNT_LIMIT                      = 941,
-    ERR_RECRUIT_A_FRIEND_FAILED                             = 942,
-    ERR_SET_LOOT_PERSONAL                                   = 943,
-    ERR_SET_LOOT_METHOD_FAILED_COMBAT                       = 944,
-    ERR_REAGENT_BANK_FULL                                   = 945,
-    ERR_REAGENT_BANK_LOCKED                                 = 946,
-    ERR_GARRISON_BUILDING_EXISTS                            = 947,
-    ERR_GARRISON_INVALID_PLOT                               = 948,
-    ERR_GARRISON_INVALID_BUILDINGID                         = 949,
-    ERR_GARRISON_INVALID_PLOT_BUILDING                      = 950,
-    ERR_GARRISON_REQUIRES_BLUEPRINT                         = 951,
-    ERR_GARRISON_NOT_ENOUGH_CURRENCY                        = 952,
-    ERR_GARRISON_NOT_ENOUGH_GOLD                            = 953,
-    ERR_GARRISON_COMPLETE_MISSION_WRONG_FOLLOWER_TYPE       = 954,
-    ERR_ALREADY_USING_LFG_LIST                              = 955,
-    ERR_RESTRICTED_ACCOUNT_LFG_LIST_TRIAL                   = 956,
-    ERR_TOY_USE_LIMIT_REACHED                               = 957,
-    ERR_TOY_ALREADY_KNOWN                                   = 958,
-    ERR_TRANSMOG_SET_ALREADY_KNOWN                          = 959,
-    ERR_NOT_ENOUGH_CURRENCY                                 = 960,
-    ERR_SPEC_IS_DISABLED                                    = 961,
-    ERR_FEATURE_RESTRICTED_TRIAL                            = 962,
-    ERR_CANT_BE_OBLITERATED                                 = 963,
-    ERR_ARTIFACT_RELIC_DOES_NOT_MATCH_ARTIFACT              = 964,
-    ERR_MUST_EQUIP_ARTIFACT                                 = 965,
-    ERR_CANT_DO_THAT_RIGHT_NOW                              = 966,
-    ERR_AFFECTING_COMBAT                                    = 967,
-    ERR_EQUIPMENT_MANAGER_COMBAT_SWAP_S                     = 968,
-    ERR_EQUIPMENT_MANAGER_BAGS_FULL                         = 969,
-    ERR_EQUIPMENT_MANAGER_MISSING_ITEM_S                    = 970,
-    ERR_MOVIE_RECORDING_WARNING_PERF                        = 971,
-    ERR_MOVIE_RECORDING_WARNING_DISK_FULL                   = 972,
-    ERR_MOVIE_RECORDING_WARNING_NO_MOVIE                    = 973,
-    ERR_MOVIE_RECORDING_WARNING_REQUIREMENTS                = 974,
-    ERR_MOVIE_RECORDING_WARNING_COMPRESSING                 = 975,
-    ERR_NO_CHALLENGE_MODE_REWARD                            = 976,
-    ERR_CLAIMED_CHALLENGE_MODE_REWARD                       = 977,
-    ERR_CHALLENGE_MODE_PERIOD_RESET_SS                      = 978,
-    ERR_CANT_DO_THAT_CHALLENGE_MODE_ACTIVE                  = 979,
-    ERR_TALENT_FAILED_REST_AREA                             = 980,
-    ERR_CANNOT_ABANDON_LAST_PET                             = 981,
-    ERR_TEST_CVAR_SET_SSS                                   = 982,
-    ERR_QUEST_TURN_IN_FAIL_REASON                           = 983,
-    ERR_CLAIMED_CHALLENGE_MODE_REWARD_OLD                   = 984,
-    ERR_TALENT_GRANTED_BY_AURA                              = 985,
-    ERR_CHALLENGE_MODE_ALREADY_COMPLETE                     = 986,
-    ERR_GLYPH_TARGET_NOT_AVAILABLE                          = 987,
+    ERR_CLIENT_ON_TRANSPORT                                 = 152,
+    ERR_KILLED_BY_S                                         = 153,
+    ERR_LOOT_LOCKED                                         = 154,
+    ERR_LOOT_TOO_FAR                                        = 155,
+    ERR_LOOT_DIDNT_KILL                                     = 156,
+    ERR_LOOT_BAD_FACING                                     = 157,
+    ERR_LOOT_NOTSTANDING                                    = 158,
+    ERR_LOOT_STUNNED                                        = 159,
+    ERR_LOOT_NO_UI                                          = 160,
+    ERR_LOOT_WHILE_INVULNERABLE                             = 161,
+    ERR_NO_LOOT                                             = 162,
+    ERR_QUEST_ACCEPTED_S                                    = 163,
+    ERR_QUEST_COMPLETE_S                                    = 164,
+    ERR_QUEST_FAILED_S                                      = 165,
+    ERR_QUEST_FAILED_BAG_FULL_S                             = 166,
+    ERR_QUEST_FAILED_MAX_COUNT_S                            = 167,
+    ERR_QUEST_FAILED_LOW_LEVEL                              = 168,
+    ERR_QUEST_FAILED_MISSING_ITEMS                          = 169,
+    ERR_QUEST_FAILED_WRONG_RACE                             = 170,
+    ERR_QUEST_FAILED_NOT_ENOUGH_MONEY                       = 171,
+    ERR_QUEST_FAILED_EXPANSION                              = 172,
+    ERR_QUEST_ONLY_ONE_TIMED                                = 173,
+    ERR_QUEST_NEED_PREREQS                                  = 174,
+    ERR_QUEST_NEED_PREREQS_CUSTOM                           = 175,
+    ERR_QUEST_ALREADY_ON                                    = 176,
+    ERR_QUEST_ALREADY_DONE                                  = 177,
+    ERR_QUEST_ALREADY_DONE_DAILY                            = 178,
+    ERR_QUEST_HAS_IN_PROGRESS                               = 179,
+    ERR_QUEST_REWARD_EXP_I                                  = 180,
+    ERR_QUEST_REWARD_MONEY_S                                = 181,
+    ERR_QUEST_MUST_CHOOSE                                   = 182,
+    ERR_QUEST_LOG_FULL                                      = 183,
+    ERR_COMBAT_DAMAGE_SSI                                   = 184,
+    ERR_INSPECT_S                                           = 185,
+    ERR_CANT_USE_ITEM                                       = 186,
+    ERR_CANT_USE_ITEM_IN_ARENA                              = 187,
+    ERR_CANT_USE_ITEM_IN_RATED_BATTLEGROUND                 = 188,
+    ERR_MUST_EQUIP_ITEM                                     = 189,
+    ERR_PASSIVE_ABILITY                                     = 190,
+    ERR_2HSKILLNOTFOUND                                     = 191,
+    ERR_NO_ATTACK_TARGET                                    = 192,
+    ERR_INVALID_ATTACK_TARGET                               = 193,
+    ERR_ATTACK_PVP_TARGET_WHILE_UNFLAGGED                   = 194,
+    ERR_ATTACK_STUNNED                                      = 195,
+    ERR_ATTACK_PACIFIED                                     = 196,
+    ERR_ATTACK_MOUNTED                                      = 197,
+    ERR_ATTACK_FLEEING                                      = 198,
+    ERR_ATTACK_CONFUSED                                     = 199,
+    ERR_ATTACK_CHARMED                                      = 200,
+    ERR_ATTACK_DEAD                                         = 201,
+    ERR_ATTACK_PREVENTED_BY_MECHANIC_S                      = 202,
+    ERR_ATTACK_CHANNEL                                      = 203,
+    ERR_TAXISAMENODE                                        = 204,
+    ERR_TAXINOSUCHPATH                                      = 205,
+    ERR_TAXIUNSPECIFIEDSERVERERROR                          = 206,
+    ERR_TAXINOTENOUGHMONEY                                  = 207,
+    ERR_TAXITOOFARAWAY                                      = 208,
+    ERR_TAXINOVENDORNEARBY                                  = 209,
+    ERR_TAXINOTVISITED                                      = 210,
+    ERR_TAXIPLAYERBUSY                                      = 211,
+    ERR_TAXIPLAYERALREADYMOUNTED                            = 212,
+    ERR_TAXIPLAYERSHAPESHIFTED                              = 213,
+    ERR_TAXIPLAYERMOVING                                    = 214,
+    ERR_TAXINOPATHS                                         = 215,
+    ERR_TAXINOTELIGIBLE                                     = 216,
+    ERR_TAXINOTSTANDING                                     = 217,
+    ERR_NO_REPLY_TARGET                                     = 218,
+    ERR_GENERIC_NO_TARGET                                   = 219,
+    ERR_INITIATE_TRADE_S                                    = 220,
+    ERR_TRADE_REQUEST_S                                     = 221,
+    ERR_TRADE_BLOCKED_S                                     = 222,
+    ERR_TRADE_TARGET_DEAD                                   = 223,
+    ERR_TRADE_TOO_FAR                                       = 224,
+    ERR_TRADE_CANCELLED                                     = 225,
+    ERR_TRADE_COMPLETE                                      = 226,
+    ERR_TRADE_BAG_FULL                                      = 227,
+    ERR_TRADE_TARGET_BAG_FULL                               = 228,
+    ERR_TRADE_MAX_COUNT_EXCEEDED                            = 229,
+    ERR_TRADE_TARGET_MAX_COUNT_EXCEEDED                     = 230,
+    ERR_ALREADY_TRADING                                     = 231,
+    ERR_MOUNT_INVALIDMOUNTEE                                = 232,
+    ERR_MOUNT_TOOFARAWAY                                    = 233,
+    ERR_MOUNT_ALREADYMOUNTED                                = 234,
+    ERR_MOUNT_NOTMOUNTABLE                                  = 235,
+    ERR_MOUNT_NOTYOURPET                                    = 236,
+    ERR_MOUNT_OTHER                                         = 237,
+    ERR_MOUNT_LOOTING                                       = 238,
+    ERR_MOUNT_RACECANTMOUNT                                 = 239,
+    ERR_MOUNT_SHAPESHIFTED                                  = 240,
+    ERR_MOUNT_NO_FAVORITES                                  = 241,
+    ERR_DISMOUNT_NOPET                                      = 242,
+    ERR_DISMOUNT_NOTMOUNTED                                 = 243,
+    ERR_DISMOUNT_NOTYOURPET                                 = 244,
+    ERR_SPELL_FAILED_TOTEMS                                 = 245,
+    ERR_SPELL_FAILED_REAGENTS                               = 246,
+    ERR_SPELL_FAILED_REAGENTS_GENERIC                       = 247,
+    ERR_CANT_TRADE_GOLD                                     = 248,
+    ERR_SPELL_FAILED_EQUIPPED_ITEM                          = 249,
+    ERR_SPELL_FAILED_EQUIPPED_ITEM_CLASS_S                  = 250,
+    ERR_SPELL_FAILED_SHAPESHIFT_FORM_S                      = 251,
+    ERR_SPELL_FAILED_ANOTHER_IN_PROGRESS                    = 252,
+    ERR_BADATTACKFACING                                     = 253,
+    ERR_BADATTACKPOS                                        = 254,
+    ERR_CHEST_IN_USE                                        = 255,
+    ERR_USE_CANT_OPEN                                       = 256,
+    ERR_USE_LOCKED                                          = 257,
+    ERR_DOOR_LOCKED                                         = 258,
+    ERR_BUTTON_LOCKED                                       = 259,
+    ERR_USE_LOCKED_WITH_ITEM_S                              = 260,
+    ERR_USE_LOCKED_WITH_SPELL_S                             = 261,
+    ERR_USE_LOCKED_WITH_SPELL_KNOWN_SI                      = 262,
+    ERR_USE_TOO_FAR                                         = 263,
+    ERR_USE_BAD_ANGLE                                       = 264,
+    ERR_USE_OBJECT_MOVING                                   = 265,
+    ERR_USE_SPELL_FOCUS                                     = 266,
+    ERR_USE_DESTROYED                                       = 267,
+    ERR_SET_LOOT_FREEFORALL                                 = 268,
+    ERR_SET_LOOT_ROUNDROBIN                                 = 269,
+    ERR_SET_LOOT_MASTER                                     = 270,
+    ERR_SET_LOOT_GROUP                                      = 271,
+    ERR_SET_LOOT_THRESHOLD_S                                = 272,
+    ERR_NEW_LOOT_MASTER_S                                   = 273,
+    ERR_SPECIFY_MASTER_LOOTER                               = 274,
+    ERR_LOOT_SPEC_CHANGED_S                                 = 275,
+    ERR_TAME_FAILED                                         = 276,
+    ERR_CHAT_WHILE_DEAD                                     = 277,
+    ERR_CHAT_PLAYER_NOT_FOUND_S                             = 278,
+    ERR_NEWTAXIPATH                                         = 279,
+    ERR_NO_PET                                              = 280,
+    ERR_NOTYOURPET                                          = 281,
+    ERR_PET_NOT_RENAMEABLE                                  = 282,
+    ERR_QUEST_OBJECTIVE_COMPLETE_S                          = 283,
+    ERR_QUEST_UNKNOWN_COMPLETE                              = 284,
+    ERR_QUEST_ADD_KILL_SII                                  = 285,
+    ERR_QUEST_ADD_FOUND_SII                                 = 286,
+    ERR_QUEST_ADD_ITEM_SII                                  = 287,
+    ERR_QUEST_ADD_PLAYER_KILL_SII                           = 288,
+    ERR_CANNOTCREATEDIRECTORY                               = 289,
+    ERR_CANNOTCREATEFILE                                    = 290,
+    ERR_PLAYER_WRONG_FACTION                                = 291,
+    ERR_PLAYER_IS_NEUTRAL                                   = 292,
+    ERR_BANKSLOT_FAILED_TOO_MANY                            = 293,
+    ERR_BANKSLOT_INSUFFICIENT_FUNDS                         = 294,
+    ERR_BANKSLOT_NOTBANKER                                  = 295,
+    ERR_FRIEND_DB_ERROR                                     = 296,
+    ERR_FRIEND_LIST_FULL                                    = 297,
+    ERR_FRIEND_ADDED_S                                      = 298,
+    ERR_BATTLETAG_FRIEND_ADDED_S                            = 299,
+    ERR_FRIEND_ONLINE_SS                                    = 300,
+    ERR_FRIEND_OFFLINE_S                                    = 301,
+    ERR_FRIEND_NOT_FOUND                                    = 302,
+    ERR_FRIEND_WRONG_FACTION                                = 303,
+    ERR_FRIEND_REMOVED_S                                    = 304,
+    ERR_BATTLETAG_FRIEND_REMOVED_S                          = 305,
+    ERR_FRIEND_ERROR                                        = 306,
+    ERR_FRIEND_ALREADY_S                                    = 307,
+    ERR_FRIEND_SELF                                         = 308,
+    ERR_FRIEND_DELETED                                      = 309,
+    ERR_IGNORE_FULL                                         = 310,
+    ERR_IGNORE_SELF                                         = 311,
+    ERR_IGNORE_NOT_FOUND                                    = 312,
+    ERR_IGNORE_ALREADY_S                                    = 313,
+    ERR_IGNORE_ADDED_S                                      = 314,
+    ERR_IGNORE_REMOVED_S                                    = 315,
+    ERR_IGNORE_AMBIGUOUS                                    = 316,
+    ERR_IGNORE_DELETED                                      = 317,
+    ERR_ONLY_ONE_BOLT                                       = 318,
+    ERR_ONLY_ONE_AMMO                                       = 319,
+    ERR_SPELL_FAILED_EQUIPPED_SPECIFIC_ITEM                 = 320,
+    ERR_WRONG_BAG_TYPE_SUBCLASS                             = 321,
+    ERR_CANT_WRAP_STACKABLE                                 = 322,
+    ERR_CANT_WRAP_EQUIPPED                                  = 323,
+    ERR_CANT_WRAP_WRAPPED                                   = 324,
+    ERR_CANT_WRAP_BOUND                                     = 325,
+    ERR_CANT_WRAP_UNIQUE                                    = 326,
+    ERR_CANT_WRAP_BAGS                                      = 327,
+    ERR_OUT_OF_MANA                                         = 328,
+    ERR_OUT_OF_RAGE                                         = 329,
+    ERR_OUT_OF_FOCUS                                        = 330,
+    ERR_OUT_OF_ENERGY                                       = 331,
+    ERR_OUT_OF_CHI                                          = 332,
+    ERR_OUT_OF_HEALTH                                       = 333,
+    ERR_OUT_OF_RUNES                                        = 334,
+    ERR_OUT_OF_RUNIC_POWER                                  = 335,
+    ERR_OUT_OF_SOUL_SHARDS                                  = 336,
+    ERR_OUT_OF_LUNAR_POWER                                  = 337,
+    ERR_OUT_OF_HOLY_POWER                                   = 338,
+    ERR_OUT_OF_MAELSTROM                                    = 339,
+    ERR_OUT_OF_COMBO_POINTS                                 = 340,
+    ERR_OUT_OF_INSANITY                                     = 341,
+    ERR_OUT_OF_ARCANE_CHARGES                               = 342,
+    ERR_OUT_OF_FURY                                         = 343,
+    ERR_OUT_OF_PAIN                                         = 344,
+    ERR_OUT_OF_POWER_DISPLAY                                = 345,
+    ERR_LOOT_GONE                                           = 346,
+    ERR_MOUNT_FORCEDDISMOUNT                                = 347,
+    ERR_AUTOFOLLOW_TOO_FAR                                  = 348,
+    ERR_UNIT_NOT_FOUND                                      = 349,
+    ERR_INVALID_FOLLOW_TARGET                               = 350,
+    ERR_INVALID_FOLLOW_PVP_COMBAT                           = 351,
+    ERR_INVALID_FOLLOW_TARGET_PVP_COMBAT                    = 352,
+    ERR_INVALID_INSPECT_TARGET                              = 353,
+    ERR_GUILDEMBLEM_SUCCESS                                 = 354,
+    ERR_GUILDEMBLEM_INVALID_TABARD_COLORS                   = 355,
+    ERR_GUILDEMBLEM_NOGUILD                                 = 356,
+    ERR_GUILDEMBLEM_NOTGUILDMASTER                          = 357,
+    ERR_GUILDEMBLEM_NOTENOUGHMONEY                          = 358,
+    ERR_GUILDEMBLEM_INVALIDVENDOR                           = 359,
+    ERR_EMBLEMERROR_NOTABARDGEOSET                          = 360,
+    ERR_SPELL_OUT_OF_RANGE                                  = 361,
+    ERR_COMMAND_NEEDS_TARGET                                = 362,
+    ERR_NOAMMO_S                                            = 363,
+    ERR_TOOBUSYTOFOLLOW                                     = 364,
+    ERR_DUEL_REQUESTED                                      = 365,
+    ERR_DUEL_CANCELLED                                      = 366,
+    ERR_DEATHBINDALREADYBOUND                               = 367,
+    ERR_DEATHBIND_SUCCESS_S                                 = 368,
+    ERR_NOEMOTEWHILERUNNING                                 = 369,
+    ERR_ZONE_EXPLORED                                       = 370,
+    ERR_ZONE_EXPLORED_XP                                    = 371,
+    ERR_INVALID_ITEM_TARGET                                 = 372,
+    ERR_INVALID_QUEST_TARGET                                = 373,
+    ERR_IGNORING_YOU_S                                      = 374,
+    ERR_FISH_NOT_HOOKED                                     = 375,
+    ERR_FISH_ESCAPED                                        = 376,
+    ERR_SPELL_FAILED_NOTUNSHEATHED                          = 377,
+    ERR_PETITION_OFFERED_S                                  = 378,
+    ERR_PETITION_SIGNED                                     = 379,
+    ERR_PETITION_SIGNED_S                                   = 380,
+    ERR_PETITION_DECLINED_S                                 = 381,
+    ERR_PETITION_ALREADY_SIGNED                             = 382,
+    ERR_PETITION_RESTRICTED_ACCOUNT_TRIAL                   = 383,
+    ERR_PETITION_ALREADY_SIGNED_OTHER                       = 384,
+    ERR_PETITION_IN_GUILD                                   = 385,
+    ERR_PETITION_CREATOR                                    = 386,
+    ERR_PETITION_NOT_ENOUGH_SIGNATURES                      = 387,
+    ERR_PETITION_NOT_SAME_SERVER                            = 388,
+    ERR_PETITION_FULL                                       = 389,
+    ERR_PETITION_ALREADY_SIGNED_BY_S                        = 390,
+    ERR_GUILD_NAME_INVALID                                  = 391,
+    ERR_SPELL_UNLEARNED_S                                   = 392,
+    ERR_PET_SPELL_ROOTED                                    = 393,
+    ERR_PET_SPELL_AFFECTING_COMBAT                          = 394,
+    ERR_PET_SPELL_OUT_OF_RANGE                              = 395,
+    ERR_PET_SPELL_NOT_BEHIND                                = 396,
+    ERR_PET_SPELL_TARGETS_DEAD                              = 397,
+    ERR_PET_SPELL_DEAD                                      = 398,
+    ERR_PET_SPELL_NOPATH                                    = 399,
+    ERR_ITEM_CANT_BE_DESTROYED                              = 400,
+    ERR_TICKET_ALREADY_EXISTS                               = 401,
+    ERR_TICKET_CREATE_ERROR                                 = 402,
+    ERR_TICKET_UPDATE_ERROR                                 = 403,
+    ERR_TICKET_DB_ERROR                                     = 404,
+    ERR_TICKET_NO_TEXT                                      = 405,
+    ERR_TICKET_TEXT_TOO_LONG                                = 406,
+    ERR_OBJECT_IS_BUSY                                      = 407,
+    ERR_EXHAUSTION_WELLRESTED                               = 408,
+    ERR_EXHAUSTION_RESTED                                   = 409,
+    ERR_EXHAUSTION_NORMAL                                   = 410,
+    ERR_EXHAUSTION_TIRED                                    = 411,
+    ERR_EXHAUSTION_EXHAUSTED                                = 412,
+    ERR_NO_ITEMS_WHILE_SHAPESHIFTED                         = 413,
+    ERR_CANT_INTERACT_SHAPESHIFTED                          = 414,
+    ERR_REALM_NOT_FOUND                                     = 415,
+    ERR_MAIL_QUEST_ITEM                                     = 416,
+    ERR_MAIL_BOUND_ITEM                                     = 417,
+    ERR_MAIL_CONJURED_ITEM                                  = 418,
+    ERR_MAIL_BAG                                            = 419,
+    ERR_MAIL_TO_SELF                                        = 420,
+    ERR_MAIL_TARGET_NOT_FOUND                               = 421,
+    ERR_MAIL_DATABASE_ERROR                                 = 422,
+    ERR_MAIL_DELETE_ITEM_ERROR                              = 423,
+    ERR_MAIL_WRAPPED_COD                                    = 424,
+    ERR_MAIL_CANT_SEND_REALM                                = 425,
+    ERR_MAIL_SENT                                           = 426,
+    ERR_NOT_HAPPY_ENOUGH                                    = 427,
+    ERR_USE_CANT_IMMUNE                                     = 428,
+    ERR_CANT_BE_DISENCHANTED                                = 429,
+    ERR_CANT_USE_DISARMED                                   = 430,
+    ERR_AUCTION_QUEST_ITEM                                  = 431,
+    ERR_AUCTION_BOUND_ITEM                                  = 432,
+    ERR_AUCTION_CONJURED_ITEM                               = 433,
+    ERR_AUCTION_LIMITED_DURATION_ITEM                       = 434,
+    ERR_AUCTION_WRAPPED_ITEM                                = 435,
+    ERR_AUCTION_LOOT_ITEM                                   = 436,
+    ERR_AUCTION_BAG                                         = 437,
+    ERR_AUCTION_EQUIPPED_BAG                                = 438,
+    ERR_AUCTION_DATABASE_ERROR                              = 439,
+    ERR_AUCTION_BID_OWN                                     = 440,
+    ERR_AUCTION_BID_INCREMENT                               = 441,
+    ERR_AUCTION_HIGHER_BID                                  = 442,
+    ERR_AUCTION_MIN_BID                                     = 443,
+    ERR_AUCTION_REPAIR_ITEM                                 = 444,
+    ERR_AUCTION_USED_CHARGES                                = 445,
+    ERR_AUCTION_ALREADY_BID                                 = 446,
+    ERR_AUCTION_STARTED                                     = 447,
+    ERR_AUCTION_REMOVED                                     = 448,
+    ERR_AUCTION_OUTBID_S                                    = 449,
+    ERR_AUCTION_WON_S                                       = 450,
+    ERR_AUCTION_SOLD_S                                      = 451,
+    ERR_AUCTION_EXPIRED_S                                   = 452,
+    ERR_AUCTION_REMOVED_S                                   = 453,
+    ERR_AUCTION_BID_PLACED                                  = 454,
+    ERR_LOGOUT_FAILED                                       = 455,
+    ERR_QUEST_PUSH_SUCCESS_S                                = 456,
+    ERR_QUEST_PUSH_INVALID_S                                = 457,
+    ERR_QUEST_PUSH_ACCEPTED_S                               = 458,
+    ERR_QUEST_PUSH_DECLINED_S                               = 459,
+    ERR_QUEST_PUSH_BUSY_S                                   = 460,
+    ERR_QUEST_PUSH_DEAD_S                                   = 461,
+    ERR_QUEST_PUSH_LOG_FULL_S                               = 462,
+    ERR_QUEST_PUSH_ONQUEST_S                                = 463,
+    ERR_QUEST_PUSH_ALREADY_DONE_S                           = 464,
+    ERR_QUEST_PUSH_NOT_DAILY_S                              = 465,
+    ERR_QUEST_PUSH_TIMER_EXPIRED_S                          = 466,
+    ERR_QUEST_PUSH_NOT_IN_PARTY_S                           = 467,
+    ERR_QUEST_PUSH_DIFFERENT_SERVER_DAILY_S                 = 468,
+    ERR_QUEST_PUSH_NOT_ALLOWED_S                            = 469,
+    ERR_RAID_GROUP_LOWLEVEL                                 = 470,
+    ERR_RAID_GROUP_ONLY                                     = 471,
+    ERR_RAID_GROUP_FULL                                     = 472,
+    ERR_RAID_GROUP_REQUIREMENTS_UNMATCH                     = 473,
+    ERR_CORPSE_IS_NOT_IN_INSTANCE                           = 474,
+    ERR_PVP_KILL_HONORABLE                                  = 475,
+    ERR_PVP_KILL_DISHONORABLE                               = 476,
+    ERR_SPELL_FAILED_ALREADY_AT_FULL_HEALTH                 = 477,
+    ERR_SPELL_FAILED_ALREADY_AT_FULL_MANA                   = 478,
+    ERR_SPELL_FAILED_ALREADY_AT_FULL_POWER_S                = 479,
+    ERR_AUTOLOOT_MONEY_S                                    = 480,
+    ERR_GENERIC_STUNNED                                     = 481,
+    ERR_TARGET_STUNNED                                      = 482,
+    ERR_MUST_REPAIR_DURABILITY                              = 483,
+    ERR_RAID_YOU_JOINED                                     = 484,
+    ERR_RAID_YOU_LEFT                                       = 485,
+    ERR_INSTANCE_GROUP_JOINED_WITH_PARTY                    = 486,
+    ERR_INSTANCE_GROUP_JOINED_WITH_RAID                     = 487,
+    ERR_RAID_MEMBER_ADDED_S                                 = 488,
+    ERR_RAID_MEMBER_REMOVED_S                               = 489,
+    ERR_INSTANCE_GROUP_ADDED_S                              = 490,
+    ERR_INSTANCE_GROUP_REMOVED_S                            = 491,
+    ERR_CLICK_ON_ITEM_TO_FEED                               = 492,
+    ERR_TOO_MANY_CHAT_CHANNELS                              = 493,
+    ERR_LOOT_ROLL_PENDING                                   = 494,
+    ERR_LOOT_PLAYER_NOT_FOUND                               = 495,
+    ERR_NOT_IN_RAID                                         = 496,
+    ERR_LOGGING_OUT                                         = 497,
+    ERR_TARGET_LOGGING_OUT                                  = 498,
+    ERR_NOT_WHILE_MOUNTED                                   = 499,
+    ERR_NOT_WHILE_SHAPESHIFTED                              = 500,
+    ERR_NOT_IN_COMBAT                                       = 501,
+    ERR_NOT_WHILE_DISARMED                                  = 502,
+    ERR_PET_BROKEN                                          = 503,
+    ERR_TALENT_WIPE_ERROR                                   = 504,
+    ERR_SPEC_WIPE_ERROR                                     = 505,
+    ERR_GLYPH_WIPE_ERROR                                    = 506,
+    ERR_PET_SPEC_WIPE_ERROR                                 = 507,
+    ERR_FEIGN_DEATH_RESISTED                                = 508,
+    ERR_MEETING_STONE_IN_QUEUE_S                            = 509,
+    ERR_MEETING_STONE_LEFT_QUEUE_S                          = 510,
+    ERR_MEETING_STONE_OTHER_MEMBER_LEFT                     = 511,
+    ERR_MEETING_STONE_PARTY_KICKED_FROM_QUEUE               = 512,
+    ERR_MEETING_STONE_MEMBER_STILL_IN_QUEUE                 = 513,
+    ERR_MEETING_STONE_SUCCESS                               = 514,
+    ERR_MEETING_STONE_IN_PROGRESS                           = 515,
+    ERR_MEETING_STONE_MEMBER_ADDED_S                        = 516,
+    ERR_MEETING_STONE_GROUP_FULL                            = 517,
+    ERR_MEETING_STONE_NOT_LEADER                            = 518,
+    ERR_MEETING_STONE_INVALID_LEVEL                         = 519,
+    ERR_MEETING_STONE_TARGET_NOT_IN_PARTY                   = 520,
+    ERR_MEETING_STONE_TARGET_INVALID_LEVEL                  = 521,
+    ERR_MEETING_STONE_MUST_BE_LEADER                        = 522,
+    ERR_MEETING_STONE_NO_RAID_GROUP                         = 523,
+    ERR_MEETING_STONE_NEED_PARTY                            = 524,
+    ERR_MEETING_STONE_NOT_FOUND                             = 525,
+    ERR_GUILDEMBLEM_SAME                                    = 526,
+    ERR_EQUIP_TRADE_ITEM                                    = 527,
+    ERR_PVP_TOGGLE_ON                                       = 528,
+    ERR_PVP_TOGGLE_OFF                                      = 529,
+    ERR_GROUP_JOIN_BATTLEGROUND_DESERTERS                   = 530,
+    ERR_GROUP_JOIN_BATTLEGROUND_DEAD                        = 531,
+    ERR_GROUP_JOIN_BATTLEGROUND_S                           = 532,
+    ERR_GROUP_JOIN_BATTLEGROUND_FAIL                        = 533,
+    ERR_GROUP_JOIN_BATTLEGROUND_TOO_MANY                    = 534,
+    ERR_SOLO_JOIN_BATTLEGROUND_S                            = 535,
+    ERR_JOIN_SINGLE_SCENARIO_S                              = 536,
+    ERR_BATTLEGROUND_TOO_MANY_QUEUES                        = 537,
+    ERR_BATTLEGROUND_CANNOT_QUEUE_FOR_RATED                 = 538,
+    ERR_BATTLEDGROUND_QUEUED_FOR_RATED                      = 539,
+    ERR_BATTLEGROUND_TEAM_LEFT_QUEUE                        = 540,
+    ERR_BATTLEGROUND_NOT_IN_BATTLEGROUND                    = 541,
+    ERR_ALREADY_IN_ARENA_TEAM_S                             = 542,
+    ERR_INVALID_PROMOTION_CODE                              = 543,
+    ERR_BG_PLAYER_JOINED_SS                                 = 544,
+    ERR_BG_PLAYER_LEFT_S                                    = 545,
+    ERR_RESTRICTED_ACCOUNT                                  = 546,
+    ERR_RESTRICTED_ACCOUNT_TRIAL                            = 547,
+    ERR_PLAY_TIME_EXCEEDED                                  = 548,
+    ERR_APPROACHING_PARTIAL_PLAY_TIME                       = 549,
+    ERR_APPROACHING_PARTIAL_PLAY_TIME_2                     = 550,
+    ERR_APPROACHING_NO_PLAY_TIME                            = 551,
+    ERR_APPROACHING_NO_PLAY_TIME_2                          = 552,
+    ERR_UNHEALTHY_TIME                                      = 553,
+    ERR_CHAT_RESTRICTED_TRIAL                               = 554,
+    ERR_CHAT_THROTTLED                                      = 555,
+    ERR_MAIL_REACHED_CAP                                    = 556,
+    ERR_INVALID_RAID_TARGET                                 = 557,
+    ERR_RAID_LEADER_READY_CHECK_START_S                     = 558,
+    ERR_READY_CHECK_IN_PROGRESS                             = 559,
+    ERR_READY_CHECK_THROTTLED                               = 560,
+    ERR_DUNGEON_DIFFICULTY_FAILED                           = 561,
+    ERR_DUNGEON_DIFFICULTY_CHANGED_S                        = 562,
+    ERR_TRADE_WRONG_REALM                                   = 563,
+    ERR_TRADE_NOT_ON_TAPLIST                                = 564,
+    ERR_CHAT_PLAYER_AMBIGUOUS_S                             = 565,
+    ERR_LOOT_CANT_LOOT_THAT_NOW                             = 566,
+    ERR_LOOT_MASTER_INV_FULL                                = 567,
+    ERR_LOOT_MASTER_UNIQUE_ITEM                             = 568,
+    ERR_LOOT_MASTER_OTHER                                   = 569,
+    ERR_FILTERING_YOU_S                                     = 570,
+    ERR_USE_PREVENTED_BY_MECHANIC_S                         = 571,
+    ERR_ITEM_UNIQUE_EQUIPPABLE                              = 572,
+    ERR_LFG_LEADER_IS_LFM_S                                 = 573,
+    ERR_LFG_PENDING                                         = 574,
+    ERR_CANT_SPEAK_LANGAGE                                  = 575,
+    ERR_VENDOR_MISSING_TURNINS                              = 576,
+    ERR_BATTLEGROUND_NOT_IN_TEAM                            = 577,
+    ERR_NOT_IN_BATTLEGROUND                                 = 578,
+    ERR_NOT_ENOUGH_HONOR_POINTS                             = 579,
+    ERR_NOT_ENOUGH_ARENA_POINTS                             = 580,
+    ERR_SOCKETING_REQUIRES_META_GEM                         = 581,
+    ERR_SOCKETING_META_GEM_ONLY_IN_METASLOT                 = 582,
+    ERR_SOCKETING_REQUIRES_HYDRAULIC_GEM                    = 583,
+    ERR_SOCKETING_HYDRAULIC_GEM_ONLY_IN_HYDRAULICSLOT       = 584,
+    ERR_SOCKETING_REQUIRES_COGWHEEL_GEM                     = 585,
+    ERR_SOCKETING_COGWHEEL_GEM_ONLY_IN_COGWHEELSLOT         = 586,
+    ERR_SOCKETING_ITEM_TOO_LOW_LEVEL                        = 587,
+    ERR_ITEM_MAX_COUNT_SOCKETED                             = 588,
+    ERR_SYSTEM_DISABLED                                     = 589,
+    ERR_QUEST_FAILED_TOO_MANY_DAILY_QUESTS_I                = 590,
+    ERR_ITEM_MAX_COUNT_EQUIPPED_SOCKETED                    = 591,
+    ERR_ITEM_UNIQUE_EQUIPPABLE_SOCKETED                     = 592,
+    ERR_USER_SQUELCHED                                      = 593,
+    ERR_TOO_MUCH_GOLD                                       = 594,
+    ERR_NOT_BARBER_SITTING                                  = 595,
+    ERR_QUEST_FAILED_CAIS                                   = 596,
+    ERR_INVITE_RESTRICTED_TRIAL                             = 597,
+    ERR_VOICE_IGNORE_FULL                                   = 598,
+    ERR_VOICE_IGNORE_SELF                                   = 599,
+    ERR_VOICE_IGNORE_NOT_FOUND                              = 600,
+    ERR_VOICE_IGNORE_ALREADY_S                              = 601,
+    ERR_VOICE_IGNORE_ADDED_S                                = 602,
+    ERR_VOICE_IGNORE_REMOVED_S                              = 603,
+    ERR_VOICE_IGNORE_AMBIGUOUS                              = 604,
+    ERR_VOICE_IGNORE_DELETED                                = 605,
+    ERR_UNKNOWN_MACRO_OPTION_S                              = 606,
+    ERR_NOT_DURING_ARENA_MATCH                              = 607,
+    ERR_PLAYER_SILENCED                                     = 608,
+    ERR_PLAYER_UNSILENCED                                   = 609,
+    ERR_COMSAT_DISCONNECT                                   = 610,
+    ERR_COMSAT_RECONNECT_ATTEMPT                            = 611,
+    ERR_COMSAT_CONNECT_FAIL                                 = 612,
+    ERR_MAIL_INVALID_ATTACHMENT_SLOT                        = 613,
+    ERR_MAIL_TOO_MANY_ATTACHMENTS                           = 614,
+    ERR_MAIL_INVALID_ATTACHMENT                             = 615,
+    ERR_MAIL_ATTACHMENT_EXPIRED                             = 616,
+    ERR_VOICE_CHAT_PARENTAL_DISABLE_MIC                     = 617,
+    ERR_PROFANE_CHAT_NAME                                   = 618,
+    ERR_PLAYER_SILENCED_ECHO                                = 619,
+    ERR_PLAYER_UNSILENCED_ECHO                              = 620,
+    ERR_LOOT_CANT_LOOT_THAT                                 = 621,
+    ERR_ARENA_EXPIRED_CAIS                                  = 622,
+    ERR_GROUP_ACTION_THROTTLED                              = 623,
+    ERR_ALREADY_PICKPOCKETED                                = 624,
+    ERR_NAME_INVALID                                        = 625,
+    ERR_NAME_NO_NAME                                        = 626,
+    ERR_NAME_TOO_SHORT                                      = 627,
+    ERR_NAME_TOO_LONG                                       = 628,
+    ERR_NAME_MIXED_LANGUAGES                                = 629,
+    ERR_NAME_PROFANE                                        = 630,
+    ERR_NAME_RESERVED                                       = 631,
+    ERR_NAME_THREE_CONSECUTIVE                              = 632,
+    ERR_NAME_INVALID_SPACE                                  = 633,
+    ERR_NAME_CONSECUTIVE_SPACES                             = 634,
+    ERR_NAME_RUSSIAN_CONSECUTIVE_SILENT_CHARACTERS          = 635,
+    ERR_NAME_RUSSIAN_SILENT_CHARACTER_AT_BEGINNING_OR_END   = 636,
+    ERR_NAME_DECLENSION_DOESNT_MATCH_BASE_NAME              = 637,
+    ERR_REFER_A_FRIEND_NOT_REFERRED_BY                      = 638,
+    ERR_REFER_A_FRIEND_TARGET_TOO_HIGH                      = 639,
+    ERR_REFER_A_FRIEND_INSUFFICIENT_GRANTABLE_LEVELS        = 640,
+    ERR_REFER_A_FRIEND_TOO_FAR                              = 641,
+    ERR_REFER_A_FRIEND_DIFFERENT_FACTION                    = 642,
+    ERR_REFER_A_FRIEND_NOT_NOW                              = 643,
+    ERR_REFER_A_FRIEND_GRANT_LEVEL_MAX_I                    = 644,
+    ERR_REFER_A_FRIEND_SUMMON_LEVEL_MAX_I                   = 645,
+    ERR_REFER_A_FRIEND_SUMMON_COOLDOWN                      = 646,
+    ERR_REFER_A_FRIEND_SUMMON_OFFLINE_S                     = 647,
+    ERR_REFER_A_FRIEND_INSUF_EXPAN_LVL                      = 648,
+    ERR_REFER_A_FRIEND_NOT_IN_LFG                           = 649,
+    ERR_REFER_A_FRIEND_NO_XREALM                            = 650,
+    ERR_REFER_A_FRIEND_MAP_INCOMING_TRANSFER_NOT_ALLOWED    = 651,
+    ERR_NOT_SAME_ACCOUNT                                    = 652,
+    ERR_BAD_ON_USE_ENCHANT                                  = 653,
+    ERR_TRADE_SELF                                          = 654,
+    ERR_TOO_MANY_SOCKETS                                    = 655,
+    ERR_ITEM_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS           = 656,
+    ERR_TRADE_TARGET_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS   = 657,
+    ERR_ITEM_MAX_LIMIT_CATEGORY_SOCKETED_EXCEEDED_IS        = 658,
+    ERR_ITEM_MAX_LIMIT_CATEGORY_EQUIPPED_EXCEEDED_IS        = 659,
+    ERR_SHAPESHIFT_FORM_CANNOT_EQUIP                        = 660,
+    ERR_ITEM_INVENTORY_FULL_SATCHEL                         = 661,
+    ERR_SCALING_STAT_ITEM_LEVEL_EXCEEDED                    = 662,
+    ERR_SCALING_STAT_ITEM_LEVEL_TOO_LOW                     = 663,
+    ERR_PURCHASE_LEVEL_TOO_LOW                              = 664,
+    ERR_GROUP_SWAP_FAILED                                   = 665,
+    ERR_INVITE_IN_COMBAT                                    = 666,
+    ERR_INVALID_GLYPH_SLOT                                  = 667,
+    ERR_GENERIC_NO_VALID_TARGETS                            = 668,
+    ERR_CALENDAR_EVENT_ALERT_S                              = 669,
+    ERR_PET_LEARN_SPELL_S                                   = 670,
+    ERR_PET_LEARN_ABILITY_S                                 = 671,
+    ERR_PET_SPELL_UNLEARNED_S                               = 672,
+    ERR_INVITE_UNKNOWN_REALM                                = 673,
+    ERR_INVITE_NO_PARTY_SERVER                              = 674,
+    ERR_INVITE_PARTY_BUSY                                   = 675,
+    ERR_PARTY_TARGET_AMBIGUOUS                              = 676,
+    ERR_PARTY_LFG_INVITE_RAID_LOCKED                        = 677,
+    ERR_PARTY_LFG_BOOT_LIMIT                                = 678,
+    ERR_PARTY_LFG_BOOT_COOLDOWN_S                           = 679,
+    ERR_PARTY_LFG_BOOT_NOT_ELIGIBLE_S                       = 680,
+    ERR_PARTY_LFG_BOOT_INPATIENT_TIMER_S                    = 681,
+    ERR_PARTY_LFG_BOOT_IN_PROGRESS                          = 682,
+    ERR_PARTY_LFG_BOOT_TOO_FEW_PLAYERS                      = 683,
+    ERR_PARTY_LFG_BOOT_VOTE_SUCCEEDED                       = 684,
+    ERR_PARTY_LFG_BOOT_VOTE_FAILED                          = 685,
+    ERR_PARTY_LFG_BOOT_IN_COMBAT                            = 686,
+    ERR_PARTY_LFG_BOOT_DUNGEON_COMPLETE                     = 687,
+    ERR_PARTY_LFG_BOOT_LOOT_ROLLS                           = 688,
+    ERR_PARTY_LFG_BOOT_VOTE_REGISTERED                      = 689,
+    ERR_PARTY_PRIVATE_GROUP_ONLY                            = 690,
+    ERR_PARTY_LFG_TELEPORT_IN_COMBAT                        = 691,
+    ERR_RAID_DISALLOWED_BY_LEVEL                            = 692,
+    ERR_RAID_DISALLOWED_BY_CROSS_REALM                      = 693,
+    ERR_PARTY_ROLE_NOT_AVAILABLE                            = 694,
+    ERR_JOIN_LFG_OBJECT_FAILED                              = 695,
+    ERR_LFG_REMOVED_LEVELUP                                 = 696,
+    ERR_LFG_REMOVED_XP_TOGGLE                               = 697,
+    ERR_LFG_REMOVED_FACTION_CHANGE                          = 698,
+    ERR_BATTLEGROUND_INFO_THROTTLED                         = 699,
+    ERR_BATTLEGROUND_ALREADY_IN                             = 700,
+    ERR_ARENA_TEAM_CHANGE_FAILED_QUEUED                     = 701,
+    ERR_ARENA_TEAM_PERMISSIONS                              = 702,
+    ERR_NOT_WHILE_FALLING                                   = 703,
+    ERR_NOT_WHILE_MOVING                                    = 704,
+    ERR_NOT_WHILE_FATIGUED                                  = 705,
+    ERR_MAX_SOCKETS                                         = 706,
+    ERR_MULTI_CAST_ACTION_TOTEM_S                           = 707,
+    ERR_BATTLEGROUND_JOIN_LEVELUP                           = 708,
+    ERR_REMOVE_FROM_PVP_QUEUE_XP_GAIN                       = 709,
+    ERR_BATTLEGROUND_JOIN_XP_GAIN                           = 710,
+    ERR_BATTLEGROUND_JOIN_MERCENARY                         = 711,
+    ERR_BATTLEGROUND_JOIN_TOO_MANY_HEALERS                  = 712,
+    ERR_BATTLEGROUND_JOIN_TOO_MANY_TANKS                    = 713,
+    ERR_BATTLEGROUND_JOIN_TOO_MANY_DAMAGE                   = 714,
+    ERR_RAID_DIFFICULTY_FAILED                              = 715,
+    ERR_RAID_DIFFICULTY_CHANGED_S                           = 716,
+    ERR_LEGACY_RAID_DIFFICULTY_CHANGED_S                    = 717,
+    ERR_RAID_LOCKOUT_CHANGED_S                              = 718,
+    ERR_RAID_CONVERTED_TO_PARTY                             = 719,
+    ERR_PARTY_CONVERTED_TO_RAID                             = 720,
+    ERR_PLAYER_DIFFICULTY_CHANGED_S                         = 721,
+    ERR_GMRESPONSE_DB_ERROR                                 = 722,
+    ERR_BATTLEGROUND_JOIN_RANGE_INDEX                       = 723,
+    ERR_ARENA_JOIN_RANGE_INDEX                              = 724,
+    ERR_REMOVE_FROM_PVP_QUEUE_FACTION_CHANGE                = 725,
+    ERR_BATTLEGROUND_JOIN_FAILED                            = 726,
+    ERR_BATTLEGROUND_JOIN_NO_VALID_SPEC_FOR_ROLE            = 727,
+    ERR_BATTLEGROUND_JOIN_RESPEC                            = 728,
+    ERR_BATTLEGROUND_INVITATION_DECLINED                    = 729,
+    ERR_BATTLEGROUND_JOIN_TIMED_OUT                         = 730,
+    ERR_BATTLEGROUND_DUPE_QUEUE                             = 731,
+    ERR_BATTLEGROUND_JOIN_MUST_COMPLETE_QUEST               = 732,
+    ERR_IN_BATTLEGROUND_RESPEC                              = 733,
+    ERR_MAIL_LIMITED_DURATION_ITEM                          = 734,
+    ERR_YELL_RESTRICTED_TRIAL                               = 735,
+    ERR_CHAT_RAID_RESTRICTED_TRIAL                          = 736,
+    ERR_LFG_ROLE_CHECK_FAILED                               = 737,
+    ERR_LFG_ROLE_CHECK_FAILED_TIMEOUT                       = 738,
+    ERR_LFG_ROLE_CHECK_FAILED_NOT_VIABLE                    = 739,
+    ERR_LFG_READY_CHECK_FAILED                              = 740,
+    ERR_LFG_READY_CHECK_FAILED_TIMEOUT                      = 741,
+    ERR_LFG_GROUP_FULL                                      = 742,
+    ERR_LFG_NO_LFG_OBJECT                                   = 743,
+    ERR_LFG_NO_SLOTS_PLAYER                                 = 744,
+    ERR_LFG_NO_SLOTS_PARTY                                  = 745,
+    ERR_LFG_NO_SPEC                                         = 746,
+    ERR_LFG_MISMATCHED_SLOTS                                = 747,
+    ERR_LFG_MISMATCHED_SLOTS_LOCAL_XREALM                   = 748,
+    ERR_LFG_PARTY_PLAYERS_FROM_DIFFERENT_REALMS             = 749,
+    ERR_LFG_MEMBERS_NOT_PRESENT                             = 750,
+    ERR_LFG_GET_INFO_TIMEOUT                                = 751,
+    ERR_LFG_INVALID_SLOT                                    = 752,
+    ERR_LFG_DESERTER_PLAYER                                 = 753,
+    ERR_LFG_DESERTER_PARTY                                  = 754,
+    ERR_LFG_DEAD                                            = 755,
+    ERR_LFG_RANDOM_COOLDOWN_PLAYER                          = 756,
+    ERR_LFG_RANDOM_COOLDOWN_PARTY                           = 757,
+    ERR_LFG_TOO_MANY_MEMBERS                                = 758,
+    ERR_LFG_TOO_FEW_MEMBERS                                 = 759,
+    ERR_LFG_PROPOSAL_FAILED                                 = 760,
+    ERR_LFG_PROPOSAL_DECLINED_SELF                          = 761,
+    ERR_LFG_PROPOSAL_DECLINED_PARTY                         = 762,
+    ERR_LFG_NO_SLOTS_SELECTED                               = 763,
+    ERR_LFG_NO_ROLES_SELECTED                               = 764,
+    ERR_LFG_ROLE_CHECK_INITIATED                            = 765,
+    ERR_LFG_READY_CHECK_INITIATED                           = 766,
+    ERR_LFG_PLAYER_DECLINED_ROLE_CHECK                      = 767,
+    ERR_LFG_PLAYER_DECLINED_READY_CHECK                     = 768,
+    ERR_LFG_JOINED_QUEUE                                    = 769,
+    ERR_LFG_JOINED_FLEX_QUEUE                               = 770,
+    ERR_LFG_JOINED_RF_QUEUE                                 = 771,
+    ERR_LFG_JOINED_SCENARIO_QUEUE                           = 772,
+    ERR_LFG_JOINED_WORLD_PVP_QUEUE                          = 773,
+    ERR_LFG_JOINED_BATTLEFIELD_QUEUE                        = 774,
+    ERR_LFG_JOINED_LIST                                     = 775,
+    ERR_LFG_LEFT_QUEUE                                      = 776,
+    ERR_LFG_LEFT_LIST                                       = 777,
+    ERR_LFG_ROLE_CHECK_ABORTED                              = 778,
+    ERR_LFG_READY_CHECK_ABORTED                             = 779,
+    ERR_LFG_CANT_USE_BATTLEGROUND                           = 780,
+    ERR_LFG_CANT_USE_DUNGEONS                               = 781,
+    ERR_LFG_REASON_TOO_MANY_LFG                             = 782,
+    ERR_INVALID_TELEPORT_LOCATION                           = 783,
+    ERR_TOO_FAR_TO_INTERACT                                 = 784,
+    ERR_BATTLEGROUND_PLAYERS_FROM_DIFFERENT_REALMS          = 785,
+    ERR_DIFFICULTY_CHANGE_COOLDOWN_S                        = 786,
+    ERR_DIFFICULTY_CHANGE_COMBAT_COOLDOWN_S                 = 787,
+    ERR_DIFFICULTY_CHANGE_WORLDSTATE                        = 788,
+    ERR_DIFFICULTY_CHANGE_ENCOUNTER                         = 789,
+    ERR_DIFFICULTY_CHANGE_COMBAT                            = 790,
+    ERR_DIFFICULTY_CHANGE_PLAYER_BUSY                       = 791,
+    ERR_DIFFICULTY_CHANGE_ALREADY_STARTED                   = 792,
+    ERR_DIFFICULTY_CHANGE_OTHER_HEROIC_S                    = 793,
+    ERR_DIFFICULTY_CHANGE_HEROIC_INSTANCE_ALREADY_RUNNING   = 794,
+    ERR_ARENA_TEAM_PARTY_SIZE                               = 795,
+    ERR_QUEST_FORCE_REMOVED_S                               = 796,
+    ERR_ATTACK_NO_ACTIONS                                   = 797,
+    ERR_IN_RANDOM_BG                                        = 798,
+    ERR_IN_NON_RANDOM_BG                                    = 799,
+    ERR_AUCTION_ENOUGH_ITEMS                                = 800,
+    ERR_BN_FRIEND_SELF                                      = 801,
+    ERR_BN_FRIEND_ALREADY                                   = 802,
+    ERR_BN_FRIEND_BLOCKED                                   = 803,
+    ERR_BN_FRIEND_LIST_FULL                                 = 804,
+    ERR_BN_FRIEND_REQUEST_SENT                              = 805,
+    ERR_BN_BROADCAST_THROTTLE                               = 806,
+    ERR_BG_DEVELOPER_ONLY                                   = 807,
+    ERR_CURRENCY_SPELL_SLOT_MISMATCH                        = 808,
+    ERR_CURRENCY_NOT_TRADABLE                               = 809,
+    ERR_REQUIRES_EXPANSION_S                                = 810,
+    ERR_QUEST_FAILED_SPELL                                  = 811,
+    ERR_TALENT_FAILED_NOT_ENOUGH_TALENTS_IN_PRIMARY_TREE    = 812,
+    ERR_TALENT_FAILED_NO_PRIMARY_TREE_SELECTED              = 813,
+    ERR_TALENT_FAILED_CANT_REMOVE_TALENT                    = 814,
+    ERR_TALENT_FAILED_UNKNOWN                               = 815,
+    ERR_WARGAME_REQUEST_FAILURE                             = 816,
+    ERR_RANK_REQUIRES_AUTHENTICATOR                         = 817,
+    ERR_GUILD_BANK_VOUCHER_FAILED                           = 818,
+    ERR_WARGAME_REQUEST_SENT                                = 819,
+    ERR_REQUIRES_ACHIEVEMENT_I                              = 820,
+    ERR_REFUND_RESULT_EXCEED_MAX_CURRENCY                   = 821,
+    ERR_CANT_BUY_QUANTITY                                   = 822,
+    ERR_ITEM_IS_BATTLE_PAY_LOCKED                           = 823,
+    ERR_PARTY_ALREADY_IN_BATTLEGROUND_QUEUE                 = 824,
+    ERR_PARTY_CONFIRMING_BATTLEGROUND_QUEUE                 = 825,
+    ERR_BATTLEFIELD_TEAM_PARTY_SIZE                         = 826,
+    ERR_INSUFF_TRACKED_CURRENCY_IS                          = 827,
+    ERR_NOT_ON_TOURNAMENT_REALM                             = 828,
+    ERR_GUILD_TRIAL_ACCOUNT_TRIAL                           = 829,
+    ERR_GUILD_TRIAL_ACCOUNT_VETERAN                         = 830,
+    ERR_GUILD_UNDELETABLE_DUE_TO_LEVEL                      = 831,
+    ERR_CANT_DO_THAT_IN_A_GROUP                             = 832,
+    ERR_GUILD_LEADER_REPLACED                               = 833,
+    ERR_TRANSMOGRIFY_CANT_EQUIP                             = 834,
+    ERR_TRANSMOGRIFY_INVALID_ITEM_TYPE                      = 835,
+    ERR_TRANSMOGRIFY_NOT_SOULBOUND                          = 836,
+    ERR_TRANSMOGRIFY_INVALID_SOURCE                         = 837,
+    ERR_TRANSMOGRIFY_INVALID_DESTINATION                    = 838,
+    ERR_TRANSMOGRIFY_MISMATCH                               = 839,
+    ERR_TRANSMOGRIFY_LEGENDARY                              = 840,
+    ERR_TRANSMOGRIFY_SAME_ITEM                              = 841,
+    ERR_TRANSMOGRIFY_SAME_APPEARANCE                        = 842,
+    ERR_TRANSMOGRIFY_NOT_EQUIPPED                           = 843,
+    ERR_VOID_DEPOSIT_FULL                                   = 844,
+    ERR_VOID_WITHDRAW_FULL                                  = 845,
+    ERR_VOID_STORAGE_WRAPPED                                = 846,
+    ERR_VOID_STORAGE_STACKABLE                              = 847,
+    ERR_VOID_STORAGE_UNBOUND                                = 848,
+    ERR_VOID_STORAGE_REPAIR                                 = 849,
+    ERR_VOID_STORAGE_CHARGES                                = 850,
+    ERR_VOID_STORAGE_QUEST                                  = 851,
+    ERR_VOID_STORAGE_CONJURED                               = 852,
+    ERR_VOID_STORAGE_MAIL                                   = 853,
+    ERR_VOID_STORAGE_BAG                                    = 854,
+    ERR_VOID_TRANSFER_STORAGE_FULL                          = 855,
+    ERR_VOID_TRANSFER_INV_FULL                              = 856,
+    ERR_VOID_TRANSFER_INTERNAL_ERROR                        = 857,
+    ERR_VOID_TRANSFER_ITEM_INVALID                          = 858,
+    ERR_DIFFICULTY_DISABLED_IN_LFG                          = 859,
+    ERR_VOID_STORAGE_UNIQUE                                 = 860,
+    ERR_VOID_STORAGE_LOOT                                   = 861,
+    ERR_VOID_STORAGE_HOLIDAY                                = 862,
+    ERR_VOID_STORAGE_DURATION                               = 863,
+    ERR_VOID_STORAGE_LOAD_FAILED                            = 864,
+    ERR_VOID_STORAGE_INVALID_ITEM                           = 865,
+    ERR_PARENTAL_CONTROLS_CHAT_MUTED                        = 866,
+    ERR_SOR_START_EXPERIENCE_INCOMPLETE                     = 867,
+    ERR_SOR_INVALID_EMAIL                                   = 868,
+    ERR_SOR_INVALID_COMMENT                                 = 869,
+    ERR_CHALLENGE_MODE_RESET_COOLDOWN_S                     = 870,
+    ERR_CHALLENGE_MODE_RESET_KEYSTONE                       = 871,
+    ERR_PET_JOURNAL_ALREADY_IN_LOADOUT                      = 872,
+    ERR_REPORT_SUBMITTED_SUCCESSFULLY                       = 873,
+    ERR_REPORT_SUBMISSION_FAILED                            = 874,
+    ERR_SUGGESTION_SUBMITTED_SUCCESSFULLY                   = 875,
+    ERR_BUG_SUBMITTED_SUCCESSFULLY                          = 876,
+    ERR_CHALLENGE_MODE_ENABLED                              = 877,
+    ERR_CHALLENGE_MODE_DISABLED                             = 878,
+    ERR_PETBATTLE_CREATE_FAILED                             = 879,
+    ERR_PETBATTLE_NOT_HERE                                  = 880,
+    ERR_PETBATTLE_NOT_HERE_ON_TRANSPORT                     = 881,
+    ERR_PETBATTLE_NOT_HERE_UNEVEN_GROUND                    = 882,
+    ERR_PETBATTLE_NOT_HERE_OBSTRUCTED                       = 883,
+    ERR_PETBATTLE_NOT_WHILE_IN_COMBAT                       = 884,
+    ERR_PETBATTLE_NOT_WHILE_DEAD                            = 885,
+    ERR_PETBATTLE_NOT_WHILE_FLYING                          = 886,
+    ERR_PETBATTLE_TARGET_INVALID                            = 887,
+    ERR_PETBATTLE_TARGET_OUT_OF_RANGE                       = 888,
+    ERR_PETBATTLE_TARGET_NOT_CAPTURABLE                     = 889,
+    ERR_PETBATTLE_NOT_A_TRAINER                             = 890,
+    ERR_PETBATTLE_DECLINED                                  = 891,
+    ERR_PETBATTLE_IN_BATTLE                                 = 892,
+    ERR_PETBATTLE_INVALID_LOADOUT                           = 893,
+    ERR_PETBATTLE_ALL_PETS_DEAD                             = 894,
+    ERR_PETBATTLE_NO_PETS_IN_SLOTS                          = 895,
+    ERR_PETBATTLE_NO_ACCOUNT_LOCK                           = 896,
+    ERR_PETBATTLE_WILD_PET_TAPPED                           = 897,
+    ERR_PETBATTLE_RESTRICTED_ACCOUNT                        = 898,
+    ERR_PETBATTLE_OPPONENT_NOT_AVAILABLE                    = 899,
+    ERR_PETBATTLE_NOT_WHILE_IN_MATCHED_BATTLE               = 900,
+    ERR_CANT_HAVE_MORE_PETS_OF_THAT_TYPE                    = 901,
+    ERR_CANT_HAVE_MORE_PETS                                 = 902,
+    ERR_PVP_MAP_NOT_FOUND                                   = 903,
+    ERR_PVP_MAP_NOT_SET                                     = 904,
+    ERR_PETBATTLE_QUEUE_QUEUED                              = 905,
+    ERR_PETBATTLE_QUEUE_ALREADY_QUEUED                      = 906,
+    ERR_PETBATTLE_QUEUE_JOIN_FAILED                         = 907,
+    ERR_PETBATTLE_QUEUE_JOURNAL_LOCK                        = 908,
+    ERR_PETBATTLE_QUEUE_REMOVED                             = 909,
+    ERR_PETBATTLE_QUEUE_PROPOSAL_DECLINED                   = 910,
+    ERR_PETBATTLE_QUEUE_PROPOSAL_TIMEOUT                    = 911,
+    ERR_PETBATTLE_QUEUE_OPPONENT_DECLINED                   = 912,
+    ERR_PETBATTLE_QUEUE_REQUEUED_INTERNAL                   = 913,
+    ERR_PETBATTLE_QUEUE_REQUEUED_REMOVED                    = 914,
+    ERR_PETBATTLE_QUEUE_SLOT_LOCKED                         = 915,
+    ERR_PETBATTLE_QUEUE_SLOT_EMPTY                          = 916,
+    ERR_PETBATTLE_QUEUE_SLOT_NO_TRACKER                     = 917,
+    ERR_PETBATTLE_QUEUE_SLOT_NO_SPECIES                     = 918,
+    ERR_PETBATTLE_QUEUE_SLOT_CANT_BATTLE                    = 919,
+    ERR_PETBATTLE_QUEUE_SLOT_REVOKED                        = 920,
+    ERR_PETBATTLE_QUEUE_SLOT_DEAD                           = 921,
+    ERR_PETBATTLE_QUEUE_SLOT_NO_PET                         = 922,
+    ERR_PETBATTLE_QUEUE_NOT_WHILE_NEUTRAL                   = 923,
+    ERR_PETBATTLE_GAME_TIME_LIMIT_WARNING                   = 924,
+    ERR_PETBATTLE_GAME_ROUNDS_LIMIT_WARNING                 = 925,
+    ERR_HAS_RESTRICTION                                     = 926,
+    ERR_ITEM_UPGRADE_ITEM_TOO_LOW_LEVEL                     = 927,
+    ERR_ITEM_UPGRADE_NO_PATH                                = 928,
+    ERR_ITEM_UPGRADE_NO_MORE_UPGRADES                       = 929,
+    ERR_BONUS_ROLL_EMPTY                                    = 930,
+    ERR_CHALLENGE_MODE_FULL                                 = 931,
+    ERR_CHALLENGE_MODE_IN_PROGRESS                          = 932,
+    ERR_CHALLENGE_MODE_INCORRECT_KEYSTONE                   = 933,
+    ERR_BATTLETAG_FRIEND_NOT_FOUND                          = 934,
+    ERR_BATTLETAG_FRIEND_NOT_VALID                          = 935,
+    ERR_BATTLETAG_FRIEND_NOT_ALLOWED                        = 936,
+    ERR_BATTLETAG_FRIEND_THROTTLED                          = 937,
+    ERR_BATTLETAG_FRIEND_SUCCESS                            = 938,
+    ERR_PET_TOO_HIGH_LEVEL_TO_UNCAGE                        = 939,
+    ERR_PETBATTLE_INTERNAL                                  = 940,
+    ERR_CANT_CAGE_PET_YET                                   = 941,
+    ERR_NO_LOOT_IN_CHALLENGE_MODE                           = 942,
+    ERR_QUEST_PET_BATTLE_VICTORIES_PVP_II                   = 943,
+    ERR_ROLE_CHECK_ALREADY_IN_PROGRESS                      = 944,
+    ERR_RECRUIT_A_FRIEND_ACCOUNT_LIMIT                      = 945,
+    ERR_RECRUIT_A_FRIEND_FAILED                             = 946,
+    ERR_SET_LOOT_PERSONAL                                   = 947,
+    ERR_SET_LOOT_METHOD_FAILED_COMBAT                       = 948,
+    ERR_REAGENT_BANK_FULL                                   = 949,
+    ERR_REAGENT_BANK_LOCKED                                 = 950,
+    ERR_GARRISON_BUILDING_EXISTS                            = 951,
+    ERR_GARRISON_INVALID_PLOT                               = 952,
+    ERR_GARRISON_INVALID_BUILDINGID                         = 953,
+    ERR_GARRISON_INVALID_PLOT_BUILDING                      = 954,
+    ERR_GARRISON_REQUIRES_BLUEPRINT                         = 955,
+    ERR_GARRISON_NOT_ENOUGH_CURRENCY                        = 956,
+    ERR_GARRISON_NOT_ENOUGH_GOLD                            = 957,
+    ERR_GARRISON_COMPLETE_MISSION_WRONG_FOLLOWER_TYPE       = 958,
+    ERR_ALREADY_USING_LFG_LIST                              = 959,
+    ERR_RESTRICTED_ACCOUNT_LFG_LIST_TRIAL                   = 960,
+    ERR_TOY_USE_LIMIT_REACHED                               = 961,
+    ERR_TOY_ALREADY_KNOWN                                   = 962,
+    ERR_TRANSMOG_SET_ALREADY_KNOWN                          = 963,
+    ERR_NOT_ENOUGH_CURRENCY                                 = 964,
+    ERR_SPEC_IS_DISABLED                                    = 965,
+    ERR_FEATURE_RESTRICTED_TRIAL                            = 966,
+    ERR_CANT_BE_OBLITERATED                                 = 967,
+    ERR_CANT_BE_SCRAPPED                                    = 968,
+    ERR_ARTIFACT_RELIC_DOES_NOT_MATCH_ARTIFACT              = 969,
+    ERR_MUST_EQUIP_ARTIFACT                                 = 970,
+    ERR_CANT_DO_THAT_RIGHT_NOW                              = 971,
+    ERR_AFFECTING_COMBAT                                    = 972,
+    ERR_EQUIPMENT_MANAGER_COMBAT_SWAP_S                     = 973,
+    ERR_EQUIPMENT_MANAGER_BAGS_FULL                         = 974,
+    ERR_EQUIPMENT_MANAGER_MISSING_ITEM_S                    = 975,
+    ERR_MOVIE_RECORDING_WARNING_PERF                        = 976,
+    ERR_MOVIE_RECORDING_WARNING_DISK_FULL                   = 977,
+    ERR_MOVIE_RECORDING_WARNING_NO_MOVIE                    = 978,
+    ERR_MOVIE_RECORDING_WARNING_REQUIREMENTS                = 979,
+    ERR_MOVIE_RECORDING_WARNING_COMPRESSING                 = 980,
+    ERR_NO_CHALLENGE_MODE_REWARD                            = 981,
+    ERR_CLAIMED_CHALLENGE_MODE_REWARD                       = 982,
+    ERR_CHALLENGE_MODE_PERIOD_RESET_SS                      = 983,
+    ERR_CANT_DO_THAT_CHALLENGE_MODE_ACTIVE                  = 984,
+    ERR_TALENT_FAILED_REST_AREA                             = 985,
+    ERR_CANNOT_ABANDON_LAST_PET                             = 986,
+    ERR_TEST_CVAR_SET_SSS                                   = 987,
+    ERR_QUEST_TURN_IN_FAIL_REASON                           = 988,
+    ERR_CLAIMED_CHALLENGE_MODE_REWARD_OLD                   = 989,
+    ERR_TALENT_GRANTED_BY_AURA                              = 990,
+    ERR_CHALLENGE_MODE_ALREADY_COMPLETE                     = 991,
+    ERR_GLYPH_TARGET_NOT_AVAILABLE                          = 992,
+    ERR_PVP_WARMODE_TOGGLE_ON                               = 993,
+    ERR_PVP_WARMODE_TOGGLE_OFF                              = 994,
+    ERR_SPELL_FAILED_LEVEL_REQUIREMENT                      = 995,
+    ERR_BATTLEGROUND_JOIN_REQUIRES_LEVEL                    = 996,
+    ERR_BATTLEGROUND_JOIN_DISQUALIFIED                      = 997,
+    ERR_VOICE_CHAT_GENERIC_UNABLE_TO_CONNECT                = 998,
+    ERR_VOICE_CHAT_SERVICE_LOST                             = 999,
+    ERR_VOICE_CHAT_CHANNEL_NAME_TOO_SHORT                   = 1000,
+    ERR_VOICE_CHAT_CHANNEL_NAME_TOO_LONG                    = 1001,
+    ERR_VOICE_CHAT_CHANNEL_ALREADY_EXISTS                   = 1002,
+    ERR_VOICE_CHAT_TARGET_NOT_FOUND                         = 1003,
+    ERR_VOICE_CHAT_TOO_MANY_REQUESTS                        = 1004,
+    ERR_VOICE_CHAT_PLAYER_SILENCED                          = 1005,
+    ERR_VOICE_CHAT_PARENTAL_DISABLE_ALL                     = 1006,
+    ERR_VOICE_CHAT_DISABLED                                 = 1007,
+    ERR_NO_PVP_REWARD                                       = 1008,
+    ERR_CLAIMED_PVP_REWARD                                  = 1009,
 };
 
 #endif
diff --git a/src/server/game/Phasing/PhaseShift.cpp b/src/server/game/Phasing/PhaseShift.cpp
index b2885ae15bb..b7df2e5cd13 100644
--- a/src/server/game/Phasing/PhaseShift.cpp
+++ b/src/server/game/Phasing/PhaseShift.cpp
@@ -60,23 +60,23 @@ PhaseShift::EraseResult<PhaseShift::VisibleMapIdContainer> PhaseShift::RemoveVis
     return { VisibleMapIds.end(), false };
 }
 
-bool PhaseShift::AddUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId, int32 references /*= 1*/)
+bool PhaseShift::AddUiMapPhaseId(uint32 uiMapPhaseId, int32 references /*= 1*/)
 {
-    auto insertResult = UiWorldMapAreaIdSwaps.emplace(uiWorldMapAreaId, UiWorldMapAreaIdSwapRef{ 0 });
+    auto insertResult = UiMapPhaseIds.emplace(uiMapPhaseId, UiMapPhaseIdRef{ 0 });
     insertResult.first->second.References += references;
     return insertResult.second;
 }
 
-PhaseShift::EraseResult<PhaseShift::UiWorldMapAreaIdSwapContainer> PhaseShift::RemoveUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId)
+PhaseShift::EraseResult<PhaseShift::UiMapPhaseIdContainer> PhaseShift::RemoveUiMapPhaseId(uint32 uiMapPhaseId)
 {
-    auto itr = UiWorldMapAreaIdSwaps.find(uiWorldMapAreaId);
-    if (itr != UiWorldMapAreaIdSwaps.end())
+    auto itr = UiMapPhaseIds.find(uiMapPhaseId);
+    if (itr != UiMapPhaseIds.end())
     {
         if (!--itr->second.References)
-            return { UiWorldMapAreaIdSwaps.erase(itr), true };
+            return { UiMapPhaseIds.erase(itr), true };
         return { itr, false };
     }
-    return { UiWorldMapAreaIdSwaps.end(), false };
+    return { UiMapPhaseIds.end(), false };
 }
 
 void PhaseShift::Clear()
@@ -84,7 +84,7 @@ void PhaseShift::Clear()
     ClearPhases();
     PersonalGuid.Clear();
     VisibleMapIds.clear();
-    UiWorldMapAreaIdSwaps.clear();
+    UiMapPhaseIds.clear();
 }
 
 void PhaseShift::ClearPhases()
diff --git a/src/server/game/Phasing/PhaseShift.h b/src/server/game/Phasing/PhaseShift.h
index f1929168613..c15bf4100a2 100644
--- a/src/server/game/Phasing/PhaseShift.h
+++ b/src/server/game/Phasing/PhaseShift.h
@@ -68,7 +68,7 @@ public:
         int32 References = 0;
         TerrainSwapInfo const* VisibleMapInfo = nullptr;
     };
-    struct UiWorldMapAreaIdSwapRef
+    struct UiMapPhaseIdRef
     {
         int32 References = 0;
     };
@@ -80,7 +80,7 @@ public:
     };
     typedef boost::container::flat_set<PhaseRef> PhaseContainer;
     typedef std::map<uint32, VisibleMapIdRef> VisibleMapIdContainer;
-    typedef std::map<uint32, UiWorldMapAreaIdSwapRef> UiWorldMapAreaIdSwapContainer;
+    typedef std::map<uint32, UiMapPhaseIdRef> UiMapPhaseIdContainer;
 
     PhaseShift() : Flags(PhaseShiftFlags::Unphased), NonCosmeticReferences(0), CosmeticReferences(0), DefaultReferences(0), IsDbPhaseShift(false) { }
 
@@ -94,10 +94,10 @@ public:
     bool HasVisibleMapId(uint32 visibleMapId) const { return VisibleMapIds.find(visibleMapId) != VisibleMapIds.end(); }
     VisibleMapIdContainer const& GetVisibleMapIds() const { return VisibleMapIds; }
 
-    bool AddUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId, int32 references = 1);
-    EraseResult<UiWorldMapAreaIdSwapContainer> RemoveUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId);
-    bool HasUiWorldMapAreaIdSwap(uint32 uiWorldMapAreaId) const { return UiWorldMapAreaIdSwaps.find(uiWorldMapAreaId) != UiWorldMapAreaIdSwaps.end(); }
-    UiWorldMapAreaIdSwapContainer const& GetUiWorldMapAreaIdSwaps() const { return UiWorldMapAreaIdSwaps; }
+    bool AddUiMapPhaseId(uint32 uiMapPhaseId, int32 references = 1);
+    EraseResult<UiMapPhaseIdContainer> RemoveUiMapPhaseId(uint32 uiMapPhaseId);
+    bool HasUiMapPhaseId(uint32 uiMapPhaseId) const { return UiMapPhaseIds.find(uiMapPhaseId) != UiMapPhaseIds.end(); }
+    UiMapPhaseIdContainer const& GetUiWorldMapAreaIdSwaps() const { return UiMapPhaseIds; }
 
     void Clear();
     void ClearPhases();
@@ -111,7 +111,7 @@ protected:
     ObjectGuid PersonalGuid;
     PhaseContainer Phases;
     VisibleMapIdContainer VisibleMapIds;
-    UiWorldMapAreaIdSwapContainer UiWorldMapAreaIdSwaps;
+    UiMapPhaseIdContainer UiMapPhaseIds;
 
     void ModifyPhasesReferences(PhaseContainer::iterator itr, int32 references);
     void UpdateUnphasedFlag();
diff --git a/src/server/game/Phasing/PhasingHandler.cpp b/src/server/game/Phasing/PhasingHandler.cpp
index e60c87b4816..1cce3361654 100644
--- a/src/server/game/Phasing/PhasingHandler.cpp
+++ b/src/server/game/Phasing/PhasingHandler.cpp
@@ -146,8 +146,8 @@ void PhasingHandler::AddVisibleMapId(WorldObject* object, uint32 visibleMapId)
     TerrainSwapInfo const* terrainSwapInfo = sObjectMgr->GetTerrainSwapInfo(visibleMapId);
     bool changed = object->GetPhaseShift().AddVisibleMapId(visibleMapId, terrainSwapInfo);
 
-    for (uint32 uiWorldMapAreaIDSwap : terrainSwapInfo->UiWorldMapAreaIDSwaps)
-        changed = object->GetPhaseShift().AddUiWorldMapAreaIdSwap(uiWorldMapAreaIDSwap) || changed;
+    for (uint32 uiMapPhaseId : terrainSwapInfo->UiMapPhaseIDs)
+        changed = object->GetPhaseShift().AddUiMapPhaseId(uiMapPhaseId) || changed;
 
     if (Unit* unit = object->ToUnit())
     {
@@ -165,8 +165,8 @@ void PhasingHandler::RemoveVisibleMapId(WorldObject* object, uint32 visibleMapId
     TerrainSwapInfo const* terrainSwapInfo = sObjectMgr->GetTerrainSwapInfo(visibleMapId);
     bool changed = object->GetPhaseShift().RemoveVisibleMapId(visibleMapId).Erased;
 
-    for (uint32 uiWorldMapAreaIDSwap : terrainSwapInfo->UiWorldMapAreaIDSwaps)
-        changed = object->GetPhaseShift().RemoveUiWorldMapAreaIdSwap(uiWorldMapAreaIDSwap).Erased || changed;
+    for (uint32 uiWorldMapAreaIDSwap : terrainSwapInfo->UiMapPhaseIDs)
+        changed = object->GetPhaseShift().RemoveUiMapPhaseId(uiWorldMapAreaIDSwap).Erased || changed;
 
     if (Unit* unit = object->ToUnit())
     {
@@ -198,18 +198,21 @@ void PhasingHandler::OnMapChange(WorldObject* object)
     ConditionSourceInfo srcInfo = ConditionSourceInfo(object);
 
     object->GetPhaseShift().VisibleMapIds.clear();
-    object->GetPhaseShift().UiWorldMapAreaIdSwaps.clear();
+    object->GetPhaseShift().UiMapPhaseIds.clear();
     object->GetSuppressedPhaseShift().VisibleMapIds.clear();
 
-    if (std::vector<TerrainSwapInfo*> const* visibleMapIds = sObjectMgr->GetTerrainSwapsForMap(object->GetMapId()))
+    for (auto visibleMapPair : sObjectMgr->GetTerrainSwaps())
     {
-        for (TerrainSwapInfo const* visibleMapInfo : *visibleMapIds)
+        for (TerrainSwapInfo const* visibleMapInfo : visibleMapPair.second)
         {
             if (sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, visibleMapInfo->Id, srcInfo))
             {
-                phaseShift.AddVisibleMapId(visibleMapInfo->Id, visibleMapInfo);
-                for (uint32 uiWorldMapAreaIdSwap : visibleMapInfo->UiWorldMapAreaIDSwaps)
-                    phaseShift.AddUiWorldMapAreaIdSwap(uiWorldMapAreaIdSwap);
+                if (visibleMapPair.first == object->GetMapId())
+                    phaseShift.AddVisibleMapId(visibleMapInfo->Id, visibleMapInfo);
+
+                // ui map is visible on all maps
+                for (uint32 uiMapPhaseId : visibleMapInfo->UiMapPhaseIDs)
+                    phaseShift.AddUiMapPhaseId(uiMapPhaseId);
             }
             else
                 suppressedPhaseShift.AddVisibleMapId(visibleMapInfo->Id, visibleMapInfo);
@@ -317,8 +320,8 @@ void PhasingHandler::OnConditionChange(WorldObject* object)
         if (!sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, itr->first, srcInfo))
         {
             newSuppressions.AddVisibleMapId(itr->first, itr->second.VisibleMapInfo, itr->second.References);
-            for (uint32 uiWorldMapAreaIdSwap : itr->second.VisibleMapInfo->UiWorldMapAreaIDSwaps)
-                changed = phaseShift.RemoveUiWorldMapAreaIdSwap(uiWorldMapAreaIdSwap).Erased || changed;
+            for (uint32 uiMapPhaseId : itr->second.VisibleMapInfo->UiMapPhaseIDs)
+                changed = phaseShift.RemoveUiMapPhaseId(uiMapPhaseId).Erased || changed;
 
             itr = phaseShift.VisibleMapIds.erase(itr);
         }
@@ -331,8 +334,8 @@ void PhasingHandler::OnConditionChange(WorldObject* object)
         if (sConditionMgr->IsObjectMeetingNotGroupedConditions(CONDITION_SOURCE_TYPE_TERRAIN_SWAP, itr->first, srcInfo))
         {
             changed = phaseShift.AddVisibleMapId(itr->first, itr->second.VisibleMapInfo, itr->second.References) || changed;
-            for (uint32 uiWorldMapAreaIdSwap : itr->second.VisibleMapInfo->UiWorldMapAreaIDSwaps)
-                changed = phaseShift.AddUiWorldMapAreaIdSwap(uiWorldMapAreaIdSwap) || changed;
+            for (uint32 uiMapPhaseId : itr->second.VisibleMapInfo->UiMapPhaseIDs)
+                changed = phaseShift.AddUiMapPhaseId(uiMapPhaseId) || changed;
 
             itr = suppressedPhaseShift.VisibleMapIds.erase(itr);
         }
@@ -403,9 +406,9 @@ void PhasingHandler::SendToPlayer(Player const* player, PhaseShift const& phaseS
     phaseShiftChange.VisibleMapIDs.reserve(phaseShift.VisibleMapIds.size());
     std::transform(phaseShift.VisibleMapIds.begin(), phaseShift.VisibleMapIds.end(), std::back_inserter(phaseShiftChange.VisibleMapIDs),
         [](PhaseShift::VisibleMapIdContainer::value_type const& visibleMapId) { return visibleMapId.first; });
-    phaseShiftChange.UiWorldMapAreaIDSwaps.reserve(phaseShift.UiWorldMapAreaIdSwaps.size());
-    std::transform(phaseShift.UiWorldMapAreaIdSwaps.begin(), phaseShift.UiWorldMapAreaIdSwaps.end(), std::back_inserter(phaseShiftChange.UiWorldMapAreaIDSwaps),
-        [](PhaseShift::UiWorldMapAreaIdSwapContainer::value_type const& uiWorldMapAreaIdSwap) { return uiWorldMapAreaIdSwap.first; });
+    phaseShiftChange.UiMapPhaseIDs.reserve(phaseShift.UiMapPhaseIds.size());
+    std::transform(phaseShift.UiMapPhaseIds.begin(), phaseShift.UiMapPhaseIds.end(), std::back_inserter(phaseShiftChange.UiMapPhaseIDs),
+        [](PhaseShift::UiMapPhaseIdContainer::value_type const& uiWorldMapAreaIdSwap) { return uiWorldMapAreaIdSwap.first; });
 
     player->SendDirectMessage(phaseShiftChange.Write());
 }
@@ -545,10 +548,10 @@ void PhasingHandler::PrintToChat(ChatHandler* chat, PhaseShift const& phaseShift
         chat->PSendSysMessage(LANG_PHASESHIFT_VISIBLE_MAP_IDS, visibleMapIds.str().c_str());
     }
 
-    if (!phaseShift.UiWorldMapAreaIdSwaps.empty())
+    if (!phaseShift.UiMapPhaseIds.empty())
     {
         std::ostringstream uiWorldMapAreaIdSwaps;
-        for (PhaseShift::UiWorldMapAreaIdSwapContainer::value_type const& uiWorldMapAreaIdSwap : phaseShift.UiWorldMapAreaIdSwaps)
+        for (PhaseShift::UiMapPhaseIdContainer::value_type const& uiWorldMapAreaIdSwap : phaseShift.UiMapPhaseIds)
             uiWorldMapAreaIdSwaps << uiWorldMapAreaIdSwap.first << ',' << ' ';
 
         chat->PSendSysMessage(LANG_PHASESHIFT_UI_WORLD_MAP_AREA_SWAPS, uiWorldMapAreaIdSwaps.str().c_str());
diff --git a/src/server/game/Quests/QuestDef.cpp b/src/server/game/Quests/QuestDef.cpp
index 6a71256a77b..1a6f95244a9 100644
--- a/src/server/game/Quests/QuestDef.cpp
+++ b/src/server/game/Quests/QuestDef.cpp
@@ -37,38 +37,40 @@ Quest::Quest(Field* questRecord)
     ID = questRecord[0].GetUInt32();
     Type = questRecord[1].GetUInt8();
     Level = questRecord[2].GetInt32();
-    MaxScalingLevel = questRecord[3].GetInt32();
-    PackageID = questRecord[4].GetUInt32();
-    MinLevel = questRecord[5].GetInt32();
-    QuestSortID = questRecord[6].GetInt16();
-    QuestInfoID = questRecord[7].GetUInt16();
-    SuggestedPlayers = questRecord[8].GetUInt8();
-    NextQuestInChain = questRecord[9].GetUInt32();
-    RewardXPDifficulty = questRecord[10].GetUInt32();
-    RewardXPMultiplier = questRecord[11].GetFloat();
-    RewardMoney = questRecord[12].GetUInt32();
-    RewardMoneyDifficulty = questRecord[13].GetUInt32();
-    RewardMoneyMultiplier = questRecord[14].GetFloat();
-    RewardBonusMoney = questRecord[15].GetUInt32();
+    ScalingFactionGroup = questRecord[3].GetInt32();
+    MaxScalingLevel = questRecord[4].GetInt32();
+    PackageID = questRecord[5].GetUInt32();
+    MinLevel = questRecord[6].GetInt32();
+    QuestSortID = questRecord[7].GetInt16();
+    QuestInfoID = questRecord[8].GetUInt16();
+    SuggestedPlayers = questRecord[9].GetUInt8();
+    NextQuestInChain = questRecord[10].GetUInt32();
+    RewardXPDifficulty = questRecord[11].GetUInt32();
+    RewardXPMultiplier = questRecord[12].GetFloat();
+    RewardMoney = questRecord[13].GetUInt32();
+    RewardMoneyDifficulty = questRecord[14].GetUInt32();
+    RewardMoneyMultiplier = questRecord[15].GetFloat();
+    RewardBonusMoney = questRecord[16].GetUInt32();
     for (uint32 i = 0; i < QUEST_REWARD_DISPLAY_SPELL_COUNT; ++i)
-        RewardDisplaySpell[i] = questRecord[16 + i].GetUInt32();
-
-    RewardSpell = questRecord[19].GetUInt32();
-    RewardHonor = questRecord[20].GetUInt32();
-    RewardKillHonor = questRecord[21].GetUInt32();
-    SourceItemId = questRecord[22].GetUInt32();
-    RewardArtifactXPDifficulty = questRecord[23].GetUInt32();
-    RewardArtifactXPMultiplier = questRecord[24].GetFloat();
-    RewardArtifactCategoryID = questRecord[25].GetUInt32();
-    Flags = questRecord[26].GetUInt32();
-    FlagsEx = questRecord[27].GetUInt32();
+        RewardDisplaySpell[i] = questRecord[17 + i].GetUInt32();
+
+    RewardSpell = questRecord[20].GetUInt32();
+    RewardHonor = questRecord[21].GetUInt32();
+    RewardKillHonor = questRecord[22].GetUInt32();
+    SourceItemId = questRecord[23].GetUInt32();
+    RewardArtifactXPDifficulty = questRecord[24].GetUInt32();
+    RewardArtifactXPMultiplier = questRecord[25].GetFloat();
+    RewardArtifactCategoryID = questRecord[26].GetUInt32();
+    Flags = questRecord[27].GetUInt32();
+    FlagsEx = questRecord[28].GetUInt32();
+    FlagsEx2 = questRecord[29].GetUInt32();
 
     for (uint32 i = 0; i < QUEST_ITEM_DROP_COUNT; ++i)
     {
-        RewardItemId[i] = questRecord[28 + i * 4].GetUInt32();
-        RewardItemCount[i] = questRecord[29 + i * 4].GetUInt32();
-        ItemDrop[i] = questRecord[30 + i * 4].GetUInt32();
-        ItemDropQuantity[i] = questRecord[31 + i * 4].GetUInt32();
+        RewardItemId[i] = questRecord[30 + i * 4].GetUInt32();
+        RewardItemCount[i] = questRecord[31 + i * 4].GetUInt32();
+        ItemDrop[i] = questRecord[32 + i * 4].GetUInt32();
+        ItemDropQuantity[i] = questRecord[33 + i * 4].GetUInt32();
 
         if (RewardItemId[i])
             ++_rewItemsCount;
@@ -76,63 +78,64 @@ Quest::Quest(Field* questRecord)
 
     for (uint32 i = 0; i < QUEST_REWARD_CHOICES_COUNT; ++i)
     {
-        RewardChoiceItemId[i] = questRecord[44 + i * 3].GetUInt32();
-        RewardChoiceItemCount[i] = questRecord[45 + i * 3].GetUInt32();
-        RewardChoiceItemDisplayId[i] = questRecord[46 + i * 3].GetUInt32();
+        RewardChoiceItemId[i] = questRecord[46 + i * 3].GetUInt32();
+        RewardChoiceItemCount[i] = questRecord[47 + i * 3].GetUInt32();
+        RewardChoiceItemDisplayId[i] = questRecord[48 + i * 3].GetUInt32();
 
         if (RewardChoiceItemId[i])
             ++_rewChoiceItemsCount;
     }
 
-    POIContinent = questRecord[62].GetUInt32();
-    POIx = questRecord[63].GetFloat();
-    POIy = questRecord[64].GetFloat();
-    POIPriority = questRecord[65].GetUInt32();
+    POIContinent = questRecord[64].GetUInt32();
+    POIx = questRecord[65].GetFloat();
+    POIy = questRecord[66].GetFloat();
+    POIPriority = questRecord[67].GetUInt32();
 
-    RewardTitleId = questRecord[66].GetUInt32();
-    RewardArenaPoints = questRecord[67].GetUInt32();
-    RewardSkillId = questRecord[68].GetUInt32();
-    RewardSkillPoints = questRecord[69].GetUInt32();
+    RewardTitleId = questRecord[68].GetUInt32();
+    RewardArenaPoints = questRecord[69].GetUInt32();
+    RewardSkillId = questRecord[70].GetUInt32();
+    RewardSkillPoints = questRecord[71].GetUInt32();
 
-    QuestGiverPortrait = questRecord[70].GetUInt32();
-    QuestTurnInPortrait = questRecord[71].GetUInt32();
+    QuestGiverPortrait = questRecord[72].GetUInt32();
+    QuestGiverPortraitMount = questRecord[73].GetUInt32();
+    QuestTurnInPortrait = questRecord[74].GetUInt32();
 
     for (uint32 i = 0; i < QUEST_REWARD_REPUTATIONS_COUNT; ++i)
     {
-        RewardFactionId[i] = questRecord[72 + i * 4].GetUInt32();
-        RewardFactionValue[i] = questRecord[73 + i * 4].GetInt32();
-        RewardFactionOverride[i] = questRecord[74 + i * 4].GetInt32();
-        RewardFactionCapIn[i] = questRecord[75 + i * 4].GetUInt32();
+        RewardFactionId[i] = questRecord[75 + i * 4].GetUInt32();
+        RewardFactionValue[i] = questRecord[76 + i * 4].GetInt32();
+        RewardFactionOverride[i] = questRecord[77 + i * 4].GetInt32();
+        RewardFactionCapIn[i] = questRecord[78 + i * 4].GetUInt32();
     }
 
-    RewardReputationMask = questRecord[92].GetUInt32();
+    RewardReputationMask = questRecord[95].GetUInt32();
 
     for (uint32 i = 0; i < QUEST_REWARD_CURRENCY_COUNT; ++i)
     {
-        RewardCurrencyId[i] = questRecord[93 + i * 2].GetUInt32();
-        RewardCurrencyCount[i] = questRecord[94 + i * 2].GetUInt32();
+        RewardCurrencyId[i] = questRecord[96 + i * 2].GetUInt32();
+        RewardCurrencyCount[i] = questRecord[97 + i * 2].GetUInt32();
 
         if (RewardCurrencyId[i])
             ++_rewCurrencyCount;
     }
 
-    SoundAccept = questRecord[101].GetUInt32();
-    SoundTurnIn = questRecord[102].GetUInt32();
-    AreaGroupID = questRecord[103].GetUInt32();
-    LimitTime = questRecord[104].GetUInt32();
-    AllowableRaces = questRecord[105].GetUInt64();
-    QuestRewardID = questRecord[106].GetUInt32();
-    Expansion = questRecord[107].GetInt32();
-
-    LogTitle = questRecord[108].GetString();
-    LogDescription = questRecord[109].GetString();
-    QuestDescription = questRecord[110].GetString();
-    AreaDescription = questRecord[111].GetString();
-    PortraitGiverText = questRecord[112].GetString();
-    PortraitGiverName = questRecord[113].GetString();
-    PortraitTurnInText = questRecord[114].GetString();
-    PortraitTurnInName = questRecord[115].GetString();
-    QuestCompletionLog = questRecord[116].GetString();
+    SoundAccept = questRecord[104].GetUInt32();
+    SoundTurnIn = questRecord[105].GetUInt32();
+    AreaGroupID = questRecord[106].GetUInt32();
+    LimitTime = questRecord[107].GetUInt32();
+    AllowableRaces = questRecord[108].GetUInt64();
+    TreasurePickerID = questRecord[109].GetInt32();
+    Expansion = questRecord[110].GetInt32();
+
+    LogTitle = questRecord[111].GetString();
+    LogDescription = questRecord[112].GetString();
+    QuestDescription = questRecord[113].GetString();
+    AreaDescription = questRecord[114].GetString();
+    PortraitGiverText = questRecord[115].GetString();
+    PortraitGiverName = questRecord[116].GetString();
+    PortraitTurnInText = questRecord[117].GetString();
+    PortraitTurnInName = questRecord[118].GetString();
+    QuestCompletionLog = questRecord[119].GetString();
 
     for (uint32 i = 0; i < QUEST_EMOTE_COUNT; ++i)
     {
@@ -255,20 +258,20 @@ void Quest::LoadQuestObjectiveVisualEffect(Field* fields)
     }
 }
 
-uint32 Quest::XPValue(uint32 playerLevel) const
+uint32 Quest::XPValue(Player const* player) const
 {
-    if (playerLevel)
+    if (player)
     {
-        uint32 questLevel = uint32(Level == -1 ? playerLevel : Level);
+        uint32 questLevel = player->GetQuestLevel(this);
         QuestXPEntry const* questXp = sQuestXPStore.LookupEntry(questLevel);
         if (!questXp || RewardXPDifficulty >= 10)
             return 0;
 
         float multiplier = 1.0f;
-        if (questLevel != playerLevel)
-            multiplier = sXpGameTable.GetRow(std::min(playerLevel, questLevel))->Divisor / sXpGameTable.GetRow(playerLevel)->Divisor;
+        if (questLevel != player->getLevel())
+            multiplier = sXpGameTable.GetRow(std::min<int32>(player->getLevel(), questLevel))->Divisor / sXpGameTable.GetRow(player->getLevel())->Divisor;
 
-        int32 diffFactor = 2 * (questLevel - playerLevel) + 20;
+        int32 diffFactor = 2 * (questLevel + (Level == -1 ? 0 : 5) - player->getLevel()) + 10;
         if (diffFactor < 1)
             diffFactor = 1;
         else if (diffFactor > 10)
@@ -290,11 +293,9 @@ uint32 Quest::XPValue(uint32 playerLevel) const
     return 0;
 }
 
-uint32 Quest::MoneyValue(uint8 playerLevel) const
+uint32 Quest::MoneyValue(Player const* player) const
 {
-    uint8 level = Level == -1 ? playerLevel : Level;
-
-    if (QuestMoneyRewardEntry const* money = sQuestMoneyRewardStore.LookupEntry(level))
+    if (QuestMoneyRewardEntry const* money = sQuestMoneyRewardStore.LookupEntry(player->GetQuestLevel(this)))
         return money->Difficulty[GetRewMoneyDifficulty()] * GetMoneyMultiplier();
     else
         return 0;
@@ -315,11 +316,11 @@ void Quest::BuildQuestRewards(WorldPackets::Quest::QuestRewards& rewards, Player
     rewards.SpellCompletionID       = GetRewSpell();
     rewards.SkillLineID             = GetRewardSkillId();
     rewards.NumSkillUps             = GetRewardSkillPoints();
-    rewards.RewardID                = GetRewardId();
+    rewards.TreasurePickerID        = GetTreasurePickerId();
 
     for (uint32 i = 0; i < QUEST_REWARD_CHOICES_COUNT; ++i)
     {
-        rewards.ChoiceItems[i].ItemID = RewardChoiceItemId[i];
+        rewards.ChoiceItems[i].Item.ItemID = RewardChoiceItemId[i];
         rewards.ChoiceItems[i].Quantity = RewardChoiceItemCount[i];
     }
 
diff --git a/src/server/game/Quests/QuestDef.h b/src/server/game/Quests/QuestDef.h
index adbec0efd6c..a8d2d5a701c 100644
--- a/src/server/game/Quests/QuestDef.h
+++ b/src/server/game/Quests/QuestDef.h
@@ -200,6 +200,11 @@ enum QuestFlagsEx : uint32
     QUEST_FLAGS_EX_CLEAR_PROGRESS_OF_CRITERIA_TREE_OBJECTIVES_ON_ACCEPT = 0x1000000
 };
 
+enum QuestFlagsEx2 : uint32
+{
+    QUEST_FLAGS_EX2_NO_WAR_MODE_BONUS   = 0x2
+};
+
 enum QuestSpecialFlags
 {
     QUEST_SPECIAL_FLAGS_NONE                 = 0x000,
@@ -348,17 +353,16 @@ class TC_GAME_API Quest
         void LoadQuestObjective(Field* fields);
         void LoadQuestObjectiveVisualEffect(Field* fields);
 
-        uint32 XPValue(uint32 playerLevel) const;
-        uint32 MoneyValue(uint8 playerLevel) const;
+        uint32 XPValue(Player const* player) const;
+        uint32 MoneyValue(Player const* player) const;
 
-        bool HasFlag(uint32 flag) const { return (Flags & flag) != 0; }
-        void SetFlag(uint32 flag) { Flags |= flag; }
+        bool HasFlag(QuestFlags flag) const { return (Flags & uint32(flag)) != 0; }
+        bool HasFlagEx(QuestFlagsEx flag) const { return (FlagsEx & uint32(flag)) != 0; }
+        bool HasFlagEx2(QuestFlagsEx2 flag) const { return (FlagsEx2 & uint32(flag)) != 0; }
 
         bool HasSpecialFlag(uint32 flag) const { return (SpecialFlags & flag) != 0; }
         void SetSpecialFlag(uint32 flag) { SpecialFlags |= flag; }
 
-        bool HasFlagEx(QuestFlagsEx flag) const { return (FlagsEx & uint32(flag)) != 0; }
-
         // table data accessors:
         uint32 GetQuestId() const { return ID; }
         uint32 GetQuestType() const { return Type; }
@@ -367,6 +371,7 @@ class TC_GAME_API Quest
         int32  GetMinLevel() const { return MinLevel; }
         uint32 GetMaxLevel() const { return MaxLevel; }
         int32  GetQuestLevel() const { return Level; }
+        int32  GetQuestScalingFactionGroup() const { return ScalingFactionGroup; }
         int32  GetQuestMaxScalingLevel() const { return MaxScalingLevel; }
         uint32 GetQuestInfoID() const { return QuestInfoID; }
         uint32 GetAllowableClasses() const { return AllowableClasses; }
@@ -427,15 +432,17 @@ class TC_GAME_API Quest
         bool   IsAutoComplete() const;
         uint32 GetFlags() const { return Flags; }
         uint32 GetFlagsEx() const { return FlagsEx; }
+        uint32 GetFlagsEx2() const { return FlagsEx2; }
         uint32 GetSpecialFlags() const { return SpecialFlags; }
         uint32 GetScriptId() const { return ScriptId; }
         uint32 GetAreaGroupID() const { return AreaGroupID; }
         uint32 GetRewardSkillId() const { return RewardSkillId; }
         uint32 GetRewardSkillPoints() const { return RewardSkillPoints; }
         uint32 GetRewardReputationMask() const { return RewardReputationMask; }
-        uint32 GetRewardId() const { return QuestRewardID; }
+        int32 GetTreasurePickerId() const { return TreasurePickerID; }
         int32 GetExpansion() const { return Expansion; }
         uint32 GetQuestGiverPortrait() const { return QuestGiverPortrait; }
+        int32 GetQuestGiverPortraitMount() const { return QuestGiverPortraitMount; }
         uint32 GetQuestTurnInPortrait() const { return QuestTurnInPortrait; }
         bool   IsDaily() const { return (Flags & QUEST_FLAGS_DAILY) != 0; }
         bool   IsWeekly() const { return (Flags & QUEST_FLAGS_WEEKLY) != 0; }
@@ -469,6 +476,7 @@ class TC_GAME_API Quest
         uint32 ID;
         uint32 Type;
         int32  Level;
+        int32  ScalingFactionGroup;
         int32  MaxScalingLevel;
         uint32 PackageID;
         int32  MinLevel;
@@ -492,6 +500,7 @@ class TC_GAME_API Quest
         uint32 SourceItemId;
         uint32 Flags;
         uint32 FlagsEx;
+        uint32 FlagsEx2;
         uint32 RewardItemId[QUEST_REWARD_ITEM_COUNT];
         uint32 RewardItemCount[QUEST_REWARD_ITEM_COUNT];
         uint32 ItemDrop[QUEST_ITEM_DROP_COUNT];
@@ -508,6 +517,7 @@ class TC_GAME_API Quest
         uint32 RewardSkillId;
         uint32 RewardSkillPoints;
         uint32 QuestGiverPortrait;
+        int32 QuestGiverPortraitMount;
         uint32 QuestTurnInPortrait;
         uint32 RewardFactionId[QUEST_REWARD_REPUTATIONS_COUNT];
         int32  RewardFactionValue[QUEST_REWARD_REPUTATIONS_COUNT];
@@ -521,7 +531,7 @@ class TC_GAME_API Quest
         uint32 AreaGroupID;
         uint32 LimitTime;
         uint64 AllowableRaces;
-        uint32 QuestRewardID;
+        int32 TreasurePickerID;
         int32 Expansion;
         QuestObjectives Objectives;
         std::string LogTitle;
diff --git a/src/server/game/Scenarios/ScenarioMgr.cpp b/src/server/game/Scenarios/ScenarioMgr.cpp
index c70e560efd7..1fb6dc4d18b 100644
--- a/src/server/game/Scenarios/ScenarioMgr.cpp
+++ b/src/server/game/Scenarios/ScenarioMgr.cpp
@@ -147,8 +147,8 @@ void ScenarioMgr::LoadScenarioPOI()
 
     uint32 count = 0;
 
-    //                                                      0            1        2     6          7           8       9       10         11               12
-    QueryResult result = WorldDatabase.Query("SELECT CriteriaTreeID, BlobIndex, Idx1, MapID, WorldMapAreaId, Floor, Priority, Flags, WorldEffectID, PlayerConditionID FROM scenario_poi ORDER BY CriteriaTreeID, Idx1");
+    //                                                      0            1        2     3       4         5       6          7               8
+    QueryResult result = WorldDatabase.Query("SELECT CriteriaTreeID, BlobIndex, Idx1, MapID, UiMapID, Priority, Flags, WorldEffectID, PlayerConditionID FROM scenario_poi ORDER BY CriteriaTreeID, Idx1");
     if (!result)
     {
         TC_LOG_ERROR("server.loading", ">> Loaded 0 scenario POI definitions. DB table `scenario_poi` is empty.");
@@ -188,24 +188,23 @@ void ScenarioMgr::LoadScenarioPOI()
     {
         Field* fields = result->Fetch();
 
-        int32 CriteriaTreeID = fields[0].GetInt32();
-        int32 BlobIndex = fields[1].GetInt32();
-        int32 Idx1 = fields[2].GetInt32();
-        int32 MapID = fields[3].GetInt32();
-        int32 WorldMapAreaId = fields[4].GetInt32();
-        int32 Floor = fields[5].GetInt32();
-        int32 Priority = fields[6].GetInt32();
-        int32 Flags = fields[7].GetInt32();
-        int32 WorldEffectID = fields[8].GetInt32();
-        int32 PlayerConditionID = fields[9].GetInt32();
-
-        if (!sCriteriaMgr->GetCriteriaTree(CriteriaTreeID))
-            TC_LOG_ERROR("sql.sql", "`scenario_poi` CriteriaTreeID (%u) Idx1 (%u) does not correspond to a valid criteria tree", CriteriaTreeID, Idx1);
-
-        if (CriteriaTreeID < int32(POIs.size()) && Idx1 < int32(POIs[CriteriaTreeID].size()))
-            _scenarioPOIStore[CriteriaTreeID].emplace_back(BlobIndex, MapID, WorldMapAreaId, Floor, Priority, Flags, WorldEffectID, PlayerConditionID, POIs[CriteriaTreeID][Idx1]);
+        int32 criteriaTreeID = fields[0].GetInt32();
+        int32 blobIndex = fields[1].GetInt32();
+        int32 idx1 = fields[2].GetInt32();
+        int32 mapID = fields[3].GetInt32();
+        int32 uiMapID = fields[4].GetInt32();
+        int32 priority = fields[5].GetInt32();
+        int32 flags = fields[6].GetInt32();
+        int32 worldEffectID = fields[7].GetInt32();
+        int32 playerConditionID = fields[8].GetInt32();
+
+        if (!sCriteriaMgr->GetCriteriaTree(criteriaTreeID))
+            TC_LOG_ERROR("sql.sql", "`scenario_poi` CriteriaTreeID (%u) Idx1 (%u) does not correspond to a valid criteria tree", criteriaTreeID, idx1);
+
+        if (criteriaTreeID < int32(POIs.size()) && idx1 < int32(POIs[criteriaTreeID].size()))
+            _scenarioPOIStore[criteriaTreeID].emplace_back(blobIndex, mapID, uiMapID, priority, flags, worldEffectID, playerConditionID, POIs[criteriaTreeID][idx1]);
         else
-            TC_LOG_ERROR("server.loading", "Table scenario_poi references unknown scenario poi points for criteria tree id %i POI id %i", CriteriaTreeID, BlobIndex);
+            TC_LOG_ERROR("server.loading", "Table scenario_poi references unknown scenario poi points for criteria tree id %i POI id %i", criteriaTreeID, blobIndex);
 
         ++count;
     } while (result->NextRow());
diff --git a/src/server/game/Scenarios/ScenarioMgr.h b/src/server/game/Scenarios/ScenarioMgr.h
index 93a1f3a320f..932d4decce9 100644
--- a/src/server/game/Scenarios/ScenarioMgr.h
+++ b/src/server/game/Scenarios/ScenarioMgr.h
@@ -74,23 +74,22 @@ struct ScenarioPOI
 {
     int32 BlobIndex;
     int32 MapID;
-    int32 WorldMapAreaID;
-    int32 Floor;
+    int32 UiMapID;
     int32 Priority;
     int32 Flags;
     int32 WorldEffectID;
     int32 PlayerConditionID;
     std::vector<ScenarioPOIPoint> Points;
 
-    ScenarioPOI() : BlobIndex(0), MapID(0), WorldMapAreaID(0), Floor(0), Priority(0), Flags(0), WorldEffectID(0), PlayerConditionID(0) { }
+    ScenarioPOI() : BlobIndex(0), MapID(0), UiMapID(0), Priority(0), Flags(0), WorldEffectID(0), PlayerConditionID(0) { }
 
-    ScenarioPOI(int32 _BlobIndex, int32 _MapID, int32 _WorldMapAreaID, int32 _Floor, int32 _Priority, int32 _Flags, int32 _WorldEffectID,
-        int32 _PlayerConditionID, std::vector<ScenarioPOIPoint> points) :
-        BlobIndex(_BlobIndex), MapID(_MapID), WorldMapAreaID(_WorldMapAreaID), Floor(_Floor), Priority(_Priority), Flags(_Flags), WorldEffectID(_WorldEffectID),
-        PlayerConditionID(_PlayerConditionID), Points(std::move(points)) { }
+    ScenarioPOI(int32 blobIndex, int32 mapID, int32 uiMapID, int32 priority, int32 flags, int32 worldEffectID,
+        int32 playerConditionID, std::vector<ScenarioPOIPoint> points) :
+        BlobIndex(blobIndex), MapID(mapID), UiMapID(uiMapID), Priority(priority), Flags(flags), WorldEffectID(worldEffectID),
+        PlayerConditionID(playerConditionID), Points(std::move(points)) { }
 
     ScenarioPOI(ScenarioPOI&& scenarioPOI) :
-        BlobIndex(scenarioPOI.BlobIndex), MapID(scenarioPOI.MapID), WorldMapAreaID(scenarioPOI.WorldMapAreaID), Floor(scenarioPOI.Floor), Priority(scenarioPOI.Priority),
+        BlobIndex(scenarioPOI.BlobIndex), MapID(scenarioPOI.MapID), UiMapID(scenarioPOI.UiMapID), Priority(scenarioPOI.Priority),
         Flags(scenarioPOI.Flags), WorldEffectID(scenarioPOI.WorldEffectID), PlayerConditionID(scenarioPOI.PlayerConditionID), Points(std::move(scenarioPOI.Points)) { }
 };
 
diff --git a/src/server/game/Server/Packets/AchievementPackets.cpp b/src/server/game/Server/Packets/AchievementPackets.cpp
index 87181b3006a..2c746b77ad6 100644
--- a/src/server/game/Server/Packets/AchievementPackets.cpp
+++ b/src/server/game/Server/Packets/AchievementPackets.cpp
@@ -111,7 +111,7 @@ WorldPacket const* WorldPackets::Achievement::AchievementEarned::Write()
     return &_worldPacket;
 }
 
-WorldPacket const* WorldPackets::Achievement::ServerFirstAchievement::Write()
+WorldPacket const* WorldPackets::Achievement::BroadcastAchievement::Write()
 {
     _worldPacket.WriteBits(Name.length(), 7);
     _worldPacket.WriteBit(GuildAchievement);
diff --git a/src/server/game/Server/Packets/AchievementPackets.h b/src/server/game/Server/Packets/AchievementPackets.h
index 56b027d024d..69262eae72f 100644
--- a/src/server/game/Server/Packets/AchievementPackets.h
+++ b/src/server/game/Server/Packets/AchievementPackets.h
@@ -101,7 +101,7 @@ namespace WorldPackets
         class AchievementDeleted final : public ServerPacket
         {
         public:
-            AchievementDeleted() : ServerPacket(SMSG_ACHIEVEMENT_DELETED, 4) { }
+            AchievementDeleted() : ServerPacket(SMSG_ACHIEVEMENT_DELETED, 8) { }
 
             WorldPacket const* Write() override;
 
@@ -125,10 +125,10 @@ namespace WorldPackets
             ObjectGuid Sender;
         };
 
-        class ServerFirstAchievement final : public ServerPacket
+        class BroadcastAchievement final : public ServerPacket
         {
         public:
-            ServerFirstAchievement() : ServerPacket(SMSG_SERVER_FIRST_ACHIEVEMENT) { }
+            BroadcastAchievement() : ServerPacket(SMSG_BROADCAST_ACHIEVEMENT) { }
 
             WorldPacket const* Write() override;
 
diff --git a/src/server/game/Server/Packets/AreaTriggerPackets.cpp b/src/server/game/Server/Packets/AreaTriggerPackets.cpp
index f99d9831f91..6b4047d0995 100644
--- a/src/server/game/Server/Packets/AreaTriggerPackets.cpp
+++ b/src/server/game/Server/Packets/AreaTriggerPackets.cpp
@@ -33,7 +33,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::AreaTrigger::AreaTriggerS
 
 ByteBuffer& operator<<(ByteBuffer& data, AreaTriggerCircularMovementInfo const& areaTriggerCircularMovement)
 {
-    data.WriteBit(areaTriggerCircularMovement.TargetGUID.is_initialized());
+    data.WriteBit(areaTriggerCircularMovement.PathTarget.is_initialized());
     data.WriteBit(areaTriggerCircularMovement.Center.is_initialized());
     data.WriteBit(areaTriggerCircularMovement.CounterClockwise);
     data.WriteBit(areaTriggerCircularMovement.CanLoop);
@@ -46,8 +46,8 @@ ByteBuffer& operator<<(ByteBuffer& data, AreaTriggerCircularMovementInfo const&
     data << float(areaTriggerCircularMovement.InitialAngle);
     data << float(areaTriggerCircularMovement.ZOffset);
 
-    if (areaTriggerCircularMovement.TargetGUID)
-        data << *areaTriggerCircularMovement.TargetGUID;
+    if (areaTriggerCircularMovement.PathTarget)
+        data << *areaTriggerCircularMovement.PathTarget;
 
     if (areaTriggerCircularMovement.Center)
         data << *areaTriggerCircularMovement.Center;
@@ -74,14 +74,6 @@ WorldPacket const* WorldPackets::AreaTrigger::AreaTriggerDenied::Write()
 WorldPacket const* WorldPackets::AreaTrigger::AreaTriggerRePath::Write()
 {
     _worldPacket << TriggerGUID;
-    _worldPacket << AreaTriggerSpline;
-
-    return &_worldPacket;
-}
-
-WorldPacket const* WorldPackets::AreaTrigger::AreaTriggerReShape::Write()
-{
-    _worldPacket << TriggerGUID;
 
     _worldPacket.WriteBit(AreaTriggerSpline.is_initialized());
     _worldPacket.WriteBit(AreaTriggerCircularMovement.is_initialized());
diff --git a/src/server/game/Server/Packets/AreaTriggerPackets.h b/src/server/game/Server/Packets/AreaTriggerPackets.h
index e3872493481..b3abf08c5d9 100644
--- a/src/server/game/Server/Packets/AreaTriggerPackets.h
+++ b/src/server/game/Server/Packets/AreaTriggerPackets.h
@@ -68,18 +68,7 @@ namespace WorldPackets
         class AreaTriggerRePath final : public ServerPacket
         {
         public:
-            AreaTriggerRePath() : ServerPacket(SMSG_AREA_TRIGGER_RE_PATH, 50) { }
-
-            WorldPacket const* Write() override;
-
-            AreaTriggerSplineInfo AreaTriggerSpline;
-            ObjectGuid TriggerGUID;
-        };
-
-        class AreaTriggerReShape final : public ServerPacket
-        {
-        public:
-            AreaTriggerReShape() : ServerPacket(SMSG_AREA_TRIGGER_RE_SHAPE, 17) { }
+            AreaTriggerRePath() : ServerPacket(SMSG_AREA_TRIGGER_RE_PATH, 17) { }
 
             WorldPacket const* Write() override;
 
diff --git a/src/server/game/Server/Packets/ArtifactPackets.cpp b/src/server/game/Server/Packets/ArtifactPackets.cpp
index 8666b709cf0..2612b384f8c 100644
--- a/src/server/game/Server/Packets/ArtifactPackets.cpp
+++ b/src/server/game/Server/Packets/ArtifactPackets.cpp
@@ -69,11 +69,3 @@ WorldPacket const* WorldPackets::Artifact::ArtifactXpGain::Write()
 
     return &_worldPacket;
 }
-
-WorldPacket const* WorldPackets::Artifact::ArtifactKnowledge::Write()
-{
-    _worldPacket << int32(ArtifactCategoryID);
-    _worldPacket << int8(KnowledgeLevel);
-
-    return &_worldPacket;
-}
diff --git a/src/server/game/Server/Packets/ArtifactPackets.h b/src/server/game/Server/Packets/ArtifactPackets.h
index 25934b75c28..f208a906413 100644
--- a/src/server/game/Server/Packets/ArtifactPackets.h
+++ b/src/server/game/Server/Packets/ArtifactPackets.h
@@ -99,17 +99,6 @@ namespace WorldPackets
             ObjectGuid ArtifactGUID;
             uint64 Amount = 0;
         };
-
-        class ArtifactKnowledge final : public ServerPacket
-        {
-        public:
-            ArtifactKnowledge() : ServerPacket(SMSG_ARTIFACT_KNOWLEDGE, 1 + 4) { }
-
-            WorldPacket const* Write() override;
-
-            int32 ArtifactCategoryID = 0;
-            int8 KnowledgeLevel = 0;
-        };
     }
 }
 
diff --git a/src/server/game/Server/Packets/AuthenticationPackets.cpp b/src/server/game/Server/Packets/AuthenticationPackets.cpp
index c28b8281ede..44e9608bddd 100644
--- a/src/server/game/Server/Packets/AuthenticationPackets.cpp
+++ b/src/server/game/Server/Packets/AuthenticationPackets.cpp
@@ -84,8 +84,6 @@ void WorldPackets::Auth::AuthSession::Read()
     uint32 realmJoinTicketSize;
 
     _worldPacket >> DosResponse;
-    _worldPacket >> Build;
-    _worldPacket >> BuildType;
     _worldPacket >> RegionID;
     _worldPacket >> BattlegroupID;
     _worldPacket >> RealmID;
@@ -145,6 +143,7 @@ WorldPacket const* WorldPackets::Auth::AuthResponse::Write()
         _worldPacket.WriteBit(SuccessInfo->ForceCharacterTemplate);
         _worldPacket.WriteBit(SuccessInfo->NumPlayersHorde.is_initialized());
         _worldPacket.WriteBit(SuccessInfo->NumPlayersAlliance.is_initialized());
+        _worldPacket.WriteBit(SuccessInfo->ExpansionTrialExpiration.is_initialized());
         _worldPacket.FlushBits();
 
         {
@@ -164,6 +163,9 @@ WorldPacket const* WorldPackets::Auth::AuthResponse::Write()
         if (SuccessInfo->NumPlayersAlliance)
             _worldPacket << uint16(*SuccessInfo->NumPlayersAlliance);
 
+        if (SuccessInfo->ExpansionTrialExpiration)
+            _worldPacket << int32(*SuccessInfo->ExpansionTrialExpiration);
+
         for (VirtualRealmInfo const& virtualRealm : SuccessInfo->VirtualRealms)
             _worldPacket << virtualRealm;
 
diff --git a/src/server/game/Server/Packets/AuthenticationPackets.h b/src/server/game/Server/Packets/AuthenticationPackets.h
index 97662944f09..7b0e50844bb 100644
--- a/src/server/game/Server/Packets/AuthenticationPackets.h
+++ b/src/server/game/Server/Packets/AuthenticationPackets.h
@@ -83,8 +83,6 @@ namespace WorldPackets
                 Digest.fill(0);
             }
 
-            uint16 Build = 0;
-            int8 BuildType = 0;
             uint32 RegionID = 0;
             uint32 BattlegroupID = 0;
             uint32 RealmID = 0;
@@ -159,6 +157,7 @@ namespace WorldPackets
                 bool ForceCharacterTemplate = false; ///< forces the client to always use a character template when creating a new character. @see Templates. @todo implement
                 Optional<uint16> NumPlayersHorde; ///< number of horde players in this realm. @todo implement
                 Optional<uint16> NumPlayersAlliance; ///< number of alliance players in this realm. @todo implement
+                Optional<int32> ExpansionTrialExpiration; ///< expansion trial expiration unix timestamp
             };
 
             AuthResponse();
diff --git a/src/server/game/Server/Packets/BattlegroundPackets.cpp b/src/server/game/Server/Packets/BattlegroundPackets.cpp
index 05851fb1dfd..14ae46e105a 100644
--- a/src/server/game/Server/Packets/BattlegroundPackets.cpp
+++ b/src/server/game/Server/Packets/BattlegroundPackets.cpp
@@ -67,9 +67,11 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Battleground::PVPLogData:
     data << uint32(playerData.HealingDone);
     data << uint32(playerData.Stats.size());
     data << int32(playerData.PrimaryTalentTree);
-    data << int32(playerData.PrimaryTalentTreeNameIndex);
+    data << int32(playerData.Sex);
     data << int32(playerData.Race);
-    data << uint32(playerData.Prestige);
+    data << int32(playerData.Class);
+    data << int32(playerData.CreatureID);
+    data << int32(playerData.HonorLevel);
     if (!playerData.Stats.empty())
         data.append(playerData.Stats.data(), playerData.Stats.size());
 
@@ -89,13 +91,13 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Battleground::PVPLogData:
         data << uint32(*playerData.PreMatchRating);
 
     if (playerData.RatingChange)
-        data << uint32(*playerData.RatingChange);
+        data << int32(*playerData.RatingChange);
 
     if (playerData.PreMatchMMR)
         data << uint32(*playerData.PreMatchMMR);
 
     if (playerData.MmrChange)
-        data << uint32(*playerData.MmrChange);
+        data << int32(*playerData.MmrChange);
 
     return data;
 }
diff --git a/src/server/game/Server/Packets/BattlegroundPackets.h b/src/server/game/Server/Packets/BattlegroundPackets.h
index 7340d8d7fc9..14ebc283cb5 100644
--- a/src/server/game/Server/Packets/BattlegroundPackets.h
+++ b/src/server/game/Server/Packets/BattlegroundPackets.h
@@ -122,9 +122,11 @@ namespace WorldPackets
                 Optional<int32> MmrChange;
                 std::vector<int32> Stats;
                 int32 PrimaryTalentTree = 0;
-                int32 PrimaryTalentTreeNameIndex = 0;  // controls which name field from ChrSpecialization.dbc will be sent to lua
+                int32 Sex = 0;
                 int32 Race = 0;
-                uint32 Prestige = 0;
+                int32 Class = 0;
+                int32 CreatureID = 0;
+                int32 HonorLevel = 0;
             };
 
             Optional<uint8> Winner;
diff --git a/src/server/game/Server/Packets/CalendarPackets.cpp b/src/server/game/Server/Packets/CalendarPackets.cpp
index 5292bb69b99..7c82bd9d377 100644
--- a/src/server/game/Server/Packets/CalendarPackets.cpp
+++ b/src/server/game/Server/Packets/CalendarPackets.cpp
@@ -24,7 +24,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarSendCal
     data.AppendPackedTime(eventInfo.Date);
     data << uint32(eventInfo.Flags);
     data << int32(eventInfo.TextureID);
-    data << eventInfo.EventGuildID;
+    data << uint64(eventInfo.EventClubID);
     data << eventInfo.OwnerGuid;
 
     data.WriteBits(eventInfo.EventName.size(), 8);
@@ -80,8 +80,9 @@ void WorldPackets::Calendar::CalendarGetEvent::Read()
     _worldPacket >> EventID;
 }
 
-void WorldPackets::Calendar::CalendarGuildFilter::Read()
+void WorldPackets::Calendar::CalendarCommunityFilter::Read()
 {
+    _worldPacket >> ClubID;
     _worldPacket >> MinLevel;
     _worldPacket >> MaxLevel;
     _worldPacket >> MaxRankOrder;
@@ -92,26 +93,45 @@ ByteBuffer& operator>>(ByteBuffer& buffer, WorldPackets::Calendar::CalendarAddEv
     buffer >> invite.Guid;
     buffer >> invite.Status;
     buffer >> invite.Moderator;
+    if (buffer.ReadBit())
+        invite.Unused_801_1 = boost::in_place();
+
+    if (buffer.ReadBit())
+        invite.Unused_801_2 = boost::in_place();
+
+    if (buffer.ReadBit())
+        invite.Unused_801_3 = boost::in_place();
+
+    if (invite.Unused_801_1)
+        buffer >> *invite.Unused_801_1;
+
+    if (invite.Unused_801_2)
+        buffer >> *invite.Unused_801_2;
+
+    if (invite.Unused_801_3)
+        buffer >> *invite.Unused_801_3;
+
     return buffer;
 }
 
 ByteBuffer& operator>>(ByteBuffer& buffer, WorldPackets::Calendar::CalendarAddEventInfo& addEventInfo)
 {
-    uint8 titleLength = buffer.ReadBits(8);
-    uint16 descriptionLength = buffer.ReadBits(11);
-
+    buffer >> addEventInfo.ClubID;
     buffer >> addEventInfo.EventType;
     buffer >> addEventInfo.TextureID;
     addEventInfo.Time = buffer.ReadPackedTime();
     buffer >> addEventInfo.Flags;
     addEventInfo.Invites.resize(buffer.read<uint32>());
 
-    addEventInfo.Title = buffer.ReadString(titleLength);
-    addEventInfo.Description = buffer.ReadString(descriptionLength);
+    uint8 titleLength = buffer.ReadBits(8);
+    uint16 descriptionLength = buffer.ReadBits(11);
 
     for (WorldPackets::Calendar::CalendarAddEventInviteInfo& invite : addEventInfo.Invites)
         buffer >> invite;
 
+    addEventInfo.Title = buffer.ReadString(titleLength);
+    addEventInfo.Description = buffer.ReadString(descriptionLength);
+
     return buffer;
 }
 
@@ -121,20 +141,28 @@ void WorldPackets::Calendar::CalendarAddEvent::Read()
     _worldPacket >> MaxSize;
 }
 
-void WorldPackets::Calendar::CalendarUpdateEvent::Read()
+ByteBuffer& operator>>(ByteBuffer& buffer, WorldPackets::Calendar::CalendarUpdateEventInfo& updateEventInfo)
 {
-    _worldPacket >> EventInfo.EventID;
-    _worldPacket >> EventInfo.ModeratorID;
-    _worldPacket >> EventInfo.EventType;
-    _worldPacket >> EventInfo.TextureID;
-    EventInfo.Time = _worldPacket.ReadPackedTime();
-    _worldPacket >> EventInfo.Flags;
+    buffer >> updateEventInfo.ClubID;
+    buffer >> updateEventInfo.EventID;
+    buffer >> updateEventInfo.ModeratorID;
+    buffer >> updateEventInfo.EventType;
+    buffer >> updateEventInfo.TextureID;
+    updateEventInfo.Time = buffer.ReadPackedTime();
+    buffer >> updateEventInfo.Flags;
 
-    uint8 titleLen = _worldPacket.ReadBits(8);
-    uint16 descLen = _worldPacket.ReadBits(11);
+    uint8 titleLen = buffer.ReadBits(8);
+    uint16 descLen = buffer.ReadBits(11);
 
-    EventInfo.Title = _worldPacket.ReadString(titleLen);
-    EventInfo.Description = _worldPacket.ReadString(descLen);
+    updateEventInfo.Title = buffer.ReadString(titleLen);
+    updateEventInfo.Description = buffer.ReadString(descLen);
+
+    return buffer;
+}
+
+void WorldPackets::Calendar::CalendarUpdateEvent::Read()
+{
+    _worldPacket >> EventInfo;
     _worldPacket >> MaxSize;
 }
 
@@ -142,6 +170,7 @@ void WorldPackets::Calendar::CalendarRemoveEvent::Read()
 {
     _worldPacket >> EventID;
     _worldPacket >> ModeratorID;
+    _worldPacket >> ClubID;
     _worldPacket >> Flags;
 }
 
@@ -149,6 +178,7 @@ void WorldPackets::Calendar::CalendarCopyEvent::Read()
 {
     _worldPacket >> EventID;
     _worldPacket >> ModeratorID;
+    _worldPacket >> EventClubID;
     Date = _worldPacket.ReadPackedTime();
 }
 
@@ -163,6 +193,7 @@ void WorldPackets::Calendar::CalendarEventInvite::Read()
 {
     _worldPacket >> EventID;
     _worldPacket >> ModeratorID;
+    _worldPacket >> ClubID;
 
     uint16 nameLen = _worldPacket.ReadBits(9);
     Creating = _worldPacket.ReadBit();
@@ -174,6 +205,7 @@ void WorldPackets::Calendar::CalendarEventInvite::Read()
 void WorldPackets::Calendar::CalendarEventSignUp::Read()
 {
     _worldPacket >> EventID;
+    _worldPacket >> ClubID;
     Tentative = _worldPacket.ReadBit();
 }
 
@@ -255,7 +287,7 @@ WorldPacket const* WorldPackets::Calendar::CalendarSendEvent::Write()
     _worldPacket << uint32(Flags);
     _worldPacket.AppendPackedTime(Date);
     _worldPacket << uint32(LockDate);
-    _worldPacket << EventGuildID;
+    _worldPacket << uint64(EventClubID);
     _worldPacket << uint32(Invites.size());
     _worldPacket.WriteBits(EventName.size(), 8);
     _worldPacket.WriteBits(Description.size(), 11);
@@ -277,7 +309,7 @@ WorldPacket const* WorldPackets::Calendar::CalendarEventInviteAlert::Write()
     _worldPacket << uint32(Flags);
     _worldPacket << uint8(EventType);
     _worldPacket << int32(TextureID);
-    _worldPacket << EventGuildID;
+    _worldPacket << uint64(EventClubID);
     _worldPacket << uint64(InviteID);
     _worldPacket << uint8(Status);
     _worldPacket << uint8(ModeratorStatus);
@@ -344,6 +376,7 @@ WorldPacket const* WorldPackets::Calendar::CalendarEventInviteRemovedAlert::Writ
 
 WorldPacket const* WorldPackets::Calendar::CalendarEventUpdatedAlert::Write()
 {
+    _worldPacket << uint64(EventClubID);
     _worldPacket << uint64(EventID);
 
     _worldPacket.AppendPackedTime(OriginalDate);
@@ -462,8 +495,8 @@ WorldPacket const* WorldPackets::Calendar::CalendarEventInviteNotes::Write()
     _worldPacket << InviteGuid;
     _worldPacket << uint64(EventID);
 
-    _worldPacket.WriteBits(Notes.size(), 8);
     _worldPacket.WriteBit(ClearPending);
+    _worldPacket.WriteBits(Notes.size(), 8);
     _worldPacket.FlushBits();
     _worldPacket.WriteString(Notes);
 
diff --git a/src/server/game/Server/Packets/CalendarPackets.h b/src/server/game/Server/Packets/CalendarPackets.h
index f7337386c3c..7757e51144b 100644
--- a/src/server/game/Server/Packets/CalendarPackets.h
+++ b/src/server/game/Server/Packets/CalendarPackets.h
@@ -45,13 +45,14 @@ namespace WorldPackets
             uint64 EventID = 0;
         };
 
-        class CalendarGuildFilter final : public ClientPacket
+        class CalendarCommunityFilter final : public ClientPacket
         {
         public:
-            CalendarGuildFilter(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_GUILD_FILTER, std::move(packet)) { }
+            CalendarCommunityFilter(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_COMMUNITY_FILTER, std::move(packet)) { }
 
             void Read() override;
 
+            uint64 ClubID = 0;
             uint8 MinLevel = 1;
             uint8 MaxLevel = 100;
             uint8 MaxRankOrder = 0;
@@ -62,10 +63,14 @@ namespace WorldPackets
             ObjectGuid Guid;
             uint8 Status = 0;
             uint8 Moderator = 0;
+            Optional<ObjectGuid> Unused_801_1;
+            Optional<uint64> Unused_801_2;
+            Optional<uint64> Unused_801_3;
         };
 
         struct CalendarAddEventInfo
         {
+            uint64 ClubID = 0;
             std::string Title;
             std::string Description;
             uint8 EventType = 0;
@@ -88,6 +93,7 @@ namespace WorldPackets
 
         struct CalendarUpdateEventInfo
         {
+            uint64 ClubID = 0;
             uint64 EventID = 0;
             uint64 ModeratorID = 0;
             std::string Title;
@@ -118,6 +124,7 @@ namespace WorldPackets
 
             uint64 ModeratorID = 0;
             uint64 EventID = 0;
+            uint64 ClubID = 0;
             uint32 Flags = 0;
         };
 
@@ -130,6 +137,7 @@ namespace WorldPackets
 
             uint64 ModeratorID = 0;
             uint64 EventID = 0;
+            uint64 EventClubID = 0;
             time_t Date = time_t(0);
         };
 
@@ -176,7 +184,7 @@ namespace WorldPackets
             time_t Date = time_t(0);
             uint32 Flags = 0;
             int32 TextureID = 0;
-            ObjectGuid EventGuildID;
+            uint64 EventClubID = 0;
             ObjectGuid OwnerGuid;
         };
 
@@ -213,7 +221,7 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             ObjectGuid OwnerGuid;
-            ObjectGuid EventGuildID;
+            uint64 EventClubID = 0;
             uint64 EventID = 0;
             time_t Date = time_t(0);
             time_t LockDate = time_t(0);
@@ -234,7 +242,7 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             ObjectGuid OwnerGuid;
-            ObjectGuid EventGuildID;
+            uint64 EventClubID = 0;
             ObjectGuid InvitedByGuid;
             uint64 InviteID = 0;
             uint64 EventID = 0;
@@ -258,6 +266,7 @@ namespace WorldPackets
             bool IsSignUp = false;
             bool Creating = true;
             uint64 EventID = 0;
+            uint64 ClubID = 0;
             std::string Name;
         };
 
@@ -343,6 +352,7 @@ namespace WorldPackets
 
             WorldPacket const* Write() override;
 
+            uint64 EventClubID = 0;
             uint64 EventID = 0;
             time_t Date = time_t(0);
             uint32 Flags = 0;
@@ -395,6 +405,7 @@ namespace WorldPackets
 
             bool Tentative = false;
             uint64 EventID = 0;
+            uint64 ClubID = 0;
         };
 
         class CalendarRemoveInvite final : public ClientPacket
diff --git a/src/server/game/Server/Packets/ChannelPackets.cpp b/src/server/game/Server/Packets/ChannelPackets.cpp
index fe6969d07cf..d5cb727b441 100644
--- a/src/server/game/Server/Packets/ChannelPackets.cpp
+++ b/src/server/game/Server/Packets/ChannelPackets.cpp
@@ -128,7 +128,6 @@ WorldPackets::Channel::ChannelCommand::ChannelCommand(WorldPacket&& packet) : Cl
         case CMSG_CHAT_CHANNEL_DECLINE_INVITE:
         case CMSG_CHAT_CHANNEL_DISPLAY_LIST:
         case CMSG_CHAT_CHANNEL_LIST:
-        case CMSG_CHAT_CHANNEL_MODERATE:
         case CMSG_CHAT_CHANNEL_OWNER:
             break;
         default:
@@ -150,12 +149,10 @@ WorldPackets::Channel::ChannelPlayerCommand::ChannelPlayerCommand(WorldPacket&&
         case CMSG_CHAT_CHANNEL_INVITE:
         case CMSG_CHAT_CHANNEL_KICK:
         case CMSG_CHAT_CHANNEL_MODERATOR:
-        case CMSG_CHAT_CHANNEL_MUTE:
         case CMSG_CHAT_CHANNEL_SET_OWNER:
         case CMSG_CHAT_CHANNEL_SILENCE_ALL:
         case CMSG_CHAT_CHANNEL_UNBAN:
         case CMSG_CHAT_CHANNEL_UNMODERATOR:
-        case CMSG_CHAT_CHANNEL_UNMUTE:
         case CMSG_CHAT_CHANNEL_UNSILENCE_ALL:
             break;
         default:
diff --git a/src/server/game/Server/Packets/CharacterPackets.cpp b/src/server/game/Server/Packets/CharacterPackets.cpp
index 538a2c7e1d5..3973c55cf0e 100644
--- a/src/server/game/Server/Packets/CharacterPackets.cpp
+++ b/src/server/game/Server/Packets/CharacterPackets.cpp
@@ -140,6 +140,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Character::EnumCharacters
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Character::EnumCharactersResult::CharacterInfo const& charInfo)
 {
     data << charInfo.Guid;
+    data << uint64(charInfo.GuildClubMemberID);
     data << uint8(charInfo.ListPosition);
     data << uint8(charInfo.Race);
     data << uint8(charInfo.Class);
@@ -201,9 +202,9 @@ WorldPacket const* WorldPackets::Character::EnumCharactersResult::Write()
 
     _worldPacket.WriteBit(Success);
     _worldPacket.WriteBit(IsDeletedCharacters);
-    _worldPacket.WriteBit(IsDemonHunterCreationAllowed);
+    _worldPacket.WriteBit(IsTestDemonHunterCreationAllowed);
     _worldPacket.WriteBit(HasDemonHunterOnRealm);
-    _worldPacket.WriteBit(Unknown7x);
+    _worldPacket.WriteBit(IsDemonHunterCreationAllowed);
     _worldPacket.WriteBit(DisabledClassesMask.is_initialized());
     _worldPacket.WriteBit(IsAlliedRacesCreationAllowed);
     _worldPacket << uint32(Characters.size());
@@ -227,6 +228,7 @@ void WorldPackets::Character::CreateCharacter::Read()
     CreateInfo.reset(new CharacterCreateInfo());
     uint32 nameLength = _worldPacket.ReadBits(6);
     bool const hasTemplateSet = _worldPacket.ReadBit();
+    CreateInfo->IsTrialBoost = _worldPacket.ReadBit();
 
     _worldPacket >> CreateInfo->Race;
     _worldPacket >> CreateInfo->Class;
@@ -246,6 +248,7 @@ void WorldPackets::Character::CreateCharacter::Read()
 WorldPacket const* WorldPackets::Character::CreateChar::Write()
 {
     _worldPacket << uint8(Code);
+    _worldPacket << Guid;
     return &_worldPacket;
 }
 
diff --git a/src/server/game/Server/Packets/CharacterPackets.h b/src/server/game/Server/Packets/CharacterPackets.h
index 1f4ce11621a..fb5984efc8a 100644
--- a/src/server/game/Server/Packets/CharacterPackets.h
+++ b/src/server/game/Server/Packets/CharacterPackets.h
@@ -56,6 +56,7 @@ namespace WorldPackets
             std::array<uint8, PLAYER_CUSTOM_DISPLAY_SIZE> CustomDisplay = { };
             uint8 OutfitId        = 0;
             Optional<int32> TemplateSet;
+            bool IsTrialBoost     = false;
             std::string Name;
 
             /// Server side data
@@ -121,6 +122,7 @@ namespace WorldPackets
                 CharacterInfo(Field* fields);
 
                 ObjectGuid Guid;
+                uint64 GuildClubMemberID = 0; ///< same as bgs.protocol.club.v1.MemberId.unique_id, guessed basing on SMSG_QUERY_PLAYER_NAME_RESPONSE (that one is known)
                 std::string Name;
                 uint8 ListPosition       = 0; ///< Order of the characters in list
                 uint8 Race               = 0;
@@ -170,22 +172,22 @@ namespace WorldPackets
 
             struct RaceUnlock
             {
-                int32 RaceID;
-                bool HasExpansion;
-                bool HasAchievement;
-                bool HasHeritageArmor;
+                int32 RaceID          = 0;
+                bool HasExpansion     = false;
+                bool HasAchievement   = false;
+                bool HasHeritageArmor = false;
             };
 
             EnumCharactersResult() : ServerPacket(SMSG_ENUM_CHARACTERS_RESULT) { }
 
             WorldPacket const* Write() override;
 
-            bool Success                = false; ///<
-            bool IsDeletedCharacters    = false; ///< used for character undelete list
-            bool IsDemonHunterCreationAllowed = false; ///< used for demon hunter early access
-            bool HasDemonHunterOnRealm  = false;
-            bool Unknown7x              = false;
-            bool IsAlliedRacesCreationAllowed = false;
+            bool Success                          = false; ///<
+            bool IsDeletedCharacters              = false; ///< used for character undelete list
+            bool IsTestDemonHunterCreationAllowed = false; ///< allows client to skip 1 per realm and level 70 requirements
+            bool HasDemonHunterOnRealm            = false;
+            bool IsDemonHunterCreationAllowed     = false; ///< used for demon hunter early access
+            bool IsAlliedRacesCreationAllowed     = false;
 
             int32 MaxCharacterLevel     = 1;
             Optional<uint32> DisabledClassesMask;
@@ -225,6 +227,7 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             uint8 Code = 0; ///< Result code @see enum ResponseCodes
+            ObjectGuid Guid;
         };
 
         class CharDelete final : public ClientPacket
@@ -537,7 +540,7 @@ namespace WorldPackets
         class InitialSetup final : public ServerPacket
         {
         public:
-            InitialSetup() : ServerPacket(SMSG_INITIAL_SETUP, 1 + 1 + 4 + 4) { }
+            InitialSetup() : ServerPacket(SMSG_INITIAL_SETUP, 1 + 1) { }
 
             WorldPacket const* Write() override;
 
diff --git a/src/server/game/Server/Packets/ChatPackets.cpp b/src/server/game/Server/Packets/ChatPackets.cpp
index 26cbd48f7bf..044fe086f48 100644
--- a/src/server/game/Server/Packets/ChatPackets.cpp
+++ b/src/server/game/Server/Packets/ChatPackets.cpp
@@ -47,32 +47,30 @@ void WorldPackets::Chat::ChatMessageChannel::Read()
     Text = _worldPacket.ReadString(textLen);
 }
 
-void WorldPackets::Chat::ChatAddonMessage::Read()
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Chat::ChatAddonMessageParams& params)
 {
-    uint32 prefixLen = _worldPacket.ReadBits(5);
-    uint32 textLen = _worldPacket.ReadBits(9);
-    Prefix = _worldPacket.ReadString(prefixLen);
-    Text = _worldPacket.ReadString(textLen);
+    uint32 prefixLen = data.ReadBits(5);
+    uint32 textLen = data.ReadBits(8);
+    params.IsLogged = data.ReadBit();
+    params.Type = ChatMsg(data.read<int32>());
+    params.Prefix = data.ReadString(prefixLen);
+    params.Text = data.ReadString(textLen);
+
+    return data;
 }
 
-void WorldPackets::Chat::ChatAddonMessageWhisper::Read()
+void WorldPackets::Chat::ChatAddonMessage::Read()
 {
-    uint32 targetLen = _worldPacket.ReadBits(9);
-    uint32 prefixLen = _worldPacket.ReadBits(5);
-    uint32 textLen = _worldPacket.ReadBits(9);
-    Target = _worldPacket.ReadString(targetLen);
-    Prefix = _worldPacket.ReadString(prefixLen);
-    Text = _worldPacket.ReadString(textLen);
+    _worldPacket >> Params;
 }
 
-void WorldPackets::Chat::ChatAddonMessageChannel::Read()
+void WorldPackets::Chat::ChatAddonMessageTargeted::Read()
 {
     uint32 targetLen = _worldPacket.ReadBits(9);
-    uint32 prefixLen = _worldPacket.ReadBits(5);
-    uint32 textLen = _worldPacket.ReadBits(9);
+    _worldPacket.ResetBitPos();
+
+    _worldPacket >> Params;
     Target = _worldPacket.ReadString(targetLen);
-    Prefix = _worldPacket.ReadString(prefixLen);
-    Text = _worldPacket.ReadString(textLen);
 }
 
 void WorldPackets::Chat::ChatMessageDND::Read()
@@ -162,17 +160,17 @@ void WorldPackets::Chat::Chat::SetReceiver(WorldObject const* receiver, LocaleCo
 
 WorldPacket const* WorldPackets::Chat::Chat::Write()
 {
-    _worldPacket << SlashCmd;
-    _worldPacket << _Language;
+    _worldPacket << uint8(SlashCmd);
+    _worldPacket << uint32(_Language);
     _worldPacket << SenderGUID;
     _worldPacket << SenderGuildGUID;
     _worldPacket << SenderAccountGUID;
     _worldPacket << TargetGUID;
-    _worldPacket << TargetVirtualAddress;
-    _worldPacket << SenderVirtualAddress;
+    _worldPacket << uint32(TargetVirtualAddress);
+    _worldPacket << uint32(SenderVirtualAddress);
     _worldPacket << PartyGUID;
-    _worldPacket << AchievementID;
-    _worldPacket << DisplayTime;
+    _worldPacket << uint32(AchievementID);
+    _worldPacket << float(DisplayTime);
     _worldPacket.WriteBits(SenderName.length(), 11);
     _worldPacket.WriteBits(TargetName.length(), 11);
     _worldPacket.WriteBits(Prefix.length(), 5);
@@ -181,6 +179,7 @@ WorldPacket const* WorldPackets::Chat::Chat::Write()
     _worldPacket.WriteBits(_ChatFlags, 11);
     _worldPacket.WriteBit(HideChatLog);
     _worldPacket.WriteBit(FakeSenderName);
+    _worldPacket.WriteBit(Unused_801.is_initialized());
     _worldPacket.FlushBits();
 
     _worldPacket.WriteString(SenderName);
@@ -189,6 +188,9 @@ WorldPacket const* WorldPackets::Chat::Chat::Write()
     _worldPacket.WriteString(_Channel);
     _worldPacket.WriteString(ChatText);
 
+    if (Unused_801)
+        _worldPacket << uint32(*Unused_801);
+
     return &_worldPacket;
 }
 
diff --git a/src/server/game/Server/Packets/ChatPackets.h b/src/server/game/Server/Packets/ChatPackets.h
index 97654aa656e..cbb9da156b0 100644
--- a/src/server/game/Server/Packets/ChatPackets.h
+++ b/src/server/game/Server/Packets/ChatPackets.h
@@ -53,7 +53,7 @@ namespace WorldPackets
         class ChatMessageWhisper final : public ClientPacket
         {
         public:
-            ChatMessageWhisper(WorldPacket&& packet) : ClientPacket(std::move(packet)) { }
+            ChatMessageWhisper(WorldPacket&& packet) : ClientPacket(CMSG_CHAT_MESSAGE_WHISPER, std::move(packet)) { }
 
             void Read() override;
 
@@ -66,7 +66,7 @@ namespace WorldPackets
         class ChatMessageChannel final : public ClientPacket
         {
         public:
-            ChatMessageChannel(WorldPacket&& packet) : ClientPacket(std::move(packet)) { }
+            ChatMessageChannel(WorldPacket&& packet) : ClientPacket(CMSG_CHAT_MESSAGE_CHANNEL, std::move(packet)) { }
 
             void Read() override;
 
@@ -75,46 +75,35 @@ namespace WorldPackets
             std::string Target;
         };
 
-        // CMSG_CHAT_ADDON_MESSAGE_GUILD
-        // CMSG_CHAT_ADDON_MESSAGE_OFFICER
-        // CMSG_CHAT_ADDON_MESSAGE_PARTY
-        // CMSG_CHAT_ADDON_MESSAGE_RAID
-        // CMSG_CHAT_ADDON_MESSAGE_INSTANCE_CHAT
-        class ChatAddonMessage final : public ClientPacket
+        struct ChatAddonMessageParams
         {
-        public:
-            ChatAddonMessage(WorldPacket&& packet) : ClientPacket(std::move(packet)) { }
-
-            void Read() override;
-
             std::string Prefix;
             std::string Text;
+            ChatMsg Type = CHAT_MSG_PARTY;
+            bool IsLogged = false;
         };
 
-        // CMSG_CHAT_ADDON_MESSAGE_WHISPER
-        class ChatAddonMessageWhisper final : public ClientPacket
+        // CMSG_CHAT_ADDON_MESSAGE
+        class ChatAddonMessage final : public ClientPacket
         {
         public:
-            ChatAddonMessageWhisper(WorldPacket&& packet) : ClientPacket(CMSG_CHAT_ADDON_MESSAGE_WHISPER, std::move(packet)) { }
+            ChatAddonMessage(WorldPacket&& packet) : ClientPacket(CMSG_CHAT_ADDON_MESSAGE, std::move(packet)) { }
 
             void Read() override;
 
-            std::string Prefix;
-            std::string Target;
-            std::string Text;
+            ChatAddonMessageParams Params;
         };
 
         // CMSG_CHAT_ADDON_MESSAGE_CHANNEL
-        class ChatAddonMessageChannel final : public ClientPacket
+        class ChatAddonMessageTargeted final : public ClientPacket
         {
         public:
-            ChatAddonMessageChannel(WorldPacket&& packet) : ClientPacket(CMSG_CHAT_ADDON_MESSAGE_CHANNEL, std::move(packet)) { }
+            ChatAddonMessageTargeted(WorldPacket&& packet) : ClientPacket(CMSG_CHAT_ADDON_MESSAGE_TARGETED, std::move(packet)) { }
 
             void Read() override;
 
-            std::string Text;
             std::string Target;
-            std::string Prefix;
+            ChatAddonMessageParams Params;
         };
 
         class ChatMessageDND final : public ClientPacket
@@ -161,7 +150,7 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             uint8 SlashCmd = 0;     ///< @see enum ChatMsg
-            uint8 _Language = LANG_UNIVERSAL;
+            uint32 _Language = LANG_UNIVERSAL;
             ObjectGuid SenderGUID;
             ObjectGuid SenderGuildGUID;
             ObjectGuid SenderAccountGUID;
@@ -177,6 +166,7 @@ namespace WorldPackets
             uint32 AchievementID = 0;
             uint8 _ChatFlags = 0;   ///< @see enum ChatFlags
             float DisplayTime = 0.0f;
+            Optional<uint32> Unused_801;
             bool HideChatLog = false;
             bool FakeSenderName = false;
         };
diff --git a/src/server/game/Server/Packets/CombatLogPackets.cpp b/src/server/game/Server/Packets/CombatLogPackets.cpp
index 22196336960..243a7fd6e43 100644
--- a/src/server/game/Server/Packets/CombatLogPackets.cpp
+++ b/src/server/game/Server/Packets/CombatLogPackets.cpp
@@ -26,6 +26,7 @@ WorldPacket const* WorldPackets::CombatLog::SpellNonMeleeDamageLog::Write()
     *this << int32(SpellID);
     *this << int32(SpellXSpellVisualID);
     *this << int32(Damage);
+    *this << int32(OriginalDamage);
     *this << int32(Overkill);
     *this << uint8(SchoolMask);
     *this << int32(Absorbed);
@@ -35,11 +36,11 @@ WorldPacket const* WorldPackets::CombatLog::SpellNonMeleeDamageLog::Write()
     WriteBits(Flags, 7);
     WriteBit(false); // Debug info
     WriteLogDataBit();
-    WriteBit(SandboxScaling.is_initialized());
+    WriteBit(ContentTuning.is_initialized());
     FlushBits();
     WriteLogData();
-    if (SandboxScaling)
-        *this << *SandboxScaling;
+    if (ContentTuning)
+        *this << *ContentTuning;
 
     return &_worldPacket;
 }
@@ -61,12 +62,12 @@ WorldPacket const* WorldPackets::CombatLog::EnvironmentalDamageLog::Write()
 WorldPacket const* WorldPackets::CombatLog::SpellExecuteLog::Write()
 {
     *this << Caster;
-    *this << SpellID;
+    *this << int32(SpellID);
     *this << uint32(Effects.size());
 
     for (SpellLogEffect const& effect : Effects)
     {
-        *this << effect.Effect;
+        *this << int32(effect.Effect);
 
         *this << uint32(effect.PowerDrainTargets.size());
         *this << uint32(effect.ExtraAttacksTargets.size());
@@ -78,32 +79,32 @@ WorldPacket const* WorldPackets::CombatLog::SpellExecuteLog::Write()
         for (SpellLogEffectPowerDrainParams const& powerDrainTarget : effect.PowerDrainTargets)
         {
             *this << powerDrainTarget.Victim;
-            *this << powerDrainTarget.Points;
-            *this << powerDrainTarget.PowerType;
-            *this << powerDrainTarget.Amplitude;
+            *this << uint32(powerDrainTarget.Points);
+            *this << uint32(powerDrainTarget.PowerType);
+            *this << float(powerDrainTarget.Amplitude);
         }
 
         for (SpellLogEffectExtraAttacksParams const& extraAttacksTarget : effect.ExtraAttacksTargets)
         {
             *this << extraAttacksTarget.Victim;
-            *this << extraAttacksTarget.NumAttacks;
+            *this << uint32(extraAttacksTarget.NumAttacks);
         }
 
         for (SpellLogEffectDurabilityDamageParams const& durabilityDamageTarget : effect.DurabilityDamageTargets)
         {
             *this << durabilityDamageTarget.Victim;
-            *this << durabilityDamageTarget.ItemID;
-            *this << durabilityDamageTarget.Amount;
+            *this << int32(durabilityDamageTarget.ItemID);
+            *this << int32(durabilityDamageTarget.Amount);
         }
 
         for (SpellLogEffectGenericVictimParams const& genericVictimTarget : effect.GenericVictimTargets)
             *this << genericVictimTarget.Victim;
 
         for (SpellLogEffectTradeSkillItemParams const& tradeSkillTarget : effect.TradeSkillTargets)
-            *this << tradeSkillTarget.ItemID;
+            *this << int32(tradeSkillTarget.ItemID);
 
         for (SpellLogEffectFeedPetParams const& feedPetTarget : effect.FeedPetTargets)
-            *this << feedPetTarget.ItemID;
+            *this << int32(feedPetTarget.ItemID);
     }
 
     WriteLogDataBit();
@@ -119,13 +120,14 @@ WorldPacket const* WorldPackets::CombatLog::SpellHealLog::Write()
     *this << CasterGUID;
     *this << int32(SpellID);
     *this << int32(Health);
+    *this << int32(OriginalHeal);
     *this << int32(OverHeal);
     *this << int32(Absorbed);
     WriteBit(Crit);
     WriteBit(CritRollMade.is_initialized());
     WriteBit(CritRollNeeded.is_initialized());
     WriteLogDataBit();
-    WriteBit(SandboxScaling.is_initialized());
+    WriteBit(ContentTuning.is_initialized());
     FlushBits();
 
     WriteLogData();
@@ -136,8 +138,8 @@ WorldPacket const* WorldPackets::CombatLog::SpellHealLog::Write()
     if (CritRollNeeded)
         *this << *CritRollNeeded;
 
-    if (SandboxScaling)
-        *this << *SandboxScaling;
+    if (ContentTuning)
+        *this << *ContentTuning;
 
     return &_worldPacket;
 }
@@ -155,24 +157,24 @@ WorldPacket const* WorldPackets::CombatLog::SpellPeriodicAuraLog::Write()
     {
         *this << int32(effect.Effect);
         *this << int32(effect.Amount);
+        *this << int32(effect.OriginalDamage);
         *this << int32(effect.OverHealOrKill);
         *this << int32(effect.SchoolMaskOrPower);
         *this << int32(effect.AbsorbedOrAmplitude);
         *this << int32(effect.Resisted);
         WriteBit(effect.Crit);
         WriteBit(effect.DebugInfo.is_initialized());
-        WriteBit(effect.SandboxScaling.is_initialized());
+        WriteBit(effect.ContentTuning.is_initialized());
         FlushBits();
 
-        if (effect.SandboxScaling)
-            *this << *effect.SandboxScaling;
+        if (effect.ContentTuning)
+            *this << *effect.ContentTuning;
 
         if (effect.DebugInfo)
         {
             *this << float(effect.DebugInfo->CritRollMade);
             *this << float(effect.DebugInfo->CritRollNeeded);
         }
-
     }
 
     WriteLogData();
@@ -280,6 +282,7 @@ WorldPacket const* WorldPackets::CombatLog::SpellDamageShield::Write()
     *this << Defender;
     *this << int32(SpellID);
     *this << int32(TotalDamage);
+    *this << int32(OriginalDamage);
     *this << int32(OverKill);
     *this << int32(SchoolMask);
     *this << int32(LogAbsorbed);
@@ -297,6 +300,7 @@ WorldPacket const* WorldPackets::CombatLog::AttackerStateUpdate::Write()
     attackRoundInfo << AttackerGUID;
     attackRoundInfo << VictimGUID;
     attackRoundInfo << int32(Damage);
+    attackRoundInfo << int32(OriginalDamage);
     attackRoundInfo << int32(OverDamage);
     attackRoundInfo << uint8(SubDmg.is_initialized());
     if (SubDmg)
@@ -338,15 +342,16 @@ WorldPacket const* WorldPackets::CombatLog::AttackerStateUpdate::Write()
     if (HitInfo & (HITINFO_BLOCK | HITINFO_UNK12))
         attackRoundInfo << float(Unk);
 
-    attackRoundInfo << uint8(SandboxScaling.Type);
-    attackRoundInfo << uint8(SandboxScaling.TargetLevel);
-    attackRoundInfo << uint8(SandboxScaling.Expansion);
-    attackRoundInfo << uint8(SandboxScaling.Class);
-    attackRoundInfo << uint8(SandboxScaling.TargetMinScalingLevel);
-    attackRoundInfo << uint8(SandboxScaling.TargetMaxScalingLevel);
-    attackRoundInfo << int16(SandboxScaling.PlayerLevelDelta);
-    attackRoundInfo << int8(SandboxScaling.TargetScalingLevelDelta);
-    attackRoundInfo << uint16(SandboxScaling.PlayerItemLevel);
+    attackRoundInfo << uint8(ContentTuning.Type);
+    attackRoundInfo << uint8(ContentTuning.TargetLevel);
+    attackRoundInfo << uint8(ContentTuning.Expansion);
+    attackRoundInfo << uint8(ContentTuning.TargetMinScalingLevel);
+    attackRoundInfo << uint8(ContentTuning.TargetMaxScalingLevel);
+    attackRoundInfo << int16(ContentTuning.PlayerLevelDelta);
+    attackRoundInfo << int8(ContentTuning.TargetScalingLevelDelta);
+    attackRoundInfo << uint16(ContentTuning.PlayerItemLevel);
+    attackRoundInfo << uint16(ContentTuning.ScalingHealthItemLevelCurveID);
+    attackRoundInfo << uint8(ContentTuning.ScalesWithItemLevel ? 1 : 0);
 
     WriteLogDataBit();
     FlushBits();
diff --git a/src/server/game/Server/Packets/CombatLogPackets.h b/src/server/game/Server/Packets/CombatLogPackets.h
index 88a427ac962..4f3d1361796 100644
--- a/src/server/game/Server/Packets/CombatLogPackets.h
+++ b/src/server/game/Server/Packets/CombatLogPackets.h
@@ -39,6 +39,7 @@ namespace WorldPackets
             int32 SpellID = 0;
             int32 SpellXSpellVisualID = 0;
             int32 Damage = 0;
+            int32 OriginalDamage = 0;
             int32 Overkill = -1;
             uint8 SchoolMask = 0;
             int32 ShieldBlock = 0;
@@ -47,7 +48,7 @@ namespace WorldPackets
             int32 Absorbed = 0;
             int32 Flags = 0;
             // Optional<SpellNonMeleeDamageLogDebugInfo> DebugInfo;
-            Optional<Spells::SandboxScalingData> SandboxScaling;
+            Optional<Spells::ContentTuningParams> ContentTuning;
         };
 
         class EnvironmentalDamageLog final : public CombatLogServerPacket
@@ -99,12 +100,13 @@ namespace WorldPackets
             ObjectGuid TargetGUID;
             int32 SpellID       = 0;
             int32 Health        = 0;
+            int32 OriginalHeal  = 0;
             int32 OverHeal      = 0;
             int32 Absorbed      = 0;
             bool Crit           = false;
             Optional<float> CritRollMade;
             Optional<float> CritRollNeeded;
-            Optional<Spells::SandboxScalingData> SandboxScaling;
+            Optional<Spells::ContentTuningParams> ContentTuning;
         };
 
         class SpellPeriodicAuraLog final : public CombatLogServerPacket
@@ -120,13 +122,14 @@ namespace WorldPackets
             {
                 int32 Effect              = 0;
                 int32 Amount              = 0;
+                int32 OriginalDamage      = 0;
                 int32 OverHealOrKill      = 0;
                 int32 SchoolMaskOrPower   = 0;
                 int32 AbsorbedOrAmplitude = 0;
                 int32 Resisted            = 0;
                 bool Crit                 = false;
                 Optional<PeriodicalAuraLogEffectDebugInfo> DebugInfo;
-                Optional<Spells::SandboxScalingData> SandboxScaling;
+                Optional<Spells::ContentTuningParams> ContentTuning;
             };
 
             SpellPeriodicAuraLog() : CombatLogServerPacket(SMSG_SPELL_PERIODIC_AURA_LOG, 16 + 16 + 4 + 4 + 1) { }
@@ -267,6 +270,7 @@ namespace WorldPackets
             ObjectGuid Defender;
             int32 SpellID = 0;
             int32 TotalDamage = 0;
+            int32 OriginalDamage = 0;
             int32 OverKill = 0;
             int32 SchoolMask = 0;
             int32 LogAbsorbed = 0;
@@ -308,6 +312,7 @@ namespace WorldPackets
             ObjectGuid AttackerGUID;
             ObjectGuid VictimGUID;
             int32 Damage = 0;
+            int32 OriginalDamage = 0;
             int32 OverDamage = -1; // (damage - health) or -1 if unit is still alive
             Optional<SubDamage> SubDmg;
             uint8 VictimState = 0;
@@ -317,7 +322,7 @@ namespace WorldPackets
             int32 RageGained = 0;
             UnkAttackerState UnkState;
             float Unk = 0.0f;
-            Spells::SandboxScalingData SandboxScaling;
+            Spells::ContentTuningParams ContentTuning;
         };
     }
 }
diff --git a/src/server/game/Server/Packets/CombatLogPacketsCommon.cpp b/src/server/game/Server/Packets/CombatLogPacketsCommon.cpp
index e2f18ace45e..b1e22a3746f 100644
--- a/src/server/game/Server/Packets/CombatLogPacketsCommon.cpp
+++ b/src/server/game/Server/Packets/CombatLogPacketsCommon.cpp
@@ -27,6 +27,7 @@ void WorldPackets::Spells::SpellCastLogData::Initialize(Unit const* unit)
     Health = unit->GetHealth();
     AttackPower = unit->GetTotalAttackPowerValue(unit->getClass() == CLASS_HUNTER ? RANGED_ATTACK : BASE_ATTACK);
     SpellPower = unit->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_SPELL);
+    Armor = unit->GetArmor();
     PowerData.emplace_back(int32(unit->GetPowerType()), unit->GetPower(unit->GetPowerType()), int32(0));
 }
 
@@ -35,6 +36,7 @@ void WorldPackets::Spells::SpellCastLogData::Initialize(Spell const* spell)
     Health = spell->GetCaster()->GetHealth();
     AttackPower = spell->GetCaster()->GetTotalAttackPowerValue(spell->GetCaster()->getClass() == CLASS_HUNTER ? RANGED_ATTACK : BASE_ATTACK);
     SpellPower = spell->GetCaster()->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_SPELL);
+    Armor = spell->GetCaster()->GetArmor();
     Powers primaryPowerType = spell->GetCaster()->GetPowerType();
     bool primaryPowerAdded = false;
     for (SpellPowerCost const& cost : spell->GetPowerCost())
@@ -53,22 +55,22 @@ namespace WorldPackets
     namespace Spells
     {
         template<class T, class U>
-        bool SandboxScalingData::GenerateDataForUnits(T* /*attacker*/, U* /*target*/)
+        bool ContentTuningParams::GenerateDataForUnits(T* /*attacker*/, U* /*target*/)
         {
             return false;
         }
 
         template<>
-        bool SandboxScalingData::GenerateDataForUnits<Creature, Player>(Creature* attacker, Player* target)
+        bool ContentTuningParams::GenerateDataForUnits<Creature, Player>(Creature* attacker, Player* target)
         {
             CreatureTemplate const* creatureTemplate = attacker->GetCreatureTemplate();
 
             Type = TYPE_CREATURE_TO_PLAYER_DAMAGE;
-            PlayerLevelDelta = target->GetInt32Value(PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
+            PlayerLevelDelta = target->GetInt32Value(ACTIVE_PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
             PlayerItemLevel = target->GetAverageItemLevel();
+            ScalingHealthItemLevelCurveID = target->GetUInt32Value(UNIT_FIELD_SCALING_HEALTH_ITEM_LEVEL_CURVE_ID);
             TargetLevel = target->getLevel();
             Expansion = creatureTemplate->RequiredExpansion;
-            Class = creatureTemplate->unit_class;
             TargetMinScalingLevel = uint8(creatureTemplate->levelScaling->MinLevel);
             TargetMaxScalingLevel = uint8(creatureTemplate->levelScaling->MaxLevel);
             TargetScalingLevelDelta = int8(attacker->GetInt32Value(UNIT_FIELD_SCALING_LEVEL_DELTA));
@@ -76,16 +78,16 @@ namespace WorldPackets
         }
 
         template<>
-        bool SandboxScalingData::GenerateDataForUnits<Player, Creature>(Player* attacker, Creature* target)
+        bool ContentTuningParams::GenerateDataForUnits<Player, Creature>(Player* attacker, Creature* target)
         {
             CreatureTemplate const* creatureTemplate = target->GetCreatureTemplate();
 
             Type = TYPE_PLAYER_TO_CREATURE_DAMAGE;
-            PlayerLevelDelta = attacker->GetInt32Value(PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
+            PlayerLevelDelta = attacker->GetInt32Value(ACTIVE_PLAYER_FIELD_SCALING_PLAYER_LEVEL_DELTA);
             PlayerItemLevel = attacker->GetAverageItemLevel();
+            ScalingHealthItemLevelCurveID = target->GetUInt32Value(UNIT_FIELD_SCALING_HEALTH_ITEM_LEVEL_CURVE_ID);
             TargetLevel = target->getLevel();
             Expansion = creatureTemplate->RequiredExpansion;
-            Class = creatureTemplate->unit_class;
             TargetMinScalingLevel = uint8(creatureTemplate->levelScaling->MinLevel);
             TargetMaxScalingLevel = uint8(creatureTemplate->levelScaling->MaxLevel);
             TargetScalingLevelDelta = int8(target->GetInt32Value(UNIT_FIELD_SCALING_LEVEL_DELTA));
@@ -93,7 +95,7 @@ namespace WorldPackets
         }
 
         template<>
-        bool SandboxScalingData::GenerateDataForUnits<Creature, Creature>(Creature* attacker, Creature* target)
+        bool ContentTuningParams::GenerateDataForUnits<Creature, Creature>(Creature* attacker, Creature* target)
         {
             Creature* accessor = target->HasScalableLevels() ? target : attacker;
             CreatureTemplate const* creatureTemplate = accessor->GetCreatureTemplate();
@@ -103,7 +105,6 @@ namespace WorldPackets
             PlayerItemLevel = 0;
             TargetLevel = target->getLevel();
             Expansion = creatureTemplate->RequiredExpansion;
-            Class = creatureTemplate->unit_class;
             TargetMinScalingLevel = uint8(creatureTemplate->levelScaling->MinLevel);
             TargetMaxScalingLevel = uint8(creatureTemplate->levelScaling->MaxLevel);
             TargetScalingLevelDelta = int8(accessor->GetInt32Value(UNIT_FIELD_SCALING_LEVEL_DELTA));
@@ -111,7 +112,7 @@ namespace WorldPackets
         }
 
         template<>
-        bool SandboxScalingData::GenerateDataForUnits<Unit, Unit>(Unit* attacker, Unit* target)
+        bool ContentTuningParams::GenerateDataForUnits<Unit, Unit>(Unit* attacker, Unit* target)
         {
             if (Player* playerAttacker = attacker->ToPlayer())
             {
@@ -152,6 +153,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData
     data << int64(spellCastLogData.Health);
     data << int32(spellCastLogData.AttackPower);
     data << int32(spellCastLogData.SpellPower);
+    data << int32(spellCastLogData.Armor);
     data.WriteBits(spellCastLogData.PowerData.size(), 9);
     data.FlushBits();
 
@@ -165,16 +167,18 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData
     return data;
 }
 
-ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SandboxScalingData const& sandboxScalingData)
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::ContentTuningParams const& contentTuningParams)
 {
-    data.WriteBits(sandboxScalingData.Type, 4);
-    data << int16(sandboxScalingData.PlayerLevelDelta);
-    data << uint16(sandboxScalingData.PlayerItemLevel);
-    data << uint8(sandboxScalingData.TargetLevel);
-    data << uint8(sandboxScalingData.Expansion);
-    data << uint8(sandboxScalingData.Class);
-    data << uint8(sandboxScalingData.TargetMinScalingLevel);
-    data << uint8(sandboxScalingData.TargetMaxScalingLevel);
-    data << int8(sandboxScalingData.TargetScalingLevelDelta);
+    data << int16(contentTuningParams.PlayerLevelDelta);
+    data << uint16(contentTuningParams.PlayerItemLevel);
+    data << uint16(contentTuningParams.ScalingHealthItemLevelCurveID);
+    data << uint8(contentTuningParams.TargetLevel);
+    data << uint8(contentTuningParams.Expansion);
+    data << uint8(contentTuningParams.TargetMinScalingLevel);
+    data << uint8(contentTuningParams.TargetMaxScalingLevel);
+    data << int8(contentTuningParams.TargetScalingLevelDelta);
+    data.WriteBits(contentTuningParams.Type, 4);
+    data.WriteBit(contentTuningParams.ScalesWithItemLevel);
+    data.FlushBits();
     return data;
 }
diff --git a/src/server/game/Server/Packets/CombatLogPacketsCommon.h b/src/server/game/Server/Packets/CombatLogPacketsCommon.h
index 172f94e7031..b30c5fefe34 100644
--- a/src/server/game/Server/Packets/CombatLogPacketsCommon.h
+++ b/src/server/game/Server/Packets/CombatLogPacketsCommon.h
@@ -41,31 +41,34 @@ namespace WorldPackets
             int64 Health = 0;
             int32 AttackPower = 0;
             int32 SpellPower = 0;
+            int32 Armor = 0;
             std::vector<SpellLogPowerData> PowerData;
 
             void Initialize(Unit const* unit);
             void Initialize(Spell const* spell);
         };
 
-        struct SandboxScalingData
+        struct ContentTuningParams
         {
-            enum SandboxScalingDataType : uint32
+            enum ContentTuningType : uint32
             {
-                TYPE_PLAYER_TO_PLAYER               = 1, // NYI
-                TYPE_CREATURE_TO_PLAYER_DAMAGE      = 2,
-                TYPE_PLAYER_TO_CREATURE_DAMAGE      = 3,
+                TYPE_PLAYER_TO_PLAYER               = 7, // NYI
+                TYPE_PLAYER_TO_PLAYER_HEALING       = 8,
+                TYPE_CREATURE_TO_PLAYER_DAMAGE      = 1,
+                TYPE_PLAYER_TO_CREATURE_DAMAGE      = 2,
                 TYPE_CREATURE_TO_CREATURE_DAMAGE    = 4
             };
 
             uint32 Type = 0;
             int16 PlayerLevelDelta = 0;
             uint16 PlayerItemLevel = 0;
+            uint16 ScalingHealthItemLevelCurveID = 0;
             uint8 TargetLevel = 0;
             uint8 Expansion = 0;
-            uint8 Class = 0;
             uint8 TargetMinScalingLevel = 0;
             uint8 TargetMaxScalingLevel = 0;
             int8 TargetScalingLevelDelta = 0;
+            bool ScalesWithItemLevel = false;
 
             template<class T, class U>
             bool GenerateDataForUnits(T* attacker, U* target);
@@ -126,6 +129,6 @@ namespace WorldPackets
 }
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastLogData const& spellCastLogData);
-ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SandboxScalingData const& sandboxScalingData);
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::ContentTuningParams const& contentTuningParams);
 
 #endif // CombatLogPacketsCommon_h__
diff --git a/src/server/game/Server/Packets/CombatPackets.cpp b/src/server/game/Server/Packets/CombatPackets.cpp
index 5048595314c..63fc4ac1ed1 100644
--- a/src/server/game/Server/Packets/CombatPackets.cpp
+++ b/src/server/game/Server/Packets/CombatPackets.cpp
@@ -96,7 +96,7 @@ WorldPacket const* WorldPackets::Combat::AIReaction::Write()
 
 WorldPacket const* WorldPackets::Combat::AttackSwingError::Write()
 {
-    _worldPacket.WriteBits(Reason, 2);
+    _worldPacket.WriteBits(Reason, 3);
     _worldPacket.FlushBits();
     return &_worldPacket;
 }
@@ -107,8 +107,8 @@ WorldPacket const* WorldPackets::Combat::PowerUpdate::Write()
     _worldPacket << uint32(Powers.size());
     for (PowerUpdatePower const& power : Powers)
     {
-        _worldPacket << power.Power;
-        _worldPacket << power.PowerType;
+        _worldPacket << int32(power.Power);
+        _worldPacket << uint8(power.PowerType);
     }
 
     return &_worldPacket;
diff --git a/src/server/game/Server/Packets/CombatPackets.h b/src/server/game/Server/Packets/CombatPackets.h
index 446d9f5453b..313d573eae1 100644
--- a/src/server/game/Server/Packets/CombatPackets.h
+++ b/src/server/game/Server/Packets/CombatPackets.h
@@ -41,9 +41,9 @@ namespace WorldPackets
         public:
             enum AttackSwingErr : uint8
             {
-                CantAttack = 0,
+                NotInRange = 0,
                 BadFacing = 1,
-                NotInRange = 2,
+                CantAttack = 2,
                 DeadTarget = 3
             };
 
diff --git a/src/server/game/Server/Packets/DuelPackets.cpp b/src/server/game/Server/Packets/DuelPackets.cpp
index f76ccecaa89..ccee13b731a 100644
--- a/src/server/game/Server/Packets/DuelPackets.cpp
+++ b/src/server/game/Server/Packets/DuelPackets.cpp
@@ -59,6 +59,7 @@ void WorldPackets::Duel::DuelResponse::Read()
 {
     _worldPacket >> ArbiterGUID;
     Accepted = _worldPacket.ReadBit();
+    Forfeited = _worldPacket.ReadBit();
 }
 
 WorldPacket const* WorldPackets::Duel::DuelWinner::Write()
diff --git a/src/server/game/Server/Packets/DuelPackets.h b/src/server/game/Server/Packets/DuelPackets.h
index b45a8b42ba7..efa2701741a 100644
--- a/src/server/game/Server/Packets/DuelPackets.h
+++ b/src/server/game/Server/Packets/DuelPackets.h
@@ -103,6 +103,7 @@ namespace WorldPackets
 
             ObjectGuid ArbiterGUID;
             bool Accepted = false;
+            bool Forfeited = false;
         };
 
         class DuelWinner final : public ServerPacket
diff --git a/src/server/game/Server/Packets/EquipmentSetPackets.h b/src/server/game/Server/Packets/EquipmentSetPackets.h
index 1dd7040ec32..5c17fdc3cae 100644
--- a/src/server/game/Server/Packets/EquipmentSetPackets.h
+++ b/src/server/game/Server/Packets/EquipmentSetPackets.h
@@ -28,7 +28,7 @@ namespace WorldPackets
         class EquipmentSetID final : public ServerPacket
         {
         public:
-            EquipmentSetID() : ServerPacket(SMSG_EQUIPMENT_SET_ID, 8 + 4) { }
+            EquipmentSetID() : ServerPacket(SMSG_EQUIPMENT_SET_ID, 8 + 4 + 4) { }
 
             WorldPacket const* Write() override;
 
@@ -89,7 +89,7 @@ namespace WorldPackets
         class UseEquipmentSetResult final : public ServerPacket
         {
         public:
-            UseEquipmentSetResult() : ServerPacket(SMSG_USE_EQUIPMENT_SET_RESULT, 1) { }
+            UseEquipmentSetResult() : ServerPacket(SMSG_USE_EQUIPMENT_SET_RESULT, 8 + 1) { }
 
             WorldPacket const* Write() override;
 
diff --git a/src/server/game/Server/Packets/GarrisonPackets.h b/src/server/game/Server/Packets/GarrisonPackets.h
index a7bd016909c..bf83f006b1e 100644
--- a/src/server/game/Server/Packets/GarrisonPackets.h
+++ b/src/server/game/Server/Packets/GarrisonPackets.h
@@ -249,7 +249,7 @@ namespace WorldPackets
         class GarrisonLearnBlueprintResult final : public ServerPacket
         {
         public:
-            GarrisonLearnBlueprintResult() : ServerPacket(SMSG_GARRISON_LEARN_BLUEPRINT_RESULT, 4 + 4) { }
+            GarrisonLearnBlueprintResult() : ServerPacket(SMSG_GARRISON_LEARN_BLUEPRINT_RESULT, 4 + 4 + 4) { }
 
             WorldPacket const* Write() override;
 
diff --git a/src/server/game/Server/Packets/GuildFinderPackets.cpp b/src/server/game/Server/Packets/GuildFinderPackets.cpp
index ac8bcfea9df..2ce269fbdcb 100644
--- a/src/server/game/Server/Packets/GuildFinderPackets.cpp
+++ b/src/server/game/Server/Packets/GuildFinderPackets.cpp
@@ -108,7 +108,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::GuildFinder::GuildPostDat
     data << int32(post.Availability);
     data << int32(post.ClassRoles);
     data << int32(post.LevelRange);
-    data << uint32(post.SecondsRemaining);
+    data << int32(post.SecondsRemaining);
     data.WriteString(post.Comment);
     return data;
 }
diff --git a/src/server/game/Server/Packets/GuildFinderPackets.h b/src/server/game/Server/Packets/GuildFinderPackets.h
index 1fe3183156a..94084934fc1 100644
--- a/src/server/game/Server/Packets/GuildFinderPackets.h
+++ b/src/server/game/Server/Packets/GuildFinderPackets.h
@@ -157,7 +157,7 @@ namespace WorldPackets
             int32 Availability = 0;
             int32 ClassRoles = 0;
             int32 LevelRange = 0;
-            time_t SecondsRemaining = time_t(0);
+            int32 SecondsRemaining = 0;
             std::string Comment;
         };
 
diff --git a/src/server/game/Server/Packets/GuildPackets.cpp b/src/server/game/Server/Packets/GuildPackets.cpp
index 777891b3cef..2a3739f2470 100644
--- a/src/server/game/Server/Packets/GuildPackets.cpp
+++ b/src/server/game/Server/Packets/GuildPackets.cpp
@@ -63,9 +63,9 @@ WorldPacket const* WorldPackets::Guild::QueryGuildInfoResponse::Write()
 
 WorldPacket const* WorldPackets::Guild::GuildRoster::Write()
 {
-    _worldPacket << NumAccounts;
+    _worldPacket << int32(NumAccounts);
     _worldPacket.AppendPackedTime(CreateDate);
-    _worldPacket << GuildFlags;
+    _worldPacket << int32(GuildFlags);
     _worldPacket << uint32(MemberData.size());
     _worldPacket.WriteBits(WelcomeText.length(), 10);
     _worldPacket.WriteBits(InfoText.length(), 11);
@@ -98,8 +98,8 @@ void WorldPackets::Guild::GuildUpdateMotdText::Read()
 
 WorldPacket const* WorldPackets::Guild::GuildCommandResult::Write()
 {
-    _worldPacket << Result;
-    _worldPacket << Command;
+    _worldPacket << int32(Result);
+    _worldPacket << int32(Command);
 
     _worldPacket.WriteBits(Name.length(), 8);
     _worldPacket.FlushBits();
@@ -127,17 +127,17 @@ WorldPacket const* WorldPackets::Guild::GuildInvite::Write()
     _worldPacket.WriteBits(OldGuildName.length(), 7);
     _worldPacket.FlushBits();
 
-    _worldPacket << InviterVirtualRealmAddress;
-    _worldPacket << GuildVirtualRealmAddress;
+    _worldPacket << uint32(InviterVirtualRealmAddress);
+    _worldPacket << uint32(GuildVirtualRealmAddress);
     _worldPacket << GuildGUID;
-    _worldPacket << OldGuildVirtualRealmAddress;
+    _worldPacket << uint32(OldGuildVirtualRealmAddress);
     _worldPacket << OldGuildGUID;
-    _worldPacket << EmblemStyle;
-    _worldPacket << EmblemColor;
-    _worldPacket << BorderStyle;
-    _worldPacket << BorderColor;
-    _worldPacket << Background;
-    _worldPacket << AchievementPoints;
+    _worldPacket << uint32(EmblemStyle);
+    _worldPacket << uint32(EmblemColor);
+    _worldPacket << uint32(BorderStyle);
+    _worldPacket << uint32(BorderColor);
+    _worldPacket << uint32(Background);
+    _worldPacket << int32(AchievementPoints);
 
     _worldPacket.WriteString(InviterName);
     _worldPacket.WriteString(GuildName);
@@ -148,9 +148,9 @@ WorldPacket const* WorldPackets::Guild::GuildInvite::Write()
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterProfessionData const& rosterProfessionData)
 {
-    data << rosterProfessionData.DbID;
-    data << rosterProfessionData.Rank;
-    data << rosterProfessionData.Step;
+    data << int32(rosterProfessionData.DbID);
+    data << int32(rosterProfessionData.Rank);
+    data << int32(rosterProfessionData.Step);
 
     return data;
 }
@@ -158,20 +158,20 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterProfess
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterMemberData const& rosterMemberData)
 {
     data << rosterMemberData.Guid;
-    data << rosterMemberData.RankID;
-    data << rosterMemberData.AreaID;
-    data << rosterMemberData.PersonalAchievementPoints;
-    data << rosterMemberData.GuildReputation;
-    data << rosterMemberData.LastSave;
+    data << int32(rosterMemberData.RankID);
+    data << int32(rosterMemberData.AreaID);
+    data << int32(rosterMemberData.PersonalAchievementPoints);
+    data << int32(rosterMemberData.GuildReputation);
+    data << float(rosterMemberData.LastSave);
 
     for (uint8 i = 0; i < 2; i++)
         data << rosterMemberData.Profession[i];
 
-    data << rosterMemberData.VirtualRealmAddress;
-    data << rosterMemberData.Status;
-    data << rosterMemberData.Level;
-    data << rosterMemberData.ClassID;
-    data << rosterMemberData.Gender;
+    data << uint32(rosterMemberData.VirtualRealmAddress);
+    data << uint8(rosterMemberData.Status);
+    data << uint8(rosterMemberData.Level);
+    data << uint8(rosterMemberData.ClassID);
+    data << uint8(rosterMemberData.Gender);
 
     data.WriteBits(rosterMemberData.Name.length(), 6);
     data.WriteBits(rosterMemberData.Note.length(), 8);
@@ -190,7 +190,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRosterMemberD
 WorldPacket const* WorldPackets::Guild::GuildEventPresenceChange::Write()
 {
     _worldPacket << Guid;
-    _worldPacket << VirtualRealmAddress;
+    _worldPacket << uint32(VirtualRealmAddress);
 
     _worldPacket.WriteBits(Name.length(), 6);
     _worldPacket.WriteBit(LoggedOn);
@@ -215,7 +215,7 @@ WorldPacket const* WorldPackets::Guild::GuildEventMotd::Write()
 WorldPacket const* WorldPackets::Guild::GuildEventPlayerJoined::Write()
 {
     _worldPacket << Guid;
-    _worldPacket << VirtualRealmAddress;
+    _worldPacket << uint32(VirtualRealmAddress);
 
     _worldPacket.WriteBits(Name.length(), 6);
     _worldPacket.FlushBits();
@@ -249,9 +249,9 @@ WorldPacket const* WorldPackets::Guild::GuildEventLogQueryResults::Write()
     {
         _worldPacket << entry.PlayerGUID;
         _worldPacket << entry.OtherGUID;
-        _worldPacket << entry.TransactionType;
-        _worldPacket << entry.RankID;
-        _worldPacket << entry.TransactionDate;
+        _worldPacket << uint8(entry.TransactionType);
+        _worldPacket << uint8(entry.RankID);
+        _worldPacket << uint32(entry.TransactionDate);
     }
 
     return &_worldPacket;
@@ -269,12 +269,12 @@ WorldPacket const* WorldPackets::Guild::GuildEventPlayerLeft::Write()
         _worldPacket.FlushBits();
 
         _worldPacket << RemoverGUID;
-        _worldPacket << RemoverVirtualRealmAddress;
+        _worldPacket << uint32(RemoverVirtualRealmAddress);
         _worldPacket.WriteString(RemoverName);
     }
 
     _worldPacket << LeaverGUID;
-    _worldPacket << LeaverVirtualRealmAddress;
+    _worldPacket << uint32(LeaverVirtualRealmAddress);
     _worldPacket.WriteString(LeaverName);
 
     return &_worldPacket;
@@ -282,16 +282,16 @@ WorldPacket const* WorldPackets::Guild::GuildEventPlayerLeft::Write()
 
 WorldPacket const* WorldPackets::Guild::GuildPermissionsQueryResults::Write()
 {
-    _worldPacket << RankID;
-    _worldPacket << WithdrawGoldLimit;
-    _worldPacket << Flags;
-    _worldPacket << NumTabs;
+    _worldPacket << uint32(RankID);
+    _worldPacket << int32(WithdrawGoldLimit);
+    _worldPacket << int32(Flags);
+    _worldPacket << int32(NumTabs);
     _worldPacket << uint32(Tab.size());
 
     for (GuildRankTabPermissions const& tab : Tab)
     {
-        _worldPacket << tab.Flags;
-        _worldPacket << tab.WithdrawItemLimit;
+        _worldPacket << int32(tab.Flags);
+        _worldPacket << int32(tab.WithdrawItemLimit);
     }
 
     return &_worldPacket;
@@ -325,9 +325,9 @@ WorldPacket const* WorldPackets::Guild::GuildEventNewLeader::Write()
     _worldPacket.FlushBits();
 
     _worldPacket << OldLeaderGUID;
-    _worldPacket << OldLeaderVirtualRealmAddress;
+    _worldPacket << uint32(OldLeaderVirtualRealmAddress);
     _worldPacket << NewLeaderGUID;
-    _worldPacket << NewLeaderVirtualRealmAddress;
+    _worldPacket << uint32(NewLeaderVirtualRealmAddress);
 
     _worldPacket.WriteString(OldLeaderName);
     _worldPacket.WriteString(NewLeaderName);
@@ -337,7 +337,7 @@ WorldPacket const* WorldPackets::Guild::GuildEventNewLeader::Write()
 
 WorldPacket const* WorldPackets::Guild::GuildEventTabModified::Write()
 {
-    _worldPacket << Tab;
+    _worldPacket << int32(Tab);
 
     _worldPacket.WriteBits(Name.length(), 7);
     _worldPacket.WriteBits(Icon.length(), 9);
@@ -358,15 +358,15 @@ WorldPacket const* WorldPackets::Guild::GuildEventTabTextChanged::Write()
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRankData const& rankData)
 {
-    data << rankData.RankID;
-    data << rankData.RankOrder;
-    data << rankData.Flags;
-    data << rankData.WithdrawGoldLimit;
+    data << uint32(rankData.RankID);
+    data << uint32(rankData.RankOrder);
+    data << uint32(rankData.Flags);
+    data << uint32(rankData.WithdrawGoldLimit);
 
     for (uint8 i = 0; i < GUILD_BANK_MAX_TABS; i++)
     {
-        data << rankData.TabFlags[i];
-        data << rankData.TabWithdrawItemLimit[i];
+        data << uint32(rankData.TabFlags[i]);
+        data << uint32(rankData.TabWithdrawItemLimit[i]);
     }
 
     data.WriteBits(rankData.RankName.length(), 7);
@@ -416,7 +416,7 @@ WorldPacket const* WorldPackets::Guild::GuildSendRankChange::Write()
 {
     _worldPacket << Officer;
     _worldPacket << Other;
-    _worldPacket << RankID;
+    _worldPacket << uint32(RankID);
 
     _worldPacket.WriteBit(Promote);
     _worldPacket.FlushBits();
@@ -499,25 +499,25 @@ WorldPacket const* WorldPackets::Guild::GuildPartyState::Write()
     _worldPacket.WriteBit(InGuildParty);
     _worldPacket.FlushBits();
 
-    _worldPacket << NumMembers;
-    _worldPacket << NumRequired;
-    _worldPacket << GuildXPEarnedMult;
+    _worldPacket << int32(NumMembers);
+    _worldPacket << int32(NumRequired);
+    _worldPacket << float(GuildXPEarnedMult);
 
     return &_worldPacket;
 }
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildRewardItem const& rewardItem)
 {
-    data << rewardItem.ItemID;
-    data << rewardItem.Unk4;
+    data << uint32(rewardItem.ItemID);
+    data << uint32(rewardItem.Unk4);
     data << uint32(rewardItem.AchievementsRequired.size());
     data << uint64(rewardItem.RaceMask);
-    data << rewardItem.MinGuildLevel;
-    data << rewardItem.MinGuildRep;
-    data << rewardItem.Cost;
+    data << int32(rewardItem.MinGuildLevel);
+    data << int32(rewardItem.MinGuildRep);
+    data << uint64(rewardItem.Cost);
 
-    for (uint8 i = 0; i < rewardItem.AchievementsRequired.size(); i++)
-        data << rewardItem.AchievementsRequired[i];
+    for (std::size_t i = 0; i < rewardItem.AchievementsRequired.size(); i++)
+        data << uint32(rewardItem.AchievementsRequired[i]);
 
     return data;
 }
@@ -529,7 +529,7 @@ void WorldPackets::Guild::RequestGuildRewardsList::Read()
 
 WorldPacket const* WorldPackets::Guild::GuildRewardList::Write()
 {
-    _worldPacket << Version;
+    _worldPacket << int32(Version);
     _worldPacket << uint32(RewardItems.size());
 
     for (GuildRewardItem const& item : RewardItems)
@@ -592,9 +592,9 @@ void WorldPackets::Guild::GuildBankWithdrawMoney::Read()
 
 WorldPacket const* WorldPackets::Guild::GuildBankQueryResults::Write()
 {
-    _worldPacket << Money;
-    _worldPacket << Tab;
-    _worldPacket << WithdrawalsRemaining;
+    _worldPacket << uint64(Money);
+    _worldPacket << int32(Tab);
+    _worldPacket << int32(WithdrawalsRemaining);
     _worldPacket << uint32(TabInfo.size());
     _worldPacket << uint32(ItemInfo.size());
     _worldPacket.WriteBit(FullUpdate);
@@ -602,7 +602,7 @@ WorldPacket const* WorldPackets::Guild::GuildBankQueryResults::Write()
 
     for (GuildBankTabInfo const& tab : TabInfo)
     {
-        _worldPacket << tab.TabIndex;
+        _worldPacket << int32(tab.TabIndex);
         _worldPacket.WriteBits(tab.Name.length(), 7);
         _worldPacket.WriteBits(tab.Icon.length(), 9);
         _worldPacket.FlushBits();
@@ -613,12 +613,12 @@ WorldPacket const* WorldPackets::Guild::GuildBankQueryResults::Write()
 
     for (GuildBankItemInfo const& item : ItemInfo)
     {
-        _worldPacket << item.Slot;
-        _worldPacket << item.Count;
-        _worldPacket << item.EnchantmentID;
-        _worldPacket << item.Charges;
-        _worldPacket << item.OnUseEnchantmentID;
-        _worldPacket << item.Flags;
+        _worldPacket << int32(item.Slot);
+        _worldPacket << int32(item.Count);
+        _worldPacket << int32(item.EnchantmentID);
+        _worldPacket << int32(item.Charges);
+        _worldPacket << int32(item.OnUseEnchantmentID);
+        _worldPacket << int32(item.Flags);
         _worldPacket << item.Item;
         _worldPacket.WriteBits(item.SocketEnchant.size(), 2);
         _worldPacket.WriteBit(item.Locked);
@@ -658,7 +658,7 @@ void WorldPackets::Guild::GuildBankLogQuery::Read()
 
 WorldPacket const* WorldPackets::Guild::GuildBankLogQueryResults::Write()
 {
-    _worldPacket << Tab;
+    _worldPacket << int32(Tab);
     _worldPacket << uint32(Entry.size());
     _worldPacket.WriteBit(WeeklyBonusMoney.is_initialized());
     _worldPacket.FlushBits();
@@ -666,8 +666,8 @@ WorldPacket const* WorldPackets::Guild::GuildBankLogQueryResults::Write()
     for (GuildBankLogEntry const& logEntry : Entry)
     {
         _worldPacket << logEntry.PlayerGUID;
-        _worldPacket << logEntry.TimeOffset;
-        _worldPacket << logEntry.EntryType;
+        _worldPacket << uint32(logEntry.TimeOffset);
+        _worldPacket << int8(logEntry.EntryType);
 
         _worldPacket.WriteBit(logEntry.Money.is_initialized());
         _worldPacket.WriteBit(logEntry.ItemID.is_initialized());
@@ -676,20 +676,20 @@ WorldPacket const* WorldPackets::Guild::GuildBankLogQueryResults::Write()
         _worldPacket.FlushBits();
 
         if (logEntry.Money.is_initialized())
-            _worldPacket << *logEntry.Money;
+            _worldPacket << uint64(*logEntry.Money);
 
         if (logEntry.ItemID.is_initialized())
-            _worldPacket << *logEntry.ItemID;
+            _worldPacket << int32(*logEntry.ItemID);
 
         if (logEntry.Count.is_initialized())
-            _worldPacket << *logEntry.Count;
+            _worldPacket << int32(*logEntry.Count);
 
         if (logEntry.OtherTab.is_initialized())
-            _worldPacket << *logEntry.OtherTab;
+            _worldPacket << int8(*logEntry.OtherTab);
     }
 
     if (WeeklyBonusMoney)
-        _worldPacket << *WeeklyBonusMoney;
+        _worldPacket << uint64(*WeeklyBonusMoney);
 
     return &_worldPacket;
 }
@@ -701,7 +701,7 @@ void WorldPackets::Guild::GuildBankTextQuery::Read()
 
 WorldPacket const* WorldPackets::Guild::GuildBankTextQueryResult::Write()
 {
-    _worldPacket << Tab;
+    _worldPacket << int32(Tab);
 
     _worldPacket.WriteBits(Text.length(), 14);
     _worldPacket.FlushBits();
@@ -724,13 +724,13 @@ void WorldPackets::Guild::GuildQueryNews::Read()
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Guild::GuildNewsEvent const& newsEvent)
 {
-    data << newsEvent.Id;
+    data << int32(newsEvent.Id);
     data.AppendPackedTime(newsEvent.CompletedDate);
-    data << newsEvent.Type;
-    data << newsEvent.Flags;
+    data << int32(newsEvent.Type);
+    data << int32(newsEvent.Flags);
 
-    for (uint8 i = 0; i < 2; i++)
-        data << newsEvent.Data[i];
+    for (std::size_t i = 0; i < newsEvent.Data.size(); ++i)
+        data << int32(newsEvent.Data[i]);
 
     data << newsEvent.MemberGuid;
     data << uint32(newsEvent.MemberList.size());
diff --git a/src/server/game/Server/Packets/GuildPackets.h b/src/server/game/Server/Packets/GuildPackets.h
index 350ff772000..844dba91f5c 100644
--- a/src/server/game/Server/Packets/GuildPackets.h
+++ b/src/server/game/Server/Packets/GuildPackets.h
@@ -432,11 +432,11 @@ namespace WorldPackets
 
             int32 RankID = 0;
             int32 RankOrder = 0;
-            int32 WithdrawGoldLimit = 0;
+            uint32 WithdrawGoldLimit = 0;
             uint32 Flags = 0;
             uint32 OldFlags = 0;
-            int32 TabFlags[GUILD_BANK_MAX_TABS];
-            int32 TabWithdrawItemLimit[GUILD_BANK_MAX_TABS];
+            uint32 TabFlags[GUILD_BANK_MAX_TABS];
+            uint32 TabWithdrawItemLimit[GUILD_BANK_MAX_TABS];
             std::string RankName;
         };
 
@@ -687,7 +687,7 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             std::vector<GuildRewardItem> RewardItems;
-            uint32 Version = 0;
+            int32 Version = 0;
         };
 
         class GuildBankActivate final : public ClientPacket
@@ -813,10 +813,11 @@ namespace WorldPackets
             bool FullUpdate = false;
         };
 
+        // TODO: research new guild bank opcodes
         class GuildBankSwapItems final : public ClientPacket
         {
         public:
-            GuildBankSwapItems(WorldPacket&& packet) : ClientPacket(CMSG_GUILD_BANK_SWAP_ITEMS, std::move(packet)) { }
+            GuildBankSwapItems(WorldPacket&& packet) : ClientPacket(std::move(packet)) { }
 
             void Read() override;
 
@@ -917,9 +918,9 @@ namespace WorldPackets
             uint32 CompletedDate = 0;
             int32 Type = 0;
             int32 Flags = 0;
-            int32 Data[2];
+            std::array<int32, 2> Data;
             ObjectGuid MemberGuid;
-            GuidList MemberList;
+            std::vector<ObjectGuid> MemberList;
             Optional<Item::ItemInstance> Item;
         };
 
diff --git a/src/server/game/Server/Packets/InspectPackets.cpp b/src/server/game/Server/Packets/InspectPackets.cpp
index df9b540e164..04fc01ad669 100644
--- a/src/server/game/Server/Packets/InspectPackets.cpp
+++ b/src/server/game/Server/Packets/InspectPackets.cpp
@@ -35,6 +35,10 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Inspect::InspectItemData
 {
     data << itemData.CreatorGUID;
     data << uint8(itemData.Index);
+    data << uint32(itemData.AzeritePowers.size());
+    if (!itemData.AzeritePowers.empty())
+        data.append(itemData.AzeritePowers.data(), itemData.AzeritePowers.size());
+
     data << itemData.Item;
     data.WriteBit(itemData.Usable);
     data.WriteBits(itemData.Enchants.size(), 4);
@@ -76,10 +80,11 @@ WorldPackets::Inspect::InspectItemData::InspectItemData(::Item const* item, uint
     {
         if (gemData.ItemId)
         {
-            WorldPackets::Item::ItemGemData gem;
+            Gems.emplace_back();
+
+            WorldPackets::Item::ItemGemData& gem = Gems.back();
             gem.Slot = i;
             gem.Item.Initialize(&gemData);
-            Gems.push_back(gem);
         }
         ++i;
     }
@@ -103,6 +108,7 @@ WorldPacket const* WorldPackets::Inspect::InspectResult::Write()
         _worldPacket.append(PvpTalents.data(), PvpTalents.size());
 
     _worldPacket.WriteBit(GuildData.is_initialized());
+    _worldPacket.WriteBit(AzeriteLevel.is_initialized());
     _worldPacket.FlushBits();
 
     for (size_t i = 0; i < Items.size(); ++i)
@@ -111,6 +117,9 @@ WorldPacket const* WorldPackets::Inspect::InspectResult::Write()
     if (GuildData)
         _worldPacket << *GuildData;
 
+    if (AzeriteLevel)
+        _worldPacket << int32(*AzeriteLevel);
+
     return &_worldPacket;
 }
 
@@ -138,6 +147,7 @@ void WorldPackets::Inspect::InspectPVPRequest::Read()
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Inspect::PVPBracketData const& bracket)
 {
+    data << uint8(bracket.Bracket);
     data << int32(bracket.Rating);
     data << int32(bracket.Rank);
     data << int32(bracket.WeeklyPlayed);
@@ -146,7 +156,9 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Inspect::PVPBracketData c
     data << int32(bracket.SeasonWon);
     data << int32(bracket.WeeklyBestRating);
     data << int32(bracket.Unk710);
-    data << uint8(bracket.Bracket);
+    data << int32(bracket.Unk801_1);
+    data.WriteBit(bracket.Unk801_2);
+    data.FlushBits();
 
     return data;
 }
diff --git a/src/server/game/Server/Packets/InspectPackets.h b/src/server/game/Server/Packets/InspectPackets.h
index 7bf6b0baa2a..c6437f182f7 100644
--- a/src/server/game/Server/Packets/InspectPackets.h
+++ b/src/server/game/Server/Packets/InspectPackets.h
@@ -56,6 +56,7 @@ namespace WorldPackets
             bool Usable = false;
             std::vector<InspectEnchantData> Enchants;
             std::vector<Item::ItemGemData> Gems;
+            std::vector<int32> AzeritePowers;
         };
 
         struct InspectGuildData
@@ -68,7 +69,10 @@ namespace WorldPackets
         class InspectResult final : public ServerPacket
         {
         public:
-            InspectResult() : ServerPacket(SMSG_INSPECT_RESULT, 45) { }
+            InspectResult() : ServerPacket(SMSG_INSPECT_RESULT, 45)
+            {
+                PvpTalents.fill(0);
+            }
 
             WorldPacket const* Write() override;
 
@@ -76,11 +80,12 @@ namespace WorldPackets
             std::vector<InspectItemData> Items;
             std::vector<uint16> Glyphs;
             std::vector<uint16> Talents;
-            std::vector<uint16> PvpTalents;
+            std::array<uint16, MAX_PVP_TALENT_SLOTS> PvpTalents;
             int32 ClassID = CLASS_NONE;
             int32 GenderID = GENDER_NONE;
             Optional<InspectGuildData> GuildData;
             int32 SpecializationID = 0;
+            Optional<int32> AzeriteLevel;
         };
 
         class RequestHonorStats final : public ClientPacket
@@ -128,7 +133,9 @@ namespace WorldPackets
             int32 SeasonWon        = 0;
             int32 WeeklyBestRating = 0;
             int32 Unk710           = 0;
+            int32 Unk801_1         = 0;
             uint8 Bracket          = 0;
+            bool Unk801_2          = false;
         };
 
         class InspectPVPResponse final : public ServerPacket
diff --git a/src/server/game/Server/Packets/InstancePackets.cpp b/src/server/game/Server/Packets/InstancePackets.cpp
index 0a6e29e6838..258aa24bd1f 100644
--- a/src/server/game/Server/Packets/InstancePackets.cpp
+++ b/src/server/game/Server/Packets/InstancePackets.cpp
@@ -31,23 +31,13 @@ WorldPacket const* WorldPackets::Instance::UpdateInstanceOwnership::Write()
     return &_worldPacket;
 }
 
-WorldPacket const* WorldPackets::Instance::InstanceInfo::Write()
-{
-    _worldPacket << int32(LockList.size());
-
-    for (InstanceLockInfos const& lockInfos : LockList)
-        _worldPacket << lockInfos;
-
-    return &_worldPacket;
-}
-
-ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Instance::InstanceLockInfos const& lockInfos)
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Instance::InstanceLock const& lockInfos)
 {
-    data << lockInfos.MapID;
-    data << lockInfos.DifficultyID;
-    data << lockInfos.InstanceID;
-    data << lockInfos.TimeRemaining;
-    data << lockInfos.CompletedMask;
+    data << uint32(lockInfos.MapID);
+    data << uint32(lockInfos.DifficultyID);
+    data << uint64(lockInfos.InstanceID);
+    data << uint32(lockInfos.TimeRemaining);
+    data << uint32(lockInfos.CompletedMask);
 
     data.WriteBit(lockInfos.Locked);
     data.WriteBit(lockInfos.Extended);
@@ -57,6 +47,16 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Instance::InstanceLockInf
     return data;
 }
 
+WorldPacket const* WorldPackets::Instance::InstanceInfo::Write()
+{
+    _worldPacket << int32(LockList.size());
+
+    for (InstanceLock const& instanceLock : LockList)
+        _worldPacket << instanceLock;
+
+    return &_worldPacket;
+}
+
 WorldPacket const* WorldPackets::Instance::InstanceReset::Write()
 {
     _worldPacket << uint32(MapID);
diff --git a/src/server/game/Server/Packets/InstancePackets.h b/src/server/game/Server/Packets/InstancePackets.h
index f13e046906e..0869a137926 100644
--- a/src/server/game/Server/Packets/InstancePackets.h
+++ b/src/server/game/Server/Packets/InstancePackets.h
@@ -47,7 +47,7 @@ namespace WorldPackets
                                     // but it has been deperecated in favor of simply checking group leader, being inside an instance or using dungeon finder
         };
 
-        struct InstanceLockInfos
+        struct InstanceLock
         {
             uint64 InstanceID = 0u;
             uint32 MapID = 0u;
@@ -66,7 +66,7 @@ namespace WorldPackets
 
             WorldPacket const* Write() override;
 
-            std::vector<InstanceLockInfos> LockList;
+            std::vector<InstanceLock> LockList;
         };
 
         class ResetInstances final : public ClientPacket
@@ -90,7 +90,7 @@ namespace WorldPackets
         class InstanceResetFailed final : public ServerPacket
         {
         public:
-            InstanceResetFailed() : ServerPacket(SMSG_INSTANCE_RESET_FAILED, 4 + 4) { }
+            InstanceResetFailed() : ServerPacket(SMSG_INSTANCE_RESET_FAILED, 4 + 1) { }
 
             WorldPacket const* Write() override;
 
@@ -248,6 +248,4 @@ namespace WorldPackets
     }
 }
 
-ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Instance::InstanceLockInfos const& lockInfos);
-
 #endif // InstancePackets_h__
diff --git a/src/server/game/Server/Packets/ItemPackets.cpp b/src/server/game/Server/Packets/ItemPackets.cpp
index 87599873de5..55f4274eefc 100644
--- a/src/server/game/Server/Packets/ItemPackets.cpp
+++ b/src/server/game/Server/Packets/ItemPackets.cpp
@@ -280,7 +280,7 @@ WorldPacket const* WorldPackets::Item::ReadItemResultFailed::Write()
 {
     _worldPacket << Item;
     _worldPacket << uint32(Delay);
-    _worldPacket.WriteBits(Subcode, 3);
+    _worldPacket.WriteBits(Subcode, 2);
 
     _worldPacket.FlushBits();
 
diff --git a/src/server/game/Server/Packets/LFGPackets.cpp b/src/server/game/Server/Packets/LFGPackets.cpp
index 5b8d66afd6a..1ec2dec7804 100644
--- a/src/server/game/Server/Packets/LFGPackets.cpp
+++ b/src/server/game/Server/Packets/LFGPackets.cpp
@@ -311,10 +311,15 @@ WorldPacket const* WorldPackets::LFG::LFGQueueStatus::Write()
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::LFG::LFGPlayerRewards const& lfgPlayerRewards)
 {
-    data << int32(lfgPlayerRewards.RewardItem);
-    data << uint32(lfgPlayerRewards.RewardItemQuantity);
-    data << int32(lfgPlayerRewards.BonusCurrency);
-    data.WriteBit(lfgPlayerRewards.IsCurrency);
+    data.WriteBit(lfgPlayerRewards.RewardItem.is_initialized());
+    data.WriteBit(lfgPlayerRewards.RewardCurrency.is_initialized());
+    if (lfgPlayerRewards.RewardItem)
+        data << *lfgPlayerRewards.RewardItem;
+
+    data << uint32(lfgPlayerRewards.Quantity);
+    data << int32(lfgPlayerRewards.BonusQuantity);
+    if (lfgPlayerRewards.RewardCurrency)
+        data << int32(*lfgPlayerRewards.RewardCurrency);
 
     return data;
 }
diff --git a/src/server/game/Server/Packets/LFGPackets.h b/src/server/game/Server/Packets/LFGPackets.h
index 9e1c513aece..2b31074094d 100644
--- a/src/server/game/Server/Packets/LFGPackets.h
+++ b/src/server/game/Server/Packets/LFGPackets.h
@@ -20,6 +20,7 @@
 
 #include "Packet.h"
 #include "PacketUtilities.h"
+#include "ItemPacketsCommon.h"
 #include "LFGPacketsCommon.h"
 #include "Optional.h"
 
@@ -325,13 +326,24 @@ namespace WorldPackets
         struct LFGPlayerRewards
         {
             LFGPlayerRewards() { }
-            LFGPlayerRewards(int32 rewardItem, uint32 rewardItemQuantity, int32 bonusCurrency, bool isCurrency)
-                : RewardItem(rewardItem), RewardItemQuantity(rewardItemQuantity), BonusCurrency(bonusCurrency), IsCurrency(isCurrency) { }
-
-            int32 RewardItem = 0;
-            uint32 RewardItemQuantity = 0;
-            int32 BonusCurrency = 0;
-            bool IsCurrency = false;
+            LFGPlayerRewards(int32 id, uint32 quantity, int32 bonusQuantity, bool isCurrency)
+                : Quantity(quantity), BonusQuantity(bonusQuantity)
+            {
+                if (!isCurrency)
+                {
+                    RewardItem = boost::in_place();
+                    RewardItem->ItemID = id;
+                }
+                else
+                {
+                    RewardCurrency = id;
+                }
+            }
+
+            Optional<Item::ItemInstance> RewardItem;
+            Optional<int32> RewardCurrency;
+            uint32 Quantity = 0;
+            int32 BonusQuantity = 0;
         };
 
         class LFGPlayerReward final : public ServerPacket
diff --git a/src/server/game/Server/Packets/MiscPackets.cpp b/src/server/game/Server/Packets/MiscPackets.cpp
index a03f1ff35fc..9f98092d091 100644
--- a/src/server/game/Server/Packets/MiscPackets.cpp
+++ b/src/server/game/Server/Packets/MiscPackets.cpp
@@ -346,7 +346,8 @@ WorldPacket const* WorldPackets::Misc::LevelUpInfo::Write()
     for (int32 stat : StatDelta)
         _worldPacket << stat;
 
-    _worldPacket << int32(Cp);
+    _worldPacket << int32(NumNewTalents);
+    _worldPacket << int32(NumNewPvpTalentSlots);
 
     return &_worldPacket;
 }
@@ -404,11 +405,11 @@ WorldPacket const* WorldPackets::Misc::PhaseShiftChange::Write()
 
     _worldPacket << uint32(PreloadMapIDs.size() * 2);           // size in bytes
     for (uint16 preloadMapId : PreloadMapIDs)
-        _worldPacket << uint16(preloadMapId);                            // Inactive terrain swap map id
+        _worldPacket << uint16(preloadMapId);                   // Inactive terrain swap map id
 
-    _worldPacket << uint32(UiWorldMapAreaIDSwaps.size() * 2);   // size in bytes
-    for (uint16 uiWorldMapAreaIDSwap : UiWorldMapAreaIDSwaps)
-        _worldPacket << uint16(uiWorldMapAreaIDSwap);          // UI map id, WorldMapArea.db2, controls map display
+    _worldPacket << uint32(UiMapPhaseIDs.size() * 2);           // size in bytes
+    for (uint16 uiMapPhaseId : UiMapPhaseIDs)
+        _worldPacket << uint16(uiMapPhaseId);                   // phase id, controls only map display (visible on all maps)
 
     return &_worldPacket;
 }
diff --git a/src/server/game/Server/Packets/MiscPackets.h b/src/server/game/Server/Packets/MiscPackets.h
index 26affbaf934..df9c99e063b 100644
--- a/src/server/game/Server/Packets/MiscPackets.h
+++ b/src/server/game/Server/Packets/MiscPackets.h
@@ -258,7 +258,7 @@ namespace WorldPackets
 
             void Read() override;
 
-            int32 DifficultyID = 0;
+            uint32 DifficultyID = 0;
         };
 
         class SetRaidDifficulty final : public ClientPacket
@@ -480,7 +480,8 @@ namespace WorldPackets
             int32 HealthDelta = 0;
             std::array<int32, 6> PowerDelta = { };
             std::array<int32, MAX_STATS> StatDelta = { };
-            int32 Cp = 0;
+            int32 NumNewTalents = 0;
+            int32 NumNewPvpTalentSlots = 0;
         };
 
         class PlayMusic final : public ServerPacket
@@ -551,7 +552,7 @@ namespace WorldPackets
             ObjectGuid Client;
             PhaseShiftData Phaseshift;
             std::vector<uint16> PreloadMapIDs;
-            std::vector<uint16> UiWorldMapAreaIDSwaps;
+            std::vector<uint16> UiMapPhaseIDs;
             std::vector<uint16> VisibleMapIDs;
         };
 
@@ -878,14 +879,6 @@ namespace WorldPackets
             bool IsFavorite = false;
         };
 
-        class PvpPrestigeRankUp final : public ClientPacket
-        {
-        public:
-            PvpPrestigeRankUp(WorldPacket&& packet) : ClientPacket(CMSG_PVP_PRESTIGE_RANK_UP, std::move(packet)) { }
-
-            void Read() override { }
-        };
-
         class CloseInteraction final : public ClientPacket
         {
         public:
diff --git a/src/server/game/Server/Packets/MovementPackets.cpp b/src/server/game/Server/Packets/MovementPackets.cpp
index 38a7f8f68fd..3dd719f46b0 100644
--- a/src/server/game/Server/Packets/MovementPackets.cpp
+++ b/src/server/game/Server/Packets/MovementPackets.cpp
@@ -213,6 +213,16 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Movement::MonsterSplineSp
     data << uint32(spellEffectExtraData.SpellVisualID);
     data << uint32(spellEffectExtraData.ProgressCurveID);
     data << uint32(spellEffectExtraData.ParabolicCurveID);
+    data << float(spellEffectExtraData.JumpGravity);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Movement::MonsterSplineJumpExtraData const& jumpExtraData)
+{
+    data << float(jumpExtraData.JumpGravity);
+    data << uint32(jumpExtraData.StartTime);
+    data << uint32(jumpExtraData.Duration);
 
     return data;
 }
@@ -224,8 +234,7 @@ ByteBuffer& WorldPackets::operator<<(ByteBuffer& data, Movement::MovementSpline
     data << uint32(movementSpline.TierTransStartTime);
     data << int32(movementSpline.Elapsed);
     data << uint32(movementSpline.MoveTime);
-    data << float(movementSpline.JumpGravity);
-    data << uint32(movementSpline.SpecialTime);
+    data << uint32(movementSpline.FadeObjectTime);
     data << uint8(movementSpline.Mode);
     data << uint8(movementSpline.VehicleExitVoluntary);
     data << movementSpline.TransportGUID;
@@ -235,6 +244,7 @@ ByteBuffer& WorldPackets::operator<<(ByteBuffer& data, Movement::MovementSpline
     data.WriteBits(movementSpline.PackedDeltas.size(), 16);
     data.WriteBit(movementSpline.SplineFilter.is_initialized());
     data.WriteBit(movementSpline.SpellEffectExtraData.is_initialized());
+    data.WriteBit(movementSpline.JumpExtraData.is_initialized());
     data.FlushBits();
 
     if (movementSpline.SplineFilter)
@@ -262,6 +272,9 @@ ByteBuffer& WorldPackets::operator<<(ByteBuffer& data, Movement::MovementSpline
     if (movementSpline.SpellEffectExtraData)
         data << *movementSpline.SpellEffectExtraData;
 
+    if (movementSpline.JumpExtraData)
+        data << *movementSpline.JumpExtraData;
+
     return data;
 }
 
@@ -300,12 +313,12 @@ void WorldPackets::Movement::CommonMovement::WriteCreateObjectSplineDataBlock(::
         data << float(1.0f);                                                    // DurationModifier
         data << float(1.0f);                                                    // NextDurationModifier
         data.WriteBits(moveSpline.facing.type, 2);                              // Face
-        bool HasJumpGravity = data.WriteBit(moveSpline.splineflags.parabolic || moveSpline.splineflags.animation);                 // HasJumpGravity
-        bool HasSpecialTime = data.WriteBit(moveSpline.splineflags.parabolic && moveSpline.effect_start_time < moveSpline.Duration()); // HasSpecialTime
+        bool hasFadeObjectTime = data.WriteBit(moveSpline.splineflags.fadeObject && moveSpline.effect_start_time < moveSpline.Duration());
         data.WriteBits(moveSpline.getPath().size(), 16);
         data.WriteBits(uint8(moveSpline.spline.mode()), 2);                     // Mode
         data.WriteBit(0);                                                       // HasSplineFilter
         data.WriteBit(moveSpline.spell_effect_extra.is_initialized());          // HasSpellEffectExtraData
+        data.WriteBit(moveSpline.splineflags.parabolic);                        // HasJumpExtraData
         data.FlushBits();
 
         //if (HasSplineFilterKey)
@@ -341,11 +354,8 @@ void WorldPackets::Movement::CommonMovement::WriteCreateObjectSplineDataBlock(::
                 break;
         }
 
-        if (HasJumpGravity)
-            data << float(moveSpline.vertical_acceleration);                    // JumpGravity
-
-        if (HasSpecialTime)
-            data << uint32(moveSpline.effect_start_time);                       // SpecialTime
+        if (hasFadeObjectTime)
+            data << uint32(moveSpline.effect_start_time);                       // FadeObjectTime
 
         data.append(moveSpline.getPath().data(), moveSpline.getPath().size());
 
@@ -355,6 +365,14 @@ void WorldPackets::Movement::CommonMovement::WriteCreateObjectSplineDataBlock(::
             data << uint32(moveSpline.spell_effect_extra->SpellVisualId);
             data << uint32(moveSpline.spell_effect_extra->ProgressCurveId);
             data << uint32(moveSpline.spell_effect_extra->ParabolicCurveId);
+            data << float(moveSpline.vertical_acceleration);
+        }
+
+        if (moveSpline.splineflags.parabolic)
+        {
+            data << float(moveSpline.vertical_acceleration);
+            data << uint32(moveSpline.effect_start_time);
+            data << uint32(0);                                                  // Duration (override)
         }
     }
 }
@@ -388,12 +406,13 @@ void WorldPackets::Movement::MonsterMove::InitializeSplineData(::Movement::MoveS
 
     if (splineFlags.parabolic)
     {
-        movementSpline.JumpGravity = moveSpline.vertical_acceleration;
-        movementSpline.SpecialTime = moveSpline.effect_start_time;
+        movementSpline.JumpExtraData = boost::in_place();
+        movementSpline.JumpExtraData->JumpGravity = moveSpline.vertical_acceleration;
+        movementSpline.JumpExtraData->StartTime = moveSpline.effect_start_time;
     }
 
     if (splineFlags.fadeObject)
-        movementSpline.SpecialTime = moveSpline.effect_start_time;
+        movementSpline.FadeObjectTime = moveSpline.effect_start_time;
 
     if (moveSpline.spell_effect_extra)
     {
@@ -402,6 +421,7 @@ void WorldPackets::Movement::MonsterMove::InitializeSplineData(::Movement::MoveS
         movementSpline.SpellEffectExtraData->SpellVisualID = moveSpline.spell_effect_extra->SpellVisualId;
         movementSpline.SpellEffectExtraData->ProgressCurveID = moveSpline.spell_effect_extra->ProgressCurveId;
         movementSpline.SpellEffectExtraData->ParabolicCurveID = moveSpline.spell_effect_extra->ParabolicCurveId;
+        movementSpline.SpellEffectExtraData->JumpGravity = moveSpline.vertical_acceleration;
     }
 
     ::Movement::Spline<int32> const& spline = moveSpline.spline;
diff --git a/src/server/game/Server/Packets/MovementPackets.h b/src/server/game/Server/Packets/MovementPackets.h
index aaa5f770535..e50a8cf6a71 100644
--- a/src/server/game/Server/Packets/MovementPackets.h
+++ b/src/server/game/Server/Packets/MovementPackets.h
@@ -75,6 +75,14 @@ namespace WorldPackets
             uint32 SpellVisualID = 0;
             uint32 ProgressCurveID = 0;
             uint32 ParabolicCurveID = 0;
+            float JumpGravity = 0.0f;
+        };
+
+        struct MonsterSplineJumpExtraData
+        {
+            float JumpGravity = 0.0f;
+            uint32 StartTime = 0;
+            uint32 Duration = 0;
         };
 
         struct MovementSpline
@@ -85,8 +93,7 @@ namespace WorldPackets
             uint32 TierTransStartTime   = 0;
             int32 Elapsed               = 0;
             uint32 MoveTime             = 0;
-            float JumpGravity           = 0.0f;
-            uint32 SpecialTime          = 0;
+            uint32 FadeObjectTime       = 0;
             std::vector<TaggedPosition<Position::XYZ>> Points;   // Spline path
             uint8 Mode                  = 0;    // Spline mode - actually always 0 in this packet - Catmullrom mode appears only in SMSG_UPDATE_OBJECT. In this packet it is determined by flags
             uint8 VehicleExitVoluntary  = 0;
@@ -95,6 +102,7 @@ namespace WorldPackets
             std::vector<TaggedPosition<Position::PackedXYZ>> PackedDeltas;
             Optional<MonsterSplineFilter> SplineFilter;
             Optional<MonsterSplineSpellEffectExtraData> SpellEffectExtraData;
+            Optional<MonsterSplineJumpExtraData> JumpExtraData;
             float FaceDirection         = 0.0f;
             ObjectGuid FaceGUID;
             TaggedPosition<Position::XYZ> FaceSpot;
diff --git a/src/server/game/Server/Packets/NPCPackets.cpp b/src/server/game/Server/Packets/NPCPackets.cpp
index 2b7f9ab7d18..749b4b9a330 100644
--- a/src/server/game/Server/Packets/NPCPackets.cpp
+++ b/src/server/game/Server/Packets/NPCPackets.cpp
@@ -96,19 +96,19 @@ WorldPacket const* WorldPackets::NPC::VendorInventory::Write()
 WorldPacket const* WorldPackets::NPC::TrainerList::Write()
 {
     _worldPacket << TrainerGUID;
-    _worldPacket << TrainerType;
-    _worldPacket << TrainerID;
+    _worldPacket << uint32(TrainerType);
+    _worldPacket << uint32(TrainerID);
 
-    _worldPacket << int32(Spells.size());
+    _worldPacket << uint32(Spells.size());
     for (TrainerListSpell const& spell : Spells)
     {
-        _worldPacket << spell.SpellID;
-        _worldPacket << spell.MoneyCost;
-        _worldPacket << spell.ReqSkillLine;
-        _worldPacket << spell.ReqSkillRank;
+        _worldPacket << int32(spell.SpellID);
+        _worldPacket << uint32(spell.MoneyCost);
+        _worldPacket << uint32(spell.ReqSkillLine);
+        _worldPacket << uint32(spell.ReqSkillRank);
         _worldPacket.append(spell.ReqAbility.data(), spell.ReqAbility.size());
-        _worldPacket << spell.Usable;
-        _worldPacket << spell.ReqLevel;
+        _worldPacket << uint8(spell.Usable);
+        _worldPacket << uint8(spell.ReqLevel);
     }
 
     _worldPacket.WriteBits(Greeting.length(), 11);
@@ -144,11 +144,13 @@ WorldPacket const* WorldPackets::NPC::PlayerTabardVendorActivate::Write()
 
 WorldPacket const* WorldPackets::NPC::GossipPOI::Write()
 {
-    _worldPacket.WriteBits(Flags, 14);
-    _worldPacket.WriteBits(Name.length(), 6);
+    _worldPacket << int32(ID);
     _worldPacket << Pos;
     _worldPacket << int32(Icon);
     _worldPacket << int32(Importance);
+    _worldPacket.WriteBits(Flags, 14);
+    _worldPacket.WriteBits(Name.length(), 6);
+    _worldPacket.FlushBits();
     _worldPacket.WriteString(Name);
 
     return &_worldPacket;
diff --git a/src/server/game/Server/Packets/NPCPackets.h b/src/server/game/Server/Packets/NPCPackets.h
index a094f25dc22..8148e3aff60 100644
--- a/src/server/game/Server/Packets/NPCPackets.h
+++ b/src/server/game/Server/Packets/NPCPackets.h
@@ -131,9 +131,9 @@ namespace WorldPackets
         struct TrainerListSpell
         {
             int32 SpellID       = 0;
-            int32 MoneyCost     = 0;
-            int32 ReqSkillLine  = 0;
-            int32 ReqSkillRank  = 0;
+            uint32 MoneyCost    = 0;
+            uint32 ReqSkillLine = 0;
+            uint32 ReqSkillRank = 0;
             std::array<int32, 3> ReqAbility = { };
             uint8 Usable        = 0;
             uint8 ReqLevel      = 0;
@@ -180,6 +180,7 @@ namespace WorldPackets
 
             WorldPacket const* Write() override;
 
+            int32 ID            = 0;
             uint32 Flags        = 0;
             TaggedPosition<Position::XY> Pos;
             int32 Icon          = 0;
diff --git a/src/server/game/Server/Packets/PacketUtilities.h b/src/server/game/Server/Packets/PacketUtilities.h
index f7913b9c51d..99b214aab36 100644
--- a/src/server/game/Server/Packets/PacketUtilities.h
+++ b/src/server/game/Server/Packets/PacketUtilities.h
@@ -42,6 +42,8 @@ namespace WorldPackets
 
         typedef typename storage_type::value_type value_type;
         typedef typename storage_type::size_type size_type;
+        typedef typename storage_type::pointer pointer;
+        typedef typename storage_type::const_pointer const_pointer;
         typedef typename storage_type::reference reference;
         typedef typename storage_type::const_reference const_reference;
         typedef typename storage_type::iterator iterator;
@@ -55,6 +57,9 @@ namespace WorldPackets
         iterator end() { return _storage.end(); }
         const_iterator end() const { return _storage.end(); }
 
+        pointer data() { return _storage.data(); }
+        const_pointer data() const { return _storage.data(); }
+
         size_type size() const { return _storage.size(); }
         bool empty() const { return _storage.empty(); }
 
diff --git a/src/server/game/Server/Packets/PartyPackets.cpp b/src/server/game/Server/Packets/PartyPackets.cpp
index 939f0a65db1..9251addde38 100644
--- a/src/server/game/Server/Packets/PartyPackets.cpp
+++ b/src/server/game/Server/Packets/PartyPackets.cpp
@@ -33,7 +33,7 @@ WorldPacket const* WorldPackets::Party::PartyCommandResult::Write()
     _worldPacket.WriteBits(Command, 4);
     _worldPacket.WriteBits(Result, 6);
 
-    _worldPacket << ResultData;
+    _worldPacket << uint32(ResultData);
     _worldPacket << ResultGUID;
     _worldPacket.WriteString(Name);
 
@@ -78,12 +78,12 @@ WorldPacket const* WorldPackets::Party::PartyInvite::Write()
     _worldPacket << InviterBNetAccountId;
     _worldPacket << uint16(Unk1);
     _worldPacket << uint32(ProposedRoles);
-    _worldPacket << int32(LfgSlots.size());
-    _worldPacket << LfgCompletedMask;
+    _worldPacket << uint32(LfgSlots.size());
+    _worldPacket << uint32(LfgCompletedMask);
 
     _worldPacket.WriteString(InviterName);
 
-    for (int32 LfgSlot : LfgSlots)
+    for (uint32 LfgSlot : LfgSlots)
         _worldPacket << LfgSlot;
 
     return &_worldPacket;
@@ -212,7 +212,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::PartyMemberStats c
     data << int16(memberStats.PositionY);
     data << int16(memberStats.PositionZ);
     data << int32(memberStats.VehicleSeat);
-    data << int32(memberStats.Auras.size());
+    data << uint32(memberStats.Auras.size());
     data << memberStats.Phases;
 
     for (WorldPackets::Party::PartyMemberAuraStates const& aura : memberStats.Auras)
@@ -318,15 +318,13 @@ WorldPacket const* WorldPackets::Party::SendRaidTargetUpdateSingle::Write()
 
 WorldPacket const* WorldPackets::Party::SendRaidTargetUpdateAll::Write()
 {
-    _worldPacket << PartyIndex;
-
-    _worldPacket << int32(TargetIcons.size());
+    _worldPacket << uint8(PartyIndex);
+    _worldPacket << uint32(TargetIcons.size());
 
-    std::map<uint8, ObjectGuid>::const_iterator itr;
-    for (itr = TargetIcons.begin(); itr != TargetIcons.end(); itr++)
+    for (auto itr = TargetIcons.begin(); itr != TargetIcons.end(); ++itr)
     {
         _worldPacket << itr->second;
-        _worldPacket << itr->first;
+        _worldPacket << uint8(itr->first);
     }
 
     return &_worldPacket;
@@ -420,7 +418,9 @@ WorldPacket const* WorldPackets::Party::GroupNewLeader::Write()
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::PartyPlayerInfo const& playerInfo)
 {
     data.WriteBits(playerInfo.Name.size(), 6);
+    data.WriteBits(playerInfo.VoiceStateID.size(), 6);
     data.WriteBit(playerInfo.FromSocialQueue);
+    data.WriteBit(playerInfo.VoiceChatSilenced);
     data << playerInfo.GUID;
     data << uint8(playerInfo.Status);
     data << uint8(playerInfo.Subgroup);
@@ -428,6 +428,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Party::PartyPlayerInfo co
     data << uint8(playerInfo.RolesAssigned);
     data << uint8(playerInfo.Class);
     data.WriteString(playerInfo.Name);
+    data.WriteString(playerInfo.VoiceStateID);
 
     return data;
 }
@@ -524,8 +525,8 @@ void WorldPackets::Party::ClearRaidMarker::Read()
 
 WorldPacket const* WorldPackets::Party::RaidMarkersChanged::Write()
 {
-    _worldPacket << PartyIndex;
-    _worldPacket << ActiveMarkers;
+    _worldPacket << uint8(PartyIndex);
+    _worldPacket << uint32(ActiveMarkers);
 
     _worldPacket.WriteBits(RaidMarkers.size(), 4);
     _worldPacket.FlushBits();
diff --git a/src/server/game/Server/Packets/PartyPackets.h b/src/server/game/Server/Packets/PartyPackets.h
index f62e61d0990..d0b689ffb04 100644
--- a/src/server/game/Server/Packets/PartyPackets.h
+++ b/src/server/game/Server/Packets/PartyPackets.h
@@ -48,8 +48,8 @@ namespace WorldPackets
 
             void Read() override;
 
-            int8 PartyIndex = 0;
-            int32 ProposedRoles = 0;
+            uint8 PartyIndex = 0;
+            uint32 ProposedRoles = 0;
             std::string TargetName;
             std::string TargetRealm;
             ObjectGuid TargetGUID;
@@ -85,9 +85,9 @@ namespace WorldPackets
             std::string InviterRealmNameNormalized;
 
             // Lfg
-            int32 ProposedRoles = 0;
-            int32 LfgCompletedMask = 0;
-            std::vector<int32> LfgSlots;
+            uint32 ProposedRoles = 0;
+            uint32 LfgCompletedMask = 0;
+            std::vector<uint32> LfgSlots;
         };
 
         class PartyInviteResponse final : public ClientPacket
@@ -97,9 +97,9 @@ namespace WorldPackets
 
             void Read() override;
 
-            int8 PartyIndex = 0;
+            uint8 PartyIndex = 0;
             bool Accept = false;
-            Optional<int32> RolesDesired;
+            Optional<uint32> RolesDesired;
         };
 
         class PartyUninvite final : public ClientPacket
@@ -109,7 +109,7 @@ namespace WorldPackets
 
             void Read() override;
 
-            int8 PartyIndex = 0;
+            uint8 PartyIndex = 0;
             ObjectGuid TargetGUID;
             std::string Reason;
         };
@@ -327,7 +327,7 @@ namespace WorldPackets
 
             WorldPacket const* Write() override;
 
-            int8 PartyIndex = 0;
+            uint8 PartyIndex = 0;
             std::map<uint8, ObjectGuid> TargetIcons;
         };
 
@@ -359,7 +359,7 @@ namespace WorldPackets
             void Read() override;
 
             ObjectGuid Target;
-            int8 PartyIndex = 0;
+            uint8 PartyIndex = 0;
             bool Apply = false;
         };
 
@@ -405,7 +405,7 @@ namespace WorldPackets
 
             void Read() override;
 
-            int8 PartyIndex = 0;
+            uint8 PartyIndex = 0;
             bool IsReady = false;
         };
 
@@ -486,13 +486,14 @@ namespace WorldPackets
         {
             ObjectGuid GUID;
             std::string Name;
+            std::string VoiceStateID;   // same as bgs.protocol.club.v1.MemberVoiceState.id
             uint8 Class = 0;
-
             uint8 Status = 0u;
             uint8 Subgroup = 0u;
             uint8 Flags = 0u;
             uint8 RolesAssigned = 0u;
             bool FromSocialQueue = false;
+            bool VoiceChatSilenced = false;
         };
 
         struct PartyLFGInfo
@@ -554,7 +555,7 @@ namespace WorldPackets
 
             void Read() override;
 
-            int8 PartyIndex = 0;
+            uint8 PartyIndex = 0;
             bool EveryoneIsAssistant = false;
         };
 
@@ -599,7 +600,7 @@ namespace WorldPackets
 
             WorldPacket const* Write() override;
 
-            int8 PartyIndex = 0;
+            uint8 PartyIndex = 0;
             uint32 ActiveMarkers = 0u;
 
             std::vector<RaidMarker*> RaidMarkers;
diff --git a/src/server/game/Server/Packets/PetPackets.cpp b/src/server/game/Server/Packets/PetPackets.cpp
index 06182856bb4..d62ce6840cb 100644
--- a/src/server/game/Server/Packets/PetPackets.cpp
+++ b/src/server/game/Server/Packets/PetPackets.cpp
@@ -65,9 +65,8 @@ WorldPacket const* WorldPackets::Pet::PetStableList::Write()
         _worldPacket << int32(pet.CreatureID);
         _worldPacket << int32(pet.DisplayID);
         _worldPacket << int32(pet.ExperienceLevel);
-        _worldPacket << int32(pet.PetFlags);
-
-        _worldPacket << int8(pet.PetName.length());
+        _worldPacket << uint8(pet.PetFlags);
+        _worldPacket.WriteBits(pet.PetName.length(), 8);
         _worldPacket.WriteString(pet.PetName);
     }
 
@@ -92,21 +91,18 @@ WorldPacket const* WorldPackets::Pet::PetUnlearnedSpells::Write()
 
 WorldPacket const* WorldPackets::Pet::PetNameInvalid::Write()
 {
+    _worldPacket << uint8(Result);
     _worldPacket << RenameData.PetGUID;
     _worldPacket << int32(RenameData.PetNumber);
 
     _worldPacket << uint8(RenameData.NewName.length());
 
     _worldPacket.WriteBit(RenameData.DeclinedNames.is_initialized());
-    _worldPacket.FlushBits();
 
     if (RenameData.DeclinedNames)
     {
         for (int32 i = 0; i < MAX_DECLINED_NAME_CASES; i++)
-        {
             _worldPacket.WriteBits(RenameData.DeclinedNames->name[i].length(), 7);
-            _worldPacket.FlushBits();
-        }
 
         for (int32 i = 0; i < MAX_DECLINED_NAME_CASES; i++)
             _worldPacket << RenameData.DeclinedNames->name[i];
@@ -121,8 +117,7 @@ void WorldPackets::Pet::PetRename::Read()
     _worldPacket >> RenameData.PetGUID;
     _worldPacket >> RenameData.PetNumber;
 
-    int8 nameLen = 0;
-    _worldPacket >> nameLen;
+    uint8 nameLen = _worldPacket.ReadBits(8);
 
     if (_worldPacket.ReadBit())
     {
diff --git a/src/server/game/Server/Packets/PetPackets.h b/src/server/game/Server/Packets/PetPackets.h
index 965dc0b60c4..3f57f0360c9 100644
--- a/src/server/game/Server/Packets/PetPackets.h
+++ b/src/server/game/Server/Packets/PetPackets.h
@@ -125,7 +125,7 @@ namespace WorldPackets
             uint32 CreatureID = 0;
             uint32 DisplayID = 0;
             uint32 ExperienceLevel = 0;
-            uint32 PetFlags = 0;
+            uint8 PetFlags = 0;
             std::string PetName;
         };
 
diff --git a/src/server/game/Server/Packets/PetitionPackets.cpp b/src/server/game/Server/Packets/PetitionPackets.cpp
index 132494aed46..06823e15204 100644
--- a/src/server/game/Server/Packets/PetitionPackets.cpp
+++ b/src/server/game/Server/Packets/PetitionPackets.cpp
@@ -25,32 +25,31 @@ void WorldPackets::Petition::QueryPetition::Read()
 
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Petition::PetitionInfo const& petitionInfo)
 {
-    data << petitionInfo.PetitionID;
+    data << int32(petitionInfo.PetitionID);
     data << petitionInfo.Petitioner;
-
-    data << petitionInfo.MinSignatures;
-    data << petitionInfo.MaxSignatures;
-    data << petitionInfo.DeadLine;
-    data << petitionInfo.IssueDate;
-    data << petitionInfo.AllowedGuildID;
-    data << petitionInfo.AllowedClasses;
-    data << petitionInfo.AllowedRaces;
-    data << petitionInfo.AllowedGender;
-    data << petitionInfo.AllowedMinLevel;
-    data << petitionInfo.AllowedMaxLevel;
-    data << petitionInfo.NumChoices;
-    data << petitionInfo.StaticType;
-    data << petitionInfo.Muid;
+    data << int32(petitionInfo.MinSignatures);
+    data << int32(petitionInfo.MaxSignatures);
+    data << int32(petitionInfo.DeadLine);
+    data << int32(petitionInfo.IssueDate);
+    data << int32(petitionInfo.AllowedGuildID);
+    data << int32(petitionInfo.AllowedClasses);
+    data << int32(petitionInfo.AllowedRaces);
+    data << int16(petitionInfo.AllowedGender);
+    data << int32(petitionInfo.AllowedMinLevel);
+    data << int32(petitionInfo.AllowedMaxLevel);
+    data << int32(petitionInfo.NumChoices);
+    data << int32(petitionInfo.StaticType);
+    data << uint32(petitionInfo.Muid);
 
     data.WriteBits(petitionInfo.Title.length(), 7);
     data.WriteBits(petitionInfo.BodyText.length(), 12);
 
-    for (uint8 i = 0; i < 10; i++)
+    for (std::size_t i = 0; i < petitionInfo.Choicetext.size(); ++i)
         data.WriteBits(petitionInfo.Choicetext[i].length(), 6);
 
     data.FlushBits();
 
-    for (uint8 i = 0; i < 10; i++)
+    for (std::size_t i = 0; i < petitionInfo.Choicetext.size(); ++i)
         data.WriteString(petitionInfo.Choicetext[i]);
 
     data.WriteString(petitionInfo.Title);
@@ -61,7 +60,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Petition::PetitionInfo co
 
 WorldPacket const* WorldPackets::Petition::QueryPetitionResponse::Write()
 {
-    _worldPacket << PetitionID;
+    _worldPacket << uint32(PetitionID);
     _worldPacket.WriteBit(Allow);
     _worldPacket.FlushBits();
 
@@ -102,13 +101,13 @@ WorldPacket const* WorldPackets::Petition::ServerPetitionShowSignatures::Write()
     _worldPacket << Item;
     _worldPacket << Owner;
     _worldPacket << OwnerAccountID;
-    _worldPacket << PetitionID;
+    _worldPacket << int32(PetitionID);
 
     _worldPacket << uint32(Signatures.size());
-    for (PetitionSignature signature : Signatures)
+    for (PetitionSignature const& signature : Signatures)
     {
         _worldPacket << signature.Signer;
-        _worldPacket << signature.Choice;
+        _worldPacket << int32(signature.Choice);
     }
 
     return &_worldPacket;
diff --git a/src/server/game/Server/Packets/PetitionPackets.h b/src/server/game/Server/Packets/PetitionPackets.h
index a5b4e8dca6f..c378c053d84 100644
--- a/src/server/game/Server/Packets/PetitionPackets.h
+++ b/src/server/game/Server/Packets/PetitionPackets.h
@@ -56,7 +56,7 @@ namespace WorldPackets
             int32 NumChoices = 0;
             int32 StaticType = 0;
             uint32 Muid = 0;
-            std::string Choicetext[10];
+            std::array<std::string, 10> Choicetext;
         };
 
         class QueryPetitionResponse final : public ServerPacket
diff --git a/src/server/game/Server/Packets/QueryPackets.cpp b/src/server/game/Server/Packets/QueryPackets.cpp
index c640394be93..f941c895722 100644
--- a/src/server/game/Server/Packets/QueryPackets.cpp
+++ b/src/server/game/Server/Packets/QueryPackets.cpp
@@ -29,7 +29,7 @@ void WorldPackets::Query::QueryCreature::Read()
 
 WorldPacket const* WorldPackets::Query::QueryCreatureResponse::Write()
 {
-    _worldPacket << CreatureID;
+    _worldPacket << uint32(CreatureID);
     _worldPacket.WriteBit(Allow);
 
     _worldPacket.FlushBits();
@@ -61,7 +61,16 @@ WorldPacket const* WorldPackets::Query::QueryCreatureResponse::Write()
         _worldPacket << int32(Stats.CreatureFamily);
         _worldPacket << int32(Stats.Classification);
         _worldPacket.append(Stats.ProxyCreatureID.data(), Stats.ProxyCreatureID.size());
-        _worldPacket.append(Stats.CreatureDisplayID.data(), Stats.CreatureDisplayID.size());
+        _worldPacket << uint32(Stats.Display.CreatureDisplay.size());
+        _worldPacket << float(Stats.Display.TotalProbability);
+
+        for (CreatureXDisplay const& display : Stats.Display.CreatureDisplay)
+        {
+            _worldPacket << uint32(display.CreatureDisplayID);
+            _worldPacket << float(display.Scale);
+            _worldPacket << float(display.Probability);
+        }
+
         _worldPacket << float(Stats.HpMulti);
         _worldPacket << float(Stats.EnergyMulti);
         _worldPacket << uint32(Stats.QuestItems.size());
@@ -69,6 +78,7 @@ WorldPacket const* WorldPackets::Query::QueryCreatureResponse::Write()
         _worldPacket << int32(Stats.HealthScalingExpansion);
         _worldPacket << int32(Stats.RequiredExpansion);
         _worldPacket << int32(Stats.VignetteID);
+        _worldPacket << int32(Stats.Class);
 
         if (!Stats.Title.empty())
             _worldPacket << Stats.Title;
@@ -79,8 +89,8 @@ WorldPacket const* WorldPackets::Query::QueryCreatureResponse::Write()
         if (!Stats.CursorName.empty())
             _worldPacket << Stats.CursorName;
 
-        for (int32 questItem : Stats.QuestItems)
-            _worldPacket << questItem;
+        if (!Stats.QuestItems.empty())
+            _worldPacket.append(Stats.QuestItems.data(), Stats.QuestItems.size());
     }
 
     return &_worldPacket;
@@ -162,6 +172,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Query::PlayerGuidLookupDa
     data << lookupData.AccountID;
     data << lookupData.BnetAccountID;
     data << lookupData.GuidActual;
+    data << uint64(lookupData.GuildClubMemberID);
     data << uint32(lookupData.VirtualRealmAddress);
     data << uint8(lookupData.Race);
     data << uint8(lookupData.Sex);
@@ -174,7 +185,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Query::PlayerGuidLookupDa
 
 WorldPacket const* WorldPackets::Query::QueryPlayerNameResponse::Write()
 {
-    _worldPacket << Result;
+    _worldPacket << uint8(Result);
     _worldPacket << Player;
 
     if (Result == RESPONSE_SUCCESS)
@@ -206,7 +217,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Query::QueryPageTextRespo
 
 WorldPacket const* WorldPackets::Query::QueryPageTextResponse::Write()
 {
-    _worldPacket << PageTextID;
+    _worldPacket << uint32(PageTextID);
     _worldPacket.WriteBit(Allow);
 
     _worldPacket.FlushBits();
@@ -229,7 +240,7 @@ void WorldPackets::Query::QueryNPCText::Read()
 
 WorldPacket const* WorldPackets::Query::QueryNPCTextResponse::Write()
 {
-    _worldPacket << TextID;
+    _worldPacket << uint32(TextID);
     _worldPacket.WriteBit(Allow);
 
     _worldPacket.FlushBits();
@@ -238,10 +249,8 @@ WorldPacket const* WorldPackets::Query::QueryNPCTextResponse::Write()
 
     if (Allow)
     {
-        for (uint32 i = 0; i < MAX_NPC_TEXT_OPTIONS; ++i)
-            _worldPacket << Probabilities[i];
-        for (uint32 i = 0; i < MAX_NPC_TEXT_OPTIONS; ++i)
-            _worldPacket << BroadcastTextID[i];
+        _worldPacket.append(Probabilities.data(), Probabilities.size());
+        _worldPacket.append(BroadcastTextID.data(), BroadcastTextID.size());
     }
 
     return &_worldPacket;
@@ -276,8 +285,8 @@ WorldPacket const* WorldPackets::Query::QueryGameObjectResponse::Write()
 
         statsData << float(Stats.Size);
         statsData << uint8(Stats.QuestItems.size());
-        for (int32 questItem : Stats.QuestItems)
-            statsData << int32(questItem);
+        if (!Stats.QuestItems.empty())
+            statsData.append(Stats.QuestItems.data(), Stats.QuestItems.size());
 
         statsData << int32(Stats.RequiredLevel);
     }
@@ -334,7 +343,7 @@ void WorldPackets::Query::QuestPOIQuery::Read()
 {
     _worldPacket >> MissingQuestCount;
 
-    for (uint8 i = 0; i < 50; ++i)
+    for (std::size_t i = 0; i < MissingQuestPOIs.size(); ++i)
         _worldPacket >> MissingQuestPOIs[i];
 }
 
@@ -356,13 +365,12 @@ WorldPacket const* WorldPackets::Query::QuestPOIQueryResponse::Write()
             _worldPacket << int32(questPOIBlobData.QuestObjectiveID);
             _worldPacket << int32(questPOIBlobData.QuestObjectID);
             _worldPacket << int32(questPOIBlobData.MapID);
-            _worldPacket << int32(questPOIBlobData.WorldMapAreaID);
-            _worldPacket << int32(questPOIBlobData.Floor);
+            _worldPacket << int32(questPOIBlobData.UiMapID);
             _worldPacket << int32(questPOIBlobData.Priority);
             _worldPacket << int32(questPOIBlobData.Flags);
             _worldPacket << int32(questPOIBlobData.WorldEffectID);
             _worldPacket << int32(questPOIBlobData.PlayerConditionID);
-            _worldPacket << int32(questPOIBlobData.UnkWoD1);
+            _worldPacket << int32(questPOIBlobData.SpawnTrackingID);
             _worldPacket << int32(questPOIBlobData.QuestPOIBlobPointStats.size());
 
             for (QuestPOIBlobPoint const& questPOIBlobPoint : questPOIBlobData.QuestPOIBlobPointStats)
@@ -381,13 +389,9 @@ WorldPacket const* WorldPackets::Query::QuestPOIQueryResponse::Write()
 
 void WorldPackets::Query::QueryQuestCompletionNPCs::Read()
 {
-    uint32 questCount = 0;
-
-    _worldPacket >> questCount;
-    QuestCompletionNPCs.resize(questCount);
-
-    for (int32& QuestID : QuestCompletionNPCs)
-        _worldPacket >> QuestID;
+    QuestCompletionNPCs.resize(_worldPacket.read<uint32>());
+    if (!QuestCompletionNPCs.empty())
+        _worldPacket.read(QuestCompletionNPCs.data(), QuestCompletionNPCs.size());
 }
 
 WorldPacket const* WorldPackets::Query::QuestCompletionNPCResponse::Write()
@@ -396,10 +400,9 @@ WorldPacket const* WorldPackets::Query::QuestCompletionNPCResponse::Write()
     for (auto& quest : QuestCompletionNPCs)
     {
         _worldPacket << int32(quest.QuestID);
-
         _worldPacket << uint32(quest.NPCs.size());
-        for (int32 const& npc : quest.NPCs)
-            _worldPacket << int32(npc);
+        if (!quest.NPCs.empty())
+            _worldPacket.append(quest.NPCs.data(), quest.NPCs.size());
     }
 
     return &_worldPacket;
@@ -453,6 +456,7 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Query::ItemTextCache cons
 WorldPacket const* WorldPackets::Query::QueryItemTextResponse::Write()
 {
     _worldPacket.WriteBit(Valid);
+    _worldPacket.FlushBits();
     _worldPacket << Item;
     _worldPacket << Id;
 
diff --git a/src/server/game/Server/Packets/QueryPackets.h b/src/server/game/Server/Packets/QueryPackets.h
index 7639f165dae..dfdf3d437a0 100644
--- a/src/server/game/Server/Packets/QueryPackets.h
+++ b/src/server/game/Server/Packets/QueryPackets.h
@@ -23,6 +23,7 @@
 #include "NPCHandler.h"
 #include "ObjectGuid.h"
 #include "Position.h"
+#include "QuestDef.h"
 #include "SharedDefines.h"
 #include "UnitDefines.h"
 #include <array>
@@ -43,13 +44,25 @@ namespace WorldPackets
             uint32 CreatureID = 0;
         };
 
+        struct CreatureXDisplay
+        {
+            uint32 CreatureDisplayID = 0;
+            float Scale = 1.0f;
+            float Probability = 1.0f;
+        };
+
+        struct CreatureDisplayStats
+        {
+            float TotalProbability = 0.0f;
+            std::vector<CreatureXDisplay> CreatureDisplay;
+        };
+
         struct CreatureStats
         {
             CreatureStats()
             {
                 Flags.fill(0);
                 ProxyCreatureID.fill(0);
-                CreatureDisplayID.fill(0);
             }
 
             std::string Title;
@@ -58,6 +71,7 @@ namespace WorldPackets
             int32 CreatureType = 0;
             int32 CreatureFamily = 0;
             int32 Classification = 0;
+            CreatureDisplayStats Display;
             float HpMulti = 0.0f;
             float EnergyMulti = 0.0f;
             bool Leader = false;
@@ -66,9 +80,9 @@ namespace WorldPackets
             int32 HealthScalingExpansion = 0;
             uint32 RequiredExpansion = 0;
             uint32 VignetteID = 0;
+            int32 Class = 0;
             std::array<uint32, 2> Flags;
             std::array<uint32, 2> ProxyCreatureID;
-            std::array<uint32, 4> CreatureDisplayID;
             std::array<std::string, 4> Name;
             std::array<std::string, 4> NameAlt;
         };
@@ -110,6 +124,7 @@ namespace WorldPackets
             ObjectGuid BnetAccountID;
             ObjectGuid GuidActual;
             std::string Name;
+            uint64 GuildClubMemberID = 0;   // same as bgs.protocol.club.v1.MemberId.unique_id
             uint32 VirtualRealmAddress = 0;
             uint8 Race = RACE_NONE;
             uint8 Sex = GENDER_NONE;
@@ -182,8 +197,8 @@ namespace WorldPackets
 
             uint32 TextID = 0;
             bool Allow = false;
-            float Probabilities[MAX_NPC_TEXT_OPTIONS];
-            uint32 BroadcastTextID[MAX_NPC_TEXT_OPTIONS];
+            std::array<float, MAX_NPC_TEXT_OPTIONS> Probabilities;
+            std::array<uint32, MAX_NPC_TEXT_OPTIONS> BroadcastTextID;
         };
 
         class QueryGameObject final : public ClientPacket
@@ -297,7 +312,7 @@ namespace WorldPackets
             void Read() override;
 
             int32 MissingQuestCount = 0;
-            int32 MissingQuestPOIs[50];
+            std::array<int32, 100> MissingQuestPOIs;
         };
 
         struct QuestPOIBlobPoint
@@ -313,13 +328,12 @@ namespace WorldPackets
             int32 QuestObjectiveID = 0;
             int32 QuestObjectID = 0;
             int32 MapID = 0;
-            int32 WorldMapAreaID = 0;
-            int32 Floor = 0;
+            int32 UiMapID = 0;
             int32 Priority = 0;
             int32 Flags = 0;
             int32 WorldEffectID = 0;
             int32 PlayerConditionID = 0;
-            int32 UnkWoD1 = 0;
+            int32 SpawnTrackingID = 0;
             std::vector<QuestPOIBlobPoint> QuestPOIBlobPointStats;
             bool AlwaysAllowMergingBlobs = false;
         };
@@ -347,7 +361,7 @@ namespace WorldPackets
 
             void Read() override;
 
-            std::vector<int32> QuestCompletionNPCs;
+            Array<int32, 100> QuestCompletionNPCs;
         };
 
         struct QuestCompletionNPC
diff --git a/src/server/game/Server/Packets/QuestPackets.cpp b/src/server/game/Server/Packets/QuestPackets.cpp
index 20a6539ae1d..0468e170d7c 100644
--- a/src/server/game/Server/Packets/QuestPackets.cpp
+++ b/src/server/game/Server/Packets/QuestPackets.cpp
@@ -65,6 +65,7 @@ WorldPacket const* WorldPackets::Quest::QueryQuestInfoResponse::Write()
         _worldPacket << int32(Info.QuestID);
         _worldPacket << int32(Info.QuestType);
         _worldPacket << int32(Info.QuestLevel);
+        _worldPacket << int32(Info.QuestScalingFactionGroup);
         _worldPacket << int32(Info.QuestMaxScalingLevel);
         _worldPacket << int32(Info.QuestPackageID);
         _worldPacket << int32(Info.QuestMinLevel);
@@ -88,6 +89,7 @@ WorldPacket const* WorldPackets::Quest::QueryQuestInfoResponse::Write()
         _worldPacket << int32(Info.StartItem);
         _worldPacket << uint32(Info.Flags);
         _worldPacket << uint32(Info.FlagsEx);
+        _worldPacket << uint32(Info.FlagsEx2);
 
         for (uint32 i = 0; i < QUEST_REWARD_ITEM_COUNT; ++i)
         {
@@ -115,6 +117,7 @@ WorldPacket const* WorldPackets::Quest::QueryQuestInfoResponse::Write()
         _worldPacket << int32(Info.RewardNumSkillUps);
 
         _worldPacket << int32(Info.PortraitGiver);
+        _worldPacket << int32(Info.PortraitGiverMount);
         _worldPacket << int32(Info.PortraitTurnIn);
 
         for (uint32 i = 0; i < QUEST_REWARD_REPUTATIONS_COUNT; ++i)
@@ -141,7 +144,7 @@ WorldPacket const* WorldPackets::Quest::QueryQuestInfoResponse::Write()
 
         _worldPacket << uint32(Info.Objectives.size());
         _worldPacket << uint64(Info.AllowableRaces);
-        _worldPacket << int32(Info.QuestRewardID);
+        _worldPacket << int32(Info.TreasurePickerID);
         _worldPacket << int32(Info.Expansion);
 
         _worldPacket.WriteBits(Info.LogTitle.size(), 9);
@@ -222,13 +225,6 @@ WorldPacket const* WorldPackets::Quest::QuestUpdateAddPvPCredit::Write()
 ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Quest::QuestRewards const& questRewards)
 {
     data << int32(questRewards.ChoiceItemCount);
-
-    for (uint32 i = 0; i < QUEST_REWARD_CHOICES_COUNT; ++i)
-    {
-        data << int32(questRewards.ChoiceItems[i].ItemID);
-        data << int32(questRewards.ChoiceItems[i].Quantity);
-    }
-
     data << int32(questRewards.ItemCount);
 
     for (uint32 i = 0; i < QUEST_REWARD_ITEM_COUNT; ++i)
@@ -266,7 +262,13 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Quest::QuestRewards const
 
     data << int32(questRewards.SkillLineID);
     data << int32(questRewards.NumSkillUps);
-    data << int32(questRewards.RewardID);
+    data << int32(questRewards.TreasurePickerID);
+
+    for (uint32 i = 0; i < QUEST_REWARD_CHOICES_COUNT; ++i)
+    {
+        data << questRewards.ChoiceItems[i].Item;
+        data << int32(questRewards.ChoiceItems[i].Quantity);
+    }
 
     data.WriteBit(questRewards.IsBoostSpell);
     data.FlushBits();
@@ -302,6 +304,7 @@ WorldPacket const* WorldPackets::Quest::QuestGiverOfferRewardMessage::Write()
     _worldPacket << QuestData; // WorldPackets::Quest::QuestGiverOfferReward
     _worldPacket << int32(QuestPackageID);
     _worldPacket << int32(PortraitGiver);
+    _worldPacket << int32(PortraitGiverMount);
     _worldPacket << int32(PortraitTurnIn);
 
     _worldPacket.WriteBits(QuestTitle.size(), 9);
@@ -360,6 +363,7 @@ WorldPacket const* WorldPackets::Quest::QuestGiverQuestDetails::Write()
     _worldPacket << int32(QuestID);
     _worldPacket << int32(QuestPackageID);
     _worldPacket << int32(PortraitGiver);
+    _worldPacket << int32(PortraitGiverMount);
     _worldPacket << int32(PortraitTurnIn);
     _worldPacket << uint32(QuestFlags[0]); // Flags
     _worldPacket << uint32(QuestFlags[1]); // FlagsEx
@@ -643,6 +647,9 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Quest::PlayerChoiceRespon
 {
     data << int32(playerChoiceResponse.ResponseID);
     data << int32(playerChoiceResponse.ChoiceArtFileID);
+    data << int32(playerChoiceResponse.Flags);
+    data << uint32(playerChoiceResponse.WidgetSetID);
+    data << uint8(playerChoiceResponse.GroupID);
 
     data.WriteBits(playerChoiceResponse.Answer.length(), 9);
     data.WriteBits(playerChoiceResponse.Header.length(), 9);
@@ -670,6 +677,7 @@ WorldPacket const* WorldPackets::Quest::DisplayPlayerChoice::Write()
     _worldPacket.WriteBits(Question.length(), 8);
     _worldPacket.WriteBit(CloseChoiceFrame);
     _worldPacket.WriteBit(HideWarboardHeader);
+    _worldPacket.WriteBit(KeepOpenAfterChoice);
     _worldPacket.FlushBits();
 
     for (PlayerChoiceResponse const& response : Responses)
diff --git a/src/server/game/Server/Packets/QuestPackets.h b/src/server/game/Server/Packets/QuestPackets.h
index 1dd40e1ccc2..1315a57949c 100644
--- a/src/server/game/Server/Packets/QuestPackets.h
+++ b/src/server/game/Server/Packets/QuestPackets.h
@@ -109,6 +109,7 @@ namespace WorldPackets
             int32 QuestID                   = 0;
             int32 QuestType                 = 0; // Accepted values: 0, 1 or 2. 0 == IsAutoComplete() (skip objectives/details)
             int32 QuestLevel                = 0; // may be -1, static data, in other cases must be used dynamic level: Player::GetQuestLevel (0 is not known, but assuming this is no longer valid for quest intended for client)
+            int32 QuestScalingFactionGroup  = 0;
             int32 QuestMaxScalingLevel      = 255;
             int32 QuestPackageID            = 0;
             int32 QuestMinLevel             = 0;
@@ -132,6 +133,7 @@ namespace WorldPackets
             int32 StartItem                 = 0;
             uint32 Flags                    = 0;
             uint32 FlagsEx                  = 0;
+            uint32 FlagsEx2                 = 0;
             int32 POIContinent              = 0;
             float POIx                      = 0.0f;
             float POIy                      = 0.0f;
@@ -146,6 +148,7 @@ namespace WorldPackets
             int32 RewardSkillLineID         = 0; // reward skill id
             int32 RewardNumSkillUps         = 0; // reward skill points
             int32 PortraitGiver             = 0; // quest giver entry ?
+            int32 PortraitGiverMount        = 0;
             int32 PortraitTurnIn            = 0; // quest turn in entry ?
             std::string PortraitGiverText;
             std::string PortraitGiverName;
@@ -157,7 +160,7 @@ namespace WorldPackets
             int32 CompleteSoundKitID        = 0;
             int32 AreaGroupID               = 0;
             int32 TimeAllowed               = 0;
-            int32 QuestRewardID             = 0;
+            int32 TreasurePickerID          = 0;
             int32 Expansion                 = 0;
             std::vector<QuestObjective> Objectives;
             int32 RewardItems[QUEST_REWARD_ITEM_COUNT] = { };
@@ -225,7 +228,7 @@ namespace WorldPackets
 
         struct QuestChoiceItem
         {
-            int32 ItemID    = 0;
+            Item::ItemInstance Item;
             int32 Quantity  = 0;
         };
 
@@ -244,7 +247,7 @@ namespace WorldPackets
             int32 SpellCompletionID         = 0;
             int32 SkillLineID               = 0;
             int32 NumSkillUps               = 0;
-            int32 RewardID                  = 0;
+            int32 TreasurePickerID          = 0;
             QuestChoiceItem ChoiceItems[QUEST_REWARD_CHOICES_COUNT];
             int32 ItemID[QUEST_REWARD_ITEM_COUNT] = { };
             int32 ItemQty[QUEST_REWARD_ITEM_COUNT] = { };
@@ -285,6 +288,7 @@ namespace WorldPackets
 
             int32 PortraitTurnIn = 0;
             int32 PortraitGiver = 0;
+            int32 PortraitGiverMount = 0;
             std::string QuestTitle;
             std::string RewardText;
             std::string PortraitGiverText;
@@ -365,6 +369,7 @@ namespace WorldPackets
             std::vector<int32> LearnSpells;
             int32 PortraitTurnIn = 0;
             int32 PortraitGiver = 0;
+            int32 PortraitGiverMount = 0;
             int32 QuestStartItemID = 0;
             std::string PortraitGiverText;
             std::string PortraitGiverName;
@@ -663,6 +668,9 @@ namespace WorldPackets
         {
             int32 ResponseID = 0;
             int32 ChoiceArtFileID = 0;
+            int32 Flags = 0;
+            uint32 WidgetSetID = 0;
+            uint8 GroupID = 0;
             std::string Answer;
             std::string Header;
             std::string Description;
@@ -684,6 +692,7 @@ namespace WorldPackets
             std::vector<PlayerChoiceResponse> Responses;
             bool CloseChoiceFrame = false;
             bool HideWarboardHeader = false;
+            bool KeepOpenAfterChoice = false;
         };
 
         class ChoiceResponse final : public ClientPacket
diff --git a/src/server/game/Server/Packets/ReputationPackets.cpp b/src/server/game/Server/Packets/ReputationPackets.cpp
index 314dac85c5e..5e4eb54a918 100644
--- a/src/server/game/Server/Packets/ReputationPackets.cpp
+++ b/src/server/game/Server/Packets/ReputationPackets.cpp
@@ -46,8 +46,6 @@ WorldPacket const* WorldPackets::Reputation::SetForcedReactions::Write()
     for (ForcedReaction const& reaction : Reactions)
         _worldPacket << reaction;
 
-    _worldPacket.FlushBits();
-
     return &_worldPacket;
 }
 
diff --git a/src/server/game/Server/Packets/ReputationPackets.h b/src/server/game/Server/Packets/ReputationPackets.h
index 0156d504491..2046e169ab5 100644
--- a/src/server/game/Server/Packets/ReputationPackets.h
+++ b/src/server/game/Server/Packets/ReputationPackets.h
@@ -30,7 +30,7 @@ namespace WorldPackets
         class InitializeFactions final : public ServerPacket
         {
         public:
-            InitializeFactions() : ServerPacket(SMSG_INITIALIZE_FACTIONS, 1312)
+            InitializeFactions() : ServerPacket(SMSG_INITIALIZE_FACTIONS, FactionCount * (4 + 1) + FactionCount / 8)
             {
                 FactionStandings.fill(0);
                 FactionHasBonus.fill(false);
diff --git a/src/server/game/Server/Packets/ScenarioPackets.cpp b/src/server/game/Server/Packets/ScenarioPackets.cpp
index 38a667980a1..73f5120ee8d 100644
--- a/src/server/game/Server/Packets/ScenarioPackets.cpp
+++ b/src/server/game/Server/Packets/ScenarioPackets.cpp
@@ -109,8 +109,7 @@ WorldPacket const* WorldPackets::Scenario::ScenarioPOIs::Write()
         {
             _worldPacket << int32(scenarioPOI.BlobIndex);
             _worldPacket << int32(scenarioPOI.MapID);
-            _worldPacket << int32(scenarioPOI.WorldMapAreaID);
-            _worldPacket << int32(scenarioPOI.Floor);
+            _worldPacket << int32(scenarioPOI.UiMapID);
             _worldPacket << int32(scenarioPOI.Priority);
             _worldPacket << int32(scenarioPOI.Flags);
             _worldPacket << int32(scenarioPOI.WorldEffectID);
diff --git a/src/server/game/Server/Packets/ScenarioPackets.h b/src/server/game/Server/Packets/ScenarioPackets.h
index c9e1004d51a..71bcbd12d65 100644
--- a/src/server/game/Server/Packets/ScenarioPackets.h
+++ b/src/server/game/Server/Packets/ScenarioPackets.h
@@ -22,7 +22,7 @@
 #include "PacketUtilities.h"
 #include "AchievementPackets.h"
 
-#define MAX_ALLOWED_SCENARIO_POI_QUERY_SIZE 40
+#define MAX_ALLOWED_SCENARIO_POI_QUERY_SIZE 42
 
 struct ScenarioPOI;
 
diff --git a/src/server/game/Server/Packets/SpellPackets.cpp b/src/server/game/Server/Packets/SpellPackets.cpp
index ec6d57f2748..7b3117156fc 100644
--- a/src/server/game/Server/Packets/SpellPackets.cpp
+++ b/src/server/game/Server/Packets/SpellPackets.cpp
@@ -33,6 +33,7 @@ void WorldPackets::Spells::PetCancelAura::Read()
 void WorldPackets::Spells::CancelChannelling::Read()
 {
     _worldPacket >> ChannelSpell;
+    _worldPacket >> Reason;
 }
 
 WorldPacket const* WorldPackets::Spells::CategoryCooldown::Write()
@@ -99,16 +100,17 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::AuraDataInfo cons
     data << uint32(auraData.ActiveFlags);
     data << uint16(auraData.CastLevel);
     data << uint8(auraData.Applications);
+    data << int32(auraData.ContentTuningID);
     data.WriteBit(auraData.CastUnit.is_initialized());
     data.WriteBit(auraData.Duration.is_initialized());
     data.WriteBit(auraData.Remaining.is_initialized());
     data.WriteBit(auraData.TimeMod.is_initialized());
     data.WriteBits(auraData.Points.size(), 6);
     data.WriteBits(auraData.EstimatedPoints.size(), 6);
-    data.WriteBit(auraData.SandboxScaling.is_initialized());
+    data.WriteBit(auraData.ContentTuning.is_initialized());
 
-    if (auraData.SandboxScaling)
-        data << *auraData.SandboxScaling;
+    if (auraData.ContentTuning)
+        data << *auraData.ContentTuning;
 
     if (auraData.CastUnit)
         data << *auraData.CastUnit;
@@ -211,7 +213,7 @@ ByteBuffer& operator>>(ByteBuffer& buffer, WorldPackets::Spells::SpellCastReques
     buffer >> request.SpellID;
     buffer >> request.SpellXSpellVisualID;
     buffer >> request.MissileTrajectory;
-    buffer >> request.Charmer;
+    buffer >> request.CraftingNPC;
     request.SendCastFlags = buffer.ReadBits(5);
     bool hasMoveUpdate = buffer.ReadBit();
     request.Weight.resize(buffer.ReadBits(2));
@@ -366,13 +368,13 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Spells::SpellCastData con
     data << int32(spellCastData.SpellID);
     data << uint32(spellCastData.SpellXSpellVisualID);
     data << uint32(spellCastData.CastFlags);
+    data << uint32(spellCastData.CastFlagsEx);
     data << uint32(spellCastData.CastTime);
     data << spellCastData.MissileTrajectory;
     data << int32(spellCastData.Ammo.DisplayID);
     data << uint8(spellCastData.DestLocSpellCastIndex);
     data << spellCastData.Immunities;
     data << spellCastData.Predict;
-    data.WriteBits(spellCastData.CastFlagsEx, 23);
     data.WriteBits(spellCastData.HitTargets.size(), 16);
     data.WriteBits(spellCastData.MissTargets.size(), 16);
     data.WriteBits(spellCastData.MissStatus.size(), 16);
@@ -716,6 +718,7 @@ WorldPacket const* WorldPackets::Spells::PlayOrphanSpellVisual::Write()
     _worldPacket << int32(SpellVisualID);
     _worldPacket << float(TravelSpeed);
     _worldPacket << float(UnkZero);
+    _worldPacket << float(Unk801);
     _worldPacket.WriteBit(SpeedAsTime);
     _worldPacket.FlushBits();
 
@@ -726,12 +729,14 @@ WorldPacket const* WorldPackets::Spells::PlaySpellVisual::Write()
 {
     _worldPacket << Source;
     _worldPacket << Target;
+    _worldPacket << Unk801_1;
     _worldPacket << TargetPosition;
-    _worldPacket << SpellVisualID;
-    _worldPacket << TravelSpeed;
-    _worldPacket << MissReason;
-    _worldPacket << ReflectStatus;
-    _worldPacket << Orientation;
+    _worldPacket << uint32(SpellVisualID);
+    _worldPacket << float(TravelSpeed);
+    _worldPacket << uint16(MissReason);
+    _worldPacket << uint16(ReflectStatus);
+    _worldPacket << float(Orientation);
+    _worldPacket << float(Unk801_2);
     _worldPacket.WriteBit(SpeedAsTime);
     _worldPacket.FlushBits();
 
diff --git a/src/server/game/Server/Packets/SpellPackets.h b/src/server/game/Server/Packets/SpellPackets.h
index b1230459627..1df8e8772c0 100644
--- a/src/server/game/Server/Packets/SpellPackets.h
+++ b/src/server/game/Server/Packets/SpellPackets.h
@@ -57,6 +57,8 @@ namespace WorldPackets
             void Read() override;
 
             int32 ChannelSpell = 0;
+            int32 Reason = 0;       // 40 = /run SpellStopCasting(), 16 = movement/AURA_INTERRUPT_FLAG_MOVE, 41 = turning/AURA_INTERRUPT_FLAG_TURNING
+                                    // does not match SpellCastResult enum
         };
 
         class CancelGrowthAura final : public ClientPacket
@@ -177,7 +179,8 @@ namespace WorldPackets
             uint32 ActiveFlags = 0;
             uint16 CastLevel = 1;
             uint8 Applications = 1;
-            Optional<SandboxScalingData> SandboxScaling;
+            int32 ContentTuningID = 0;
+            Optional<ContentTuningParams> ContentTuning;
             Optional<ObjectGuid> CastUnit;
             Optional<int32> Duration;
             Optional<int32> Remaining;
@@ -245,7 +248,7 @@ namespace WorldPackets
             MissileTrajectoryRequest MissileTrajectory;
             Optional<MovementInfo> MoveUpdate;
             std::vector<SpellWeight> Weight;
-            ObjectGuid Charmer;
+            ObjectGuid CraftingNPC;
             int32 Misc[2] = { };
         };
 
@@ -613,7 +616,7 @@ namespace WorldPackets
         class SetSpellCharges final : public ServerPacket
         {
         public:
-            SetSpellCharges() : ServerPacket(SMSG_SET_SPELL_CHARGES, 1 + 4 + 4) { }
+            SetSpellCharges() : ServerPacket(SMSG_SET_SPELL_CHARGES, 4 + 4 + 1 + 4 + 1) { }
 
             WorldPacket const* Write() override;
 
@@ -697,6 +700,7 @@ namespace WorldPackets
             bool SpeedAsTime = false;
             float TravelSpeed = 0.0f;
             float UnkZero = 0.0f; // Always zero
+            float Unk801 = 0.0f;
             TaggedPosition<Position::XYZ> SourceRotation; // Vector of rotations, Orientation is z
             TaggedPosition<Position::XYZ> TargetLocation; // Exclusive with Target
         };
@@ -710,6 +714,7 @@ namespace WorldPackets
 
             ObjectGuid Source;
             ObjectGuid Target; // Exclusive with TargetPosition
+            ObjectGuid Unk801_1;
             uint16 MissReason = 0;
             uint32 SpellVisualID = 0;
             bool SpeedAsTime = false;
@@ -717,6 +722,7 @@ namespace WorldPackets
             float TravelSpeed = 0.0f;
             TaggedPosition<Position::XYZ> TargetPosition; // Exclusive with Target
             float Orientation = 0.0f;
+            float Unk801_2 = 0.0f;
         };
 
         class PlaySpellVisualKit final : public ServerPacket
diff --git a/src/server/game/Server/Packets/SystemPackets.cpp b/src/server/game/Server/Packets/SystemPackets.cpp
index da674178456..853e35fce5c 100644
--- a/src/server/game/Server/Packets/SystemPackets.cpp
+++ b/src/server/game/Server/Packets/SystemPackets.cpp
@@ -37,6 +37,8 @@ WorldPacket const* WorldPackets::System::FeatureSystemStatus::Write()
 
     _worldPacket << uint32(BpayStoreProductDeliveryDelay);
 
+    _worldPacket << uint32(ClubsPresenceUpdateTimer);
+
     _worldPacket.WriteBit(VoiceEnabled);
     _worldPacket.WriteBit(EuropaTicketSystemStatus.is_initialized());
     _worldPacket.WriteBit(ScrollOfResurrectionEnabled);
@@ -49,16 +51,22 @@ WorldPacket const* WorldPackets::System::FeatureSystemStatus::Write()
     _worldPacket.WriteBit(RecruitAFriendSendingEnabled);
     _worldPacket.WriteBit(CharUndeleteEnabled);
     _worldPacket.WriteBit(RestrictedAccount);
+    _worldPacket.WriteBit(CommerceSystemEnabled);
     _worldPacket.WriteBit(TutorialsEnabled);
     _worldPacket.WriteBit(NPETutorialsEnabled);
     _worldPacket.WriteBit(TwitterEnabled);
-    _worldPacket.WriteBit(CommerceSystemEnabled);
     _worldPacket.WriteBit(Unk67);
     _worldPacket.WriteBit(WillKickFromWorld);
     _worldPacket.WriteBit(KioskModeEnabled);
     _worldPacket.WriteBit(CompetitiveModeEnabled);
     _worldPacket.WriteBit(RaceClassExpansionLevels.is_initialized());
     _worldPacket.WriteBit(TokenBalanceEnabled);
+    _worldPacket.WriteBit(WarModeFeatureEnabled);
+    _worldPacket.WriteBit(ClubsEnabled);
+    _worldPacket.WriteBit(ClubsBattleNetClubTypeAllowed);
+    _worldPacket.WriteBit(ClubsCharacterClubTypeAllowed);
+    _worldPacket.WriteBit(VoiceChatDisabledByParentalControl);
+    _worldPacket.WriteBit(VoiceChatMutedByParentalControl);
 
     _worldPacket.FlushBits();
 
@@ -102,6 +110,12 @@ WorldPacket const* WorldPackets::System::FeatureSystemStatus::Write()
             _worldPacket.append(RaceClassExpansionLevels->data(), RaceClassExpansionLevels->size());
     }
 
+    {
+        _worldPacket.WriteBit(VoiceChatManagerSettings.Enabled);
+        _worldPacket << VoiceChatManagerSettings.BnetAccountGuid;
+        _worldPacket << VoiceChatManagerSettings.GuildGuid;
+    }
+
     if (EuropaTicketSystemStatus)
     {
         _worldPacket.WriteBit(EuropaTicketSystemStatus->TicketsEnabled);
@@ -141,7 +155,12 @@ WorldPacket const* WorldPackets::System::FeatureSystemStatusGlueScreen::Write()
     _worldPacket << int32(TokenPollTimeSeconds);
     _worldPacket << int32(TokenRedeemIndex);
     _worldPacket << int64(TokenBalanceAmount);
+    _worldPacket << int32(MaxCharactersPerRealm);
     _worldPacket << uint32(BpayStoreProductDeliveryDelay);
+    _worldPacket << int32(ActiveCharacterUpgradeBoostType);
+    _worldPacket << int32(ActiveClassTrialBoostType);
+    _worldPacket << int32(MinimumExpansionLevel);
+    _worldPacket << int32(MaximumExpansionLevel);
 
     return &_worldPacket;
 }
diff --git a/src/server/game/Server/Packets/SystemPackets.h b/src/server/game/Server/Packets/SystemPackets.h
index 74d40bf4e05..4d0812e7e67 100644
--- a/src/server/game/Server/Packets/SystemPackets.h
+++ b/src/server/game/Server/Packets/SystemPackets.h
@@ -80,6 +80,13 @@ namespace WorldPackets
                 float ThrottleDfBestPriority = 0.0f;
             };
 
+            struct VoiceChatProxySettings
+            {
+                bool Enabled = false;
+                ObjectGuid BnetAccountGuid;
+                ObjectGuid GuildGuid;
+            };
+
             FeatureSystemStatus() : ServerPacket(SMSG_FEATURE_SYSTEM_STATUS, 48) { }
 
             WorldPacket const* Write() override;
@@ -103,6 +110,7 @@ namespace WorldPackets
             uint32 TokenRedeemIndex                      = 0;
             int64 TokenBalanceAmount                     = 0;
             uint32 BpayStoreProductDeliveryDelay         = 0;
+            uint32 ClubsPresenceUpdateTimer              = 0;
             bool ItemRestorationButtonEnabled        = false;
             bool CharUndeleteEnabled                 = false; ///< Implemented
             bool BpayStoreDisabledByParentalControls = false;
@@ -110,16 +118,22 @@ namespace WorldPackets
             bool CommerceSystemEnabled               = false;
             bool Unk67                               = false;
             bool WillKickFromWorld                   = false;
-
             bool RestrictedAccount                   = false;
             bool TutorialsEnabled                    = false;
             bool NPETutorialsEnabled                 = false;
             bool KioskModeEnabled                    = false;
             bool CompetitiveModeEnabled              = false;
             bool TokenBalanceEnabled                 = false;
+            bool WarModeFeatureEnabled               = false;
+            bool ClubsEnabled                        = false;
+            bool ClubsBattleNetClubTypeAllowed       = false;
+            bool ClubsCharacterClubTypeAllowed       = false;
+            bool VoiceChatDisabledByParentalControl  = false;
+            bool VoiceChatMutedByParentalControl     = false;
 
             Optional<std::vector<uint8>> RaceClassExpansionLevels;
             SocialQueueConfig QuickJoinConfig;
+            VoiceChatProxySettings VoiceChatManagerSettings;
         };
 
         class FeatureSystemStatusGlueScreen final : public ServerPacket
@@ -147,7 +161,12 @@ namespace WorldPackets
             int32 TokenPollTimeSeconds               = 0;     // NYI
             int32 TokenRedeemIndex                   = 0;     // NYI
             int64 TokenBalanceAmount                 = 0;     // NYI
+            int32 MaxCharactersPerRealm              = 0;
             uint32 BpayStoreProductDeliveryDelay     = 0;     // NYI
+            int32 ActiveCharacterUpgradeBoostType    = 0;     // NYI
+            int32 ActiveClassTrialBoostType          = 0;     // NYI
+            int32 MinimumExpansionLevel              = 0;
+            int32 MaximumExpansionLevel              = 0;
         };
 
         class MOTD final : public ServerPacket
diff --git a/src/server/game/Server/Packets/TalentPackets.cpp b/src/server/game/Server/Packets/TalentPackets.cpp
index c5cbb0769a5..3344ef292fc 100644
--- a/src/server/game/Server/Packets/TalentPackets.cpp
+++ b/src/server/game/Server/Packets/TalentPackets.cpp
@@ -17,6 +17,20 @@
 
 #include "TalentPackets.h"
 
+ByteBuffer& operator>>(ByteBuffer& data, WorldPackets::Talent::PvPTalent& pvpTalent)
+{
+    data >> pvpTalent.PvPTalentID;
+    data >> pvpTalent.Slot;
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Talent::PvPTalent const& pvpTalent)
+{
+    data << uint16(pvpTalent.PvPTalentID);
+    data << uint8(pvpTalent.Slot);
+    return data;
+}
+
 WorldPacket const* WorldPackets::Talent::UpdateTalentData::Write()
 {
     _worldPacket << uint8(Info.ActiveGroup);
@@ -27,13 +41,13 @@ WorldPacket const* WorldPackets::Talent::UpdateTalentData::Write()
     {
         _worldPacket << uint32(talentGroupInfo.SpecID);
         _worldPacket << uint32(talentGroupInfo.TalentIDs.size());
-        _worldPacket << uint32(talentGroupInfo.PvPTalentIDs.size());
+        _worldPacket << uint32(talentGroupInfo.PvPTalents.size());
 
-        for (uint16 talentID : talentGroupInfo.TalentIDs)
-            _worldPacket << uint16(talentID);
+        for (uint16 talent : talentGroupInfo.TalentIDs)
+            _worldPacket << uint16(talent);
 
-        for (uint16 talentID : talentGroupInfo.PvPTalentIDs)
-            _worldPacket << uint16(talentID);
+        for (PvPTalent talent : talentGroupInfo.PvPTalents)
+            _worldPacket << talent;
     }
 
     return &_worldPacket;
@@ -92,7 +106,7 @@ WorldPacket const* WorldPackets::Talent::ActiveGlyphs::Write()
 
 void WorldPackets::Talent::LearnPvpTalents::Read()
 {
-    Talents.resize(_worldPacket.ReadBits(6));
+    Talents.resize(_worldPacket.read<uint32>());
     for (uint32 i = 0; i < Talents.size(); ++i)
         _worldPacket >> Talents[i];
 }
@@ -102,8 +116,8 @@ WorldPacket const* WorldPackets::Talent::LearnPvpTalentsFailed::Write()
     _worldPacket.WriteBits(Reason, 4);
     _worldPacket << int32(SpellID);
     _worldPacket << uint32(Talents.size());
-    if (!Talents.empty())
-        _worldPacket.append(Talents.data(), Talents.size());
+    for (PvPTalent pvpTalent : Talents)
+        _worldPacket << pvpTalent;
 
     return &_worldPacket;
 }
diff --git a/src/server/game/Server/Packets/TalentPackets.h b/src/server/game/Server/Packets/TalentPackets.h
index 920f724095e..6cbc8aca057 100644
--- a/src/server/game/Server/Packets/TalentPackets.h
+++ b/src/server/game/Server/Packets/TalentPackets.h
@@ -27,11 +27,17 @@ namespace WorldPackets
 {
     namespace Talent
     {
+        struct PvPTalent
+        {
+            uint16 PvPTalentID = 0;
+            uint8 Slot = 0;
+        };
+
         struct TalentGroupInfo
         {
             uint32 SpecID = 0;
             std::vector<uint16> TalentIDs;
-            std::vector<uint16> PvPTalentIDs;
+            std::vector<PvPTalent> PvPTalents;
         };
 
         struct TalentInfoUpdate
@@ -121,19 +127,19 @@ namespace WorldPackets
 
             void Read() override;
 
-            Array<uint16, 6> Talents;
+            Array<PvPTalent, 4> Talents;
         };
 
         class LearnPvpTalentsFailed final : public ServerPacket
         {
         public:
-            LearnPvpTalentsFailed() : ServerPacket(SMSG_LEARN_PVP_TALENTS_FAILED, 1 + 4 + 4 + 2 * MAX_PVP_TALENT_TIERS) { }
+            LearnPvpTalentsFailed() : ServerPacket(SMSG_LEARN_PVP_TALENTS_FAILED, 1 + 4 + 4 + (2 + 1) * MAX_PVP_TALENT_SLOTS) { }
 
             WorldPacket const* Write() override;
 
             uint32 Reason = 0;
             int32 SpellID = 0;
-            std::vector<uint16> Talents;
+            std::vector<PvPTalent> Talents;
         };
     }
 }
diff --git a/src/server/game/Server/Packets/TaxiPackets.cpp b/src/server/game/Server/Packets/TaxiPackets.cpp
index 9e8e552f363..a39e37425f7 100644
--- a/src/server/game/Server/Packets/TaxiPackets.cpp
+++ b/src/server/game/Server/Packets/TaxiPackets.cpp
@@ -36,8 +36,8 @@ WorldPacket const* WorldPackets::Taxi::ShowTaxiNodes::Write()
     _worldPacket.WriteBit(WindowInfo.is_initialized());
     _worldPacket.FlushBits();
 
-    _worldPacket << uint32(CanLandNodes->size());
-    _worldPacket << uint32(CanUseNodes->size());
+    _worldPacket << uint32(CanLandNodes.size());
+    _worldPacket << uint32(CanUseNodes.size());
 
     if (WindowInfo.is_initialized())
     {
@@ -45,8 +45,8 @@ WorldPacket const* WorldPackets::Taxi::ShowTaxiNodes::Write()
         _worldPacket << uint32(WindowInfo->CurrentNode);
     }
 
-    _worldPacket.append(CanLandNodes->data(), CanLandNodes->size());
-    _worldPacket.append(CanUseNodes->data(), CanUseNodes->size());
+    _worldPacket.append(CanLandNodes.data(), CanLandNodes.size());
+    _worldPacket.append(CanUseNodes.data(), CanUseNodes.size());
 
     return &_worldPacket;
 }
diff --git a/src/server/game/Server/Packets/TaxiPackets.h b/src/server/game/Server/Packets/TaxiPackets.h
index 098ed293fbb..dbf730a8bd9 100644
--- a/src/server/game/Server/Packets/TaxiPackets.h
+++ b/src/server/game/Server/Packets/TaxiPackets.h
@@ -62,8 +62,8 @@ namespace WorldPackets
             WorldPacket const* Write() override;
 
             Optional<ShowTaxiNodesWindowInfo> WindowInfo;
-            TaxiMask const* CanLandNodes = nullptr; // Nodes known by player
-            TaxiMask const* CanUseNodes = nullptr;  // Nodes available for use - this can temporarily disable a known node
+            TaxiMask CanLandNodes; // Nodes known by player
+            TaxiMask CanUseNodes;  // Nodes available for use - this can temporarily disable a known node
         };
 
         class EnableTaxiNode final : public ClientPacket
@@ -110,7 +110,7 @@ namespace WorldPackets
         class ActivateTaxiReply final : public ServerPacket
         {
         public:
-            ActivateTaxiReply() : ServerPacket(SMSG_ACTIVATE_TAXI_REPLY, 4) { }
+            ActivateTaxiReply() : ServerPacket(SMSG_ACTIVATE_TAXI_REPLY, 1) { }
 
             WorldPacket const* Write() override;
 
diff --git a/src/server/game/Server/Packets/TicketPackets.cpp b/src/server/game/Server/Packets/TicketPackets.cpp
index cafb723c062..fe74550c77f 100644
--- a/src/server/game/Server/Packets/TicketPackets.cpp
+++ b/src/server/game/Server/Packets/TicketPackets.cpp
@@ -201,9 +201,17 @@ void WorldPackets::Ticket::SupportTicketSubmitComplaint::Read()
     bool hasGuildInfo = _worldPacket.ReadBit();
     bool hasLFGListSearchResult = _worldPacket.ReadBit();
     bool hasLFGListApplicant = _worldPacket.ReadBit();
+    bool hasClubMessage = _worldPacket.ReadBit();
 
     _worldPacket.ResetBitPos();
 
+    if (hasClubMessage)
+    {
+        CommunityMessage = boost::in_place();
+        CommunityMessage->IsPlayerUsingVoice = _worldPacket.ReadBit();
+        _worldPacket.ResetBitPos();
+    }
+
     if (hasMailInfo)
         _worldPacket >> MailInfo;
 
diff --git a/src/server/game/Server/Packets/TicketPackets.h b/src/server/game/Server/Packets/TicketPackets.h
index 6e25f3da4a9..5e7fc20f2eb 100644
--- a/src/server/game/Server/Packets/TicketPackets.h
+++ b/src/server/game/Server/Packets/TicketPackets.h
@@ -178,6 +178,11 @@ namespace WorldPackets
                 std::string Comment;
             };
 
+            struct SupportTicketCommunityMessage
+            {
+                bool IsPlayerUsingVoice = false;
+            };
+
             SupportTicketSubmitComplaint(WorldPacket&& packet) : ClientPacket(CMSG_SUPPORT_TICKET_SUBMIT_COMPLAINT, std::move(packet)) { }
 
             void Read() override;
@@ -193,7 +198,7 @@ namespace WorldPackets
             Optional<SupportTicketGuildInfo> GuildInfo;
             Optional<SupportTicketLFGListSearchResult> LFGListSearchResult;
             Optional<SupportTicketLFGListApplicant> LFGListApplicant;
-
+            Optional<SupportTicketCommunityMessage> CommunityMessage;
         };
 
         class Complaint final : public ClientPacket
diff --git a/src/server/game/Server/Packets/TotemPackets.cpp b/src/server/game/Server/Packets/TotemPackets.cpp
index 1bd8f1c915e..a7b042ca19a 100644
--- a/src/server/game/Server/Packets/TotemPackets.cpp
+++ b/src/server/game/Server/Packets/TotemPackets.cpp
@@ -25,7 +25,7 @@ void WorldPackets::Totem::TotemDestroyed::Read()
 
 WorldPacket const* WorldPackets::Totem::TotemCreated::Write()
 {
-    _worldPacket << Slot;
+    _worldPacket << uint8(Slot);
     _worldPacket << Totem;
     _worldPacket << int32(Duration);
     _worldPacket << int32(SpellID);
diff --git a/src/server/game/Server/Packets/TotemPackets.h b/src/server/game/Server/Packets/TotemPackets.h
index b438109825c..232b26f1cbb 100644
--- a/src/server/game/Server/Packets/TotemPackets.h
+++ b/src/server/game/Server/Packets/TotemPackets.h
@@ -46,7 +46,7 @@ namespace WorldPackets
             ObjectGuid Totem;
             int32 SpellID = 0;
             int32 Duration = 0;
-            int8 Slot = 0;
+            uint8 Slot = 0;
             float TimeMod = 1.0f;
             bool CannotDismiss = false;
         };
diff --git a/src/server/game/Server/Packets/TransmogrificationPackets.cpp b/src/server/game/Server/Packets/TransmogrificationPackets.cpp
index 7d50891bc3e..da2c3972b12 100644
--- a/src/server/game/Server/Packets/TransmogrificationPackets.cpp
+++ b/src/server/game/Server/Packets/TransmogrificationPackets.cpp
@@ -41,8 +41,8 @@ WorldPacket const* WorldPackets::Transmogrification::TransmogCollectionUpdate::W
     _worldPacket.WriteBit(IsFullUpdate);
     _worldPacket.WriteBit(IsSetFavorite);
     _worldPacket << uint32(FavoriteAppearances.size());
-    for (uint32 itemModifiedAppearanceId : FavoriteAppearances)
-        _worldPacket << uint32(itemModifiedAppearanceId);
+    if (!FavoriteAppearances.empty())
+        _worldPacket.append(FavoriteAppearances.data(), FavoriteAppearances.size());
 
     return &_worldPacket;
 }
diff --git a/src/server/game/Server/Packets/WhoPackets.cpp b/src/server/game/Server/Packets/WhoPackets.cpp
index afc6c3bdd28..9cfbc04e488 100644
--- a/src/server/game/Server/Packets/WhoPackets.cpp
+++ b/src/server/game/Server/Packets/WhoPackets.cpp
@@ -117,8 +117,8 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Who::WhoResponse const& r
     data.WriteBits(response.Entries.size(), 6);
     data.FlushBits();
 
-    for (size_t i = 0; i < response.Entries.size(); ++i)
-        data << response.Entries[i];
+    for (WorldPackets::Who::WhoEntry const& whoEntry : response.Entries)
+        data << whoEntry;
 
     return data;
 }
diff --git a/src/server/game/Server/Packets/WorldStatePackets.cpp b/src/server/game/Server/Packets/WorldStatePackets.cpp
index 0c202978de8..8129e2e8af0 100644
--- a/src/server/game/Server/Packets/WorldStatePackets.cpp
+++ b/src/server/game/Server/Packets/WorldStatePackets.cpp
@@ -24,14 +24,14 @@ WorldPacket const* WorldPackets::WorldState::InitWorldStates::Write()
 {
     _worldPacket.reserve(16 + Worldstates.size() * 8);
 
-    _worldPacket << uint32(MapID);
-    _worldPacket << uint32(AreaID);
-    _worldPacket << uint32(SubareaID);
+    _worldPacket << int32(MapID);
+    _worldPacket << int32(AreaID);
+    _worldPacket << int32(SubareaID);
 
     _worldPacket << uint32(Worldstates.size());
     for (WorldStateInfo const& wsi : Worldstates)
     {
-        _worldPacket << uint32(wsi.VariableID);
+        _worldPacket << int32(wsi.VariableID);
         _worldPacket << int32(wsi.Value);
     }
 
diff --git a/src/server/game/Server/Packets/WorldStatePackets.h b/src/server/game/Server/Packets/WorldStatePackets.h
index ba7aa8fe282..766725fcf66 100644
--- a/src/server/game/Server/Packets/WorldStatePackets.h
+++ b/src/server/game/Server/Packets/WorldStatePackets.h
@@ -29,10 +29,10 @@ namespace WorldPackets
         public:
             struct WorldStateInfo
             {
-                WorldStateInfo(uint32 variableID, int32 value)
+                WorldStateInfo(int32 variableID, int32 value)
                     : VariableID(variableID), Value(value) { }
 
-                uint32 VariableID;
+                int32 VariableID;
                 int32 Value;
             };
 
@@ -40,9 +40,9 @@ namespace WorldPackets
 
             WorldPacket const* Write() override;
 
-            uint32 AreaID    = 0; ///< ZoneId
-            uint32 SubareaID = 0; ///< AreaId
-            uint32 MapID     = 0; ///< MapId
+            int32 AreaID    = 0; ///< ZoneId
+            int32 SubareaID = 0; ///< AreaId
+            int32 MapID     = 0; ///< MapId
 
             std::vector<WorldStateInfo> Worldstates;
         };
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index 448b277aa16..2f75b82ec74 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -156,14 +156,12 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_ADD_TOY,                                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAddToy);
     DEFINE_HANDLER(CMSG_ADVENTURE_JOURNAL_OPEN_QUEST,                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_ADVENTURE_JOURNAL_START_QUEST,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_ADVENTURE_MAP_POI_QUERY,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_ALTER_APPEARANCE,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAlterAppearance);
     DEFINE_HANDLER(CMSG_AREA_SPIRIT_HEALER_QUERY,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAreaSpiritHealerQueryOpcode);
     DEFINE_HANDLER(CMSG_AREA_SPIRIT_HEALER_QUEUE,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAreaSpiritHealerQueueOpcode);
     DEFINE_HANDLER(CMSG_AREA_TRIGGER,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAreaTriggerOpcode);
     DEFINE_HANDLER(CMSG_ARTIFACT_ADD_POWER,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleArtifactAddPower);
-    DEFINE_HANDLER(CMSG_ARTIFACT_ADD_RELIC_TALENT,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
-    DEFINE_HANDLER(CMSG_ARTIFACT_ATTUNE_PREVIEW_RELIC,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
-    DEFINE_HANDLER(CMSG_ARTIFACT_ATTUNE_SOCKETED_RELIC,                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_ARTIFACT_SET_APPEARANCE,                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleArtifactSetAppearance);
     DEFINE_HANDLER(CMSG_ATTACK_STOP,                                        STATUS_LOGGEDIN,  PROCESS_INPLACE,      &WorldSession::HandleAttackStopOpcode);
     DEFINE_HANDLER(CMSG_ATTACK_SWING,                                       STATUS_LOGGEDIN,  PROCESS_INPLACE,      &WorldSession::HandleAttackSwingOpcode);
@@ -185,6 +183,8 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_AUTO_EQUIP_ITEM,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAutoEquipItemOpcode);
     DEFINE_HANDLER(CMSG_AUTO_EQUIP_ITEM_SLOT,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAutoEquipItemSlotOpcode);
     DEFINE_HANDLER(CMSG_AUTO_STORE_BAG_ITEM,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAutoStoreBagItemOpcode);
+    DEFINE_HANDLER(CMSG_AZERITE_EMPOWERED_ITEM_SELECT_POWER,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_AZERITE_EMPOWERED_ITEM_VIEWED,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BANKER_ACTIVATE,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBankerActivateOpcode);
     DEFINE_HANDLER(CMSG_BATTLEFIELD_LEAVE,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBattlefieldLeaveOpcode);
     DEFINE_HANDLER(CMSG_BATTLEFIELD_LIST,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBattlefieldListOpcode);
@@ -198,10 +198,12 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_BATTLENET_REQUEST,                                  STATUS_AUTHED,    PROCESS_THREADUNSAFE, &WorldSession::HandleBattlenetRequest);
     DEFINE_HANDLER(CMSG_BATTLENET_REQUEST_REALM_LIST_TICKET,                STATUS_AUTHED,    PROCESS_THREADUNSAFE, &WorldSession::HandleBattlenetRequestRealmListTicket);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_ACK_FAILED_RESPONSE,                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_BATTLE_PAY_CANCEL_OPEN_CHECKOUT,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_CONFIRM_PURCHASE_RESPONSE,               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_DISTRIBUTION_ASSIGN_TO_TARGET,           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_GET_PRODUCT_LIST,                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_GET_PURCHASE_LIST,                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_BATTLE_PAY_OPEN_CHECKOUT,                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_QUERY_CLASS_TRIAL_BOOST_RESULT,          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_REQUEST_CHARACTER_BOOST_UNREVOKE,        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_REQUEST_CURRENT_VAS_TRANSFER_QUEUES,     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
@@ -211,6 +213,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_BATTLE_PAY_START_VAS_PURCHASE,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_TRIAL_BOOST_CHARACTER,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PAY_VALIDATE_BNET_VAS_TRANSFER,              STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_BATTLE_PAY_VAS_PURCHASE_COMPLETE,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PET_CLEAR_FANFARE,                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BATTLE_PET_DELETE_PET,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBattlePetDeletePet);
     DEFINE_HANDLER(CMSG_BATTLE_PET_DELETE_PET_CHEAT,                        STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
@@ -230,6 +233,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_BLACK_MARKET_BID_ON_ITEM,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBlackMarketBidOnItem);
     DEFINE_HANDLER(CMSG_BLACK_MARKET_OPEN,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBlackMarketOpen);
     DEFINE_HANDLER(CMSG_BLACK_MARKET_REQUEST_ITEMS,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBlackMarketRequestItems);
+    DEFINE_HANDLER(CMSG_BONUS_ROLL,                                         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_BUG_REPORT,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBugReportOpcode);
     DEFINE_HANDLER(CMSG_BUSY_TRADE,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBusyTradeOpcode);
     DEFINE_HANDLER(CMSG_BUY_BACK_ITEM,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleBuybackItem);
@@ -240,6 +244,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_BUY_WOW_TOKEN_START,                                STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CAGE_BATTLE_PET,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCageBattlePet);
     DEFINE_HANDLER(CMSG_CALENDAR_ADD_EVENT,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarAddEvent);
+    DEFINE_HANDLER(CMSG_CALENDAR_COMMUNITY_FILTER,                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarCommunityFilter);
     DEFINE_HANDLER(CMSG_CALENDAR_COMPLAIN,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarComplain);
     DEFINE_HANDLER(CMSG_CALENDAR_COPY_EVENT,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarCopyEvent);
     DEFINE_HANDLER(CMSG_CALENDAR_EVENT_INVITE,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventInvite);
@@ -250,7 +255,6 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_CALENDAR_GET,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGetCalendar);
     DEFINE_HANDLER(CMSG_CALENDAR_GET_EVENT,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGetEvent);
     DEFINE_HANDLER(CMSG_CALENDAR_GET_NUM_PENDING,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGetNumPending);
-    DEFINE_HANDLER(CMSG_CALENDAR_GUILD_FILTER,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGuildFilter);
     DEFINE_HANDLER(CMSG_CALENDAR_REMOVE_EVENT,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarRemoveEvent);
     DEFINE_HANDLER(CMSG_CALENDAR_REMOVE_INVITE,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventRemoveInvite);
     DEFINE_HANDLER(CMSG_CALENDAR_UPDATE_EVENT,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarUpdateEvent);
@@ -271,19 +275,15 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_CHALLENGE_MODE_REQUEST_LEADERS,                     STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHALLENGE_MODE_REQUEST_MAP_STATS,                   STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHANGE_BAG_SLOT_FLAG,                               STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_CHANGE_BANK_BAG_SLOT_FLAG,                          STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHANGE_MONUMENT_APPEARANCE,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHANGE_SUB_GROUP,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChangeSubGroupOpcode);
     DEFINE_HANDLER(CMSG_CHARACTER_RENAME_REQUEST,                           STATUS_AUTHED,    PROCESS_THREADUNSAFE, &WorldSession::HandleCharRenameOpcode);
     DEFINE_HANDLER(CMSG_CHAR_CUSTOMIZE,                                     STATUS_AUTHED,    PROCESS_THREADUNSAFE, &WorldSession::HandleCharCustomizeOpcode);
     DEFINE_HANDLER(CMSG_CHAR_DELETE,                                        STATUS_AUTHED,    PROCESS_THREADUNSAFE, &WorldSession::HandleCharDeleteOpcode);
     DEFINE_HANDLER(CMSG_CHAR_RACE_OR_FACTION_CHANGE,                        STATUS_AUTHED,    PROCESS_THREADUNSAFE, &WorldSession::HandleCharRaceOrFactionChangeOpcode);
-    DEFINE_HANDLER(CMSG_CHAT_ADDON_MESSAGE_CHANNEL,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChatAddonMessageChannelOpcode);
-    DEFINE_HANDLER(CMSG_CHAT_ADDON_MESSAGE_GUILD,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChatAddonMessageOpcode);
-    DEFINE_HANDLER(CMSG_CHAT_ADDON_MESSAGE_INSTANCE_CHAT,                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChatAddonMessageOpcode);
-    DEFINE_HANDLER(CMSG_CHAT_ADDON_MESSAGE_OFFICER,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChatAddonMessageOpcode);
-    DEFINE_HANDLER(CMSG_CHAT_ADDON_MESSAGE_PARTY,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChatAddonMessageOpcode);
-    DEFINE_HANDLER(CMSG_CHAT_ADDON_MESSAGE_RAID,                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChatAddonMessageOpcode);
-    DEFINE_HANDLER(CMSG_CHAT_ADDON_MESSAGE_WHISPER,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChatAddonMessageWhisperOpcode);
+    DEFINE_HANDLER(CMSG_CHAT_ADDON_MESSAGE,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChatAddonMessageOpcode);
+    DEFINE_HANDLER(CMSG_CHAT_ADDON_MESSAGE_TARGETED,                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChatAddonMessageTargetedOpcode);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_ANNOUNCEMENTS,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_BAN,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_DECLINE_INVITE,                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelCommand);
@@ -291,16 +291,13 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_INVITE,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_KICK,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_LIST,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelCommand);
-    DEFINE_HANDLER(CMSG_CHAT_CHANNEL_MODERATE,                              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_MODERATOR,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
-    DEFINE_HANDLER(CMSG_CHAT_CHANNEL_MUTE,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_OWNER,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_PASSWORD,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPassword);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_SET_OWNER,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_SILENCE_ALL,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_UNBAN,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_UNMODERATOR,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
-    DEFINE_HANDLER(CMSG_CHAT_CHANNEL_UNMUTE,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
     DEFINE_HANDLER(CMSG_CHAT_CHANNEL_UNSILENCE_ALL,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleChannelPlayerCommand);
     DEFINE_HANDLER(CMSG_CHAT_JOIN_CHANNEL,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleJoinChannel);
     DEFINE_HANDLER(CMSG_CHAT_LEAVE_CHANNEL,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleLeaveChannel);
@@ -328,6 +325,8 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_CLEAR_TRADE_ITEM,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleClearTradeItemOpcode);
     DEFINE_HANDLER(CMSG_CLIENT_PORT_GRAVEYARD,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandlePortGraveyard);
     DEFINE_HANDLER(CMSG_CLOSE_INTERACTION,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCloseInteraction);
+    DEFINE_HANDLER(CMSG_CLOSE_QUEST_CHOICE,                                 STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_CLUB_INVITE,                                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_COLLECTION_ITEM_SET_FAVORITE,                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleCollectionItemSetFavorite);
     DEFINE_HANDLER(CMSG_COMMENTATOR_ENABLE,                                 STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_COMMENTATOR_ENTER_INSTANCE,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
@@ -380,6 +379,8 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_ENUM_CHARACTERS,                                    STATUS_AUTHED,    PROCESS_THREADUNSAFE, &WorldSession::HandleCharEnumOpcode);
     DEFINE_HANDLER(CMSG_ENUM_CHARACTERS_DELETED_BY_CLIENT,                  STATUS_AUTHED,    PROCESS_THREADUNSAFE, &WorldSession::HandleCharUndeleteEnumOpcode);
     DEFINE_HANDLER(CMSG_FAR_SIGHT,                                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleFarSightOpcode);
+    DEFINE_HANDLER(CMSG_GAME_EVENT_DEBUG_DISABLE,                           STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_GAME_EVENT_DEBUG_ENABLE,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_GAME_OBJ_REPORT_USE,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGameobjectReportUse);
     DEFINE_HANDLER(CMSG_GAME_OBJ_USE,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGameObjectUseOpcode);
     DEFINE_HANDLER(CMSG_GARRISON_ASSIGN_FOLLOWER_TO_BUILDING,               STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
@@ -407,6 +408,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_GARRISON_START_MISSION,                             STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_GARRISON_SWAP_BUILDINGS,                            STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_GENERATE_RANDOM_CHARACTER_NAME,                     STATUS_AUTHED,    PROCESS_THREADUNSAFE, &WorldSession::HandleRandomizeCharNameOpcode);
+    DEFINE_HANDLER(CMSG_GET_ACCOUNT_CHARACTER_LIST,                         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_GET_CHALLENGE_MODE_REWARDS,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_GET_GARRISON_INFO,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGetGarrisonInfo);
     DEFINE_HANDLER(CMSG_GET_ITEM_PURCHASE_DATA,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGetItemPurchaseData);
@@ -431,7 +433,6 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_GUILD_BANK_QUERY_TAB,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankQueryTab);
     DEFINE_HANDLER(CMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY_QUERY,          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankMoneyWithdrawn);
     DEFINE_HANDLER(CMSG_GUILD_BANK_SET_TAB_TEXT,                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankSetTabText);
-    DEFINE_HANDLER(CMSG_GUILD_BANK_SWAP_ITEMS,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankSwapItems);
     DEFINE_HANDLER(CMSG_GUILD_BANK_TEXT_QUERY,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankTextQuery);
     DEFINE_HANDLER(CMSG_GUILD_BANK_UPDATE_TAB,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankUpdateTab);
     DEFINE_HANDLER(CMSG_GUILD_BANK_WITHDRAW_MONEY,                          STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleGuildBankWithdrawMoney);
@@ -473,6 +474,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_INSPECT,                                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleInspectOpcode);
     DEFINE_HANDLER(CMSG_INSPECT_PVP,                                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleInspectPVP);
     DEFINE_HANDLER(CMSG_INSTANCE_LOCK_RESPONSE,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleInstanceLockResponse);
+    DEFINE_HANDLER(CMSG_ISLAND_QUEUE,                                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_ITEM_PURCHASE_REFUND,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleItemRefund);
     DEFINE_HANDLER(CMSG_ITEM_TEXT_QUERY,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleItemTextQuery);
     DEFINE_HANDLER(CMSG_JOIN_PET_BATTLE_QUEUE,                              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
@@ -544,6 +546,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_MOVE_FEATHER_FALL_ACK,                              STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   &WorldSession::HandleMovementAckMessage);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_FLIGHT_BACK_SPEED_CHANGE_ACK,            STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   &WorldSession::HandleForceSpeedChangeAck);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_FLIGHT_SPEED_CHANGE_ACK,                 STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   &WorldSession::HandleForceSpeedChangeAck);
+    DEFINE_HANDLER(CMSG_MOVE_FORCE_MOVEMENT_FORCE_SPEED_CHANGE_ACK,         STATUS_UNHANDLED, PROCESS_THREADSAFE,   &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_PITCH_RATE_CHANGE_ACK,                   STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   &WorldSession::HandleForceSpeedChangeAck);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_ROOT_ACK,                                STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   &WorldSession::HandleMovementAckMessage);
     DEFINE_HANDLER(CMSG_MOVE_FORCE_RUN_BACK_SPEED_CHANGE_ACK,               STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   &WorldSession::HandleForceSpeedChangeAck);
@@ -634,8 +637,8 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_PROTOCOL_MISMATCH,                                  STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_PUSH_QUEST_TO_PARTY,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandlePushQuestToParty);
     DEFINE_HANDLER(CMSG_PVP_LOG_DATA,                                       STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandlePVPLogDataOpcode);
-    DEFINE_HANDLER(CMSG_PVP_PRESTIGE_RANK_UP,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandlePvpPrestigeRankUp);
     DEFINE_HANDLER(CMSG_QUERY_BATTLE_PET_NAME,                              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_QUERY_COMMUNITY_NAME,                               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_QUERY_CORPSE_LOCATION_FROM_CLIENT,                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleQueryCorpseLocation);
     DEFINE_HANDLER(CMSG_QUERY_CORPSE_TRANSPORT,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleQueryCorpseTransport);
     DEFINE_HANDLER(CMSG_QUERY_COUNTDOWN_TIMER,                              STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
@@ -652,10 +655,10 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_QUERY_PLAYER_NAME,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleNameQueryOpcode);
     DEFINE_HANDLER(CMSG_QUERY_QUEST_COMPLETION_NPCS,                        STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleQueryQuestCompletionNPCs);
     DEFINE_HANDLER(CMSG_QUERY_QUEST_INFO,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleQuestQueryOpcode);
-    DEFINE_HANDLER(CMSG_QUERY_QUEST_REWARDS,                                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_QUERY_REALM_NAME,                                   STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleQueryRealmName);
     DEFINE_HANDLER(CMSG_QUERY_SCENARIO_POI,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleQueryScenarioPOI);
     DEFINE_HANDLER(CMSG_QUERY_TIME,                                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleQueryTimeOpcode);
+    DEFINE_HANDLER(CMSG_QUERY_TREASURE_PICKER,                              STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_QUERY_VOID_STORAGE,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleVoidStorageQuery);
     DEFINE_HANDLER(CMSG_QUEST_CONFIRM_ACCEPT,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleQuestConfirmAccept);
     DEFINE_HANDLER(CMSG_QUEST_GIVER_ACCEPT_QUEST,                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleQuestgiverAcceptQuestOpcode);
@@ -696,6 +699,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_REQUEST_BATTLEFIELD_STATUS,                         STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleRequestBattlefieldStatusOpcode);
     DEFINE_HANDLER(CMSG_REQUEST_CATEGORY_COOLDOWNS,                         STATUS_LOGGEDIN,  PROCESS_INPLACE,      &WorldSession::HandleRequestCategoryCooldowns);
     DEFINE_HANDLER(CMSG_REQUEST_CEMETERY_LIST,                              STATUS_LOGGEDIN,  PROCESS_INPLACE,      &WorldSession::HandleRequestCemeteryList);
+    DEFINE_HANDLER(CMSG_REQUEST_CHALLENGE_MODE_AFFIXES,                     STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_REQUEST_CONQUEST_FORMULA_CONSTANTS,                 STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_REQUEST_CONSUMPTION_CONVERSION_INFO,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_REQUEST_CROWD_CONTROL_SPELL,                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
@@ -748,7 +752,6 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_SET_ASSISTANT_LEADER,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSetAssistantLeaderOpcode);
     DEFINE_HANDLER(CMSG_SET_BACKPACK_AUTOSORT_DISABLED,                     STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_BANK_AUTOSORT_DISABLED,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
-    DEFINE_HANDLER(CMSG_SET_BANK_BAG_SLOT_FLAG,                             STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_CONTACT_NOTES,                                  STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSetContactNotesOpcode);
     DEFINE_HANDLER(CMSG_SET_CURRENCY_FLAGS,                                 STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_DIFFICULTY_ID,                                  STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
@@ -757,6 +760,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_SET_FACTION_AT_WAR,                                 STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSetFactionAtWar);
     DEFINE_HANDLER(CMSG_SET_FACTION_INACTIVE,                               STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSetFactionInactiveOpcode);
     DEFINE_HANDLER(CMSG_SET_FACTION_NOT_AT_WAR,                             STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSetFactionNotAtWar);
+    DEFINE_HANDLER(CMSG_SET_GAME_EVENT_DEBUG_VIEW_STATE,                    STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_INSERT_ITEMS_LEFT_TO_RIGHT,                     STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_LFG_BONUS_FACTION_ID,                           STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_LOOT_METHOD,                                    STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSetLootMethodOpcode);
@@ -779,6 +783,7 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_SET_TRADE_GOLD,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSetTradeGoldOpcode);
     DEFINE_HANDLER(CMSG_SET_TRADE_ITEM,                                     STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSetTradeItemOpcode);
     DEFINE_HANDLER(CMSG_SET_USING_PARTY_GARRISON,                           STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_SET_WAR_MODE,                                       STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SET_WATCHED_FACTION,                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSetWatchedFactionOpcode);
     DEFINE_HANDLER(CMSG_SHOW_TRADE_SKILL,                                   STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_SIGN_PETITION,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleSignPetition);
@@ -850,6 +855,8 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_USE_ITEM,                                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleUseItemOpcode);
     DEFINE_HANDLER(CMSG_USE_TOY,                                            STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleUseToy);
     DEFINE_HANDLER(CMSG_VIOLENCE_LEVEL,                                     STATUS_AUTHED,    PROCESS_INPLACE,      &WorldSession::HandleViolenceLevel);
+    DEFINE_HANDLER(CMSG_VOICE_CHAT_JOIN_CHANNEL,                            STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_VOICE_CHAT_LOGIN,                                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_VOID_STORAGE_TRANSFER,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleVoidStorageTransfer);
     DEFINE_HANDLER(CMSG_WARDEN_DATA,                                        STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleWardenData);
     DEFINE_HANDLER(CMSG_WHO,                                                STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleWhoOpcode);
@@ -878,6 +885,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ADD_LOSS_OF_CONTROL,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ADD_RUNE_POWER,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ADJUST_SPLINE_DURATION,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ADVENTURE_MAP_POI_QUERY_RESPONSE,        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AE_LOOT_TARGETS,                         STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AE_LOOT_TARGET_ACK,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AI_REACTION,                             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -890,12 +898,11 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AREA_TRIGGER_DENIED,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AREA_TRIGGER_NO_CORPSE,                  STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AREA_TRIGGER_RE_PATH,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_AREA_TRIGGER_RE_SHAPE,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_AREA_TRIGGER_RE_SHAPE,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARENA_CROWD_CONTROL_SPELLS,              STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARENA_ERROR,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARENA_PREP_OPPONENT_SPECIALIZATIONS,     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARTIFACT_FORGE_OPENED,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARTIFACT_KNOWLEDGE,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARTIFACT_RESPEC_CONFIRM,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARTIFACT_TRAITS_REFUNDED,                STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ARTIFACT_XP_GAIN,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -920,6 +927,8 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AUTH_CHALLENGE,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AUTH_RESPONSE,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_AVAILABLE_HOTFIXES,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_AZERITE_EMPOWERED_ITEM_RESPEC_OPEN,      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_AZERITE_XP_GAIN,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BAN_REASON,                              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BARBER_SHOP_RESULT,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLEFIELD_LIST,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -942,6 +951,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLENET_REALM_LIST_TICKET,             STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLENET_RESPONSE,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLENET_SET_SESSION_STATE,             STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLENET_UPDATE_SESSION_KEY,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_ACK_FAILED,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_BATTLE_PET_DELIVERED,         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_CONFIRM_PURCHASE,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -952,6 +962,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_GET_PRODUCT_LIST_RESPONSE,    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_GET_PURCHASE_LIST_RESPONSE,   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_MOUNT_DELIVERED,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_OPEN_CHECKOUT_RESULT,         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_PURCHASE_UPDATE,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_START_DISTRIBUTION_ASSIGN_TO_TARGET_RESPONSE, STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BATTLE_PAY_START_PURCHASE_RESPONSE,      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -991,11 +1002,13 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BLACK_MARKET_REQUEST_ITEMS_RESULT,       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BLACK_MARKET_WON,                        STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BONUS_ROLL_EMPTY,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_BONUS_ROLL_FAILED,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BOSS_KILL_CREDIT,                        STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BREAK_TARGET,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_BROADCAST_ACHIEVEMENT,                   STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BUY_FAILED,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_BUY_SUCCEEDED,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CACHE_INFO,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CACHE_INFO,                              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CACHE_VERSION,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_CLEAR_PENDING_ACTION,           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_COMMAND_RESULT,                 STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1027,10 +1040,11 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAN_DUEL_RESULT,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAST_FAILED,                             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CATEGORY_COOLDOWN,                       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_AFFIXES,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_ALL_MAP_STATS,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_COMPLETE,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_MAP_STATS_UPDATE,         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_NEW_PLAYER_RECORD,        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_NEW_PLAYER_SEASON_RECORD, STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_REQUEST_LEADERS_RESULT,   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_REWARDS,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLENGE_MODE_RESET,                    STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1085,6 +1099,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CONNECT_TO,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CONQUEST_FORMULA_CONSTANTS,              STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CONSOLE_WRITE,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CONTRIBUTION_COLLECTOR_STATE,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CONTACT_LIST,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CONTROL_UPDATE,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_COOLDOWN_CHEAT,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1121,6 +1136,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_COMPLETE,                           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_COUNTDOWN,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_IN_BOUNDS,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_OPPONENT_SELECTED,                  STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_OUT_OF_BOUNDS,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_REQUESTED,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_WINNER,                             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1148,9 +1164,11 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_FORCE_ANIM,                              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_FORCE_OBJECT_RELINK,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_FRIEND_STATUS,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GAME_EVENT_DEBUG_INITIALIZE,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GAME_OBJECT_ACTIVATE_ANIM_KIT,           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GAME_OBJECT_CUSTOM_ANIM,                 STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GAME_OBJECT_DESPAWN,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GAME_OBJECT_MULTI_TRANSITION,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GAME_OBJECT_PLAY_SPELL_VISUAL,           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GAME_OBJECT_PLAY_SPELL_VISUAL_KIT,       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GAME_OBJECT_RESET_STATE,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1170,6 +1188,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GARRISON_COMPLETE_MISSION_RESULT,        STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GARRISON_CREATE_RESULT,                  STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GARRISON_DELETE_RESULT,                  STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GARRISON_FOLLOWER_CATEGORIES,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GARRISON_FOLLOWER_CHANGED_ABILITIES,     STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GARRISON_FOLLOWER_CHANGED_DURABILITY,    STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GARRISON_FOLLOWER_CHANGED_ITEM_LEVEL,    STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
@@ -1218,6 +1237,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_COMPLETE,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_MESSAGE,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_POI,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_GOSSIP_TEXT_UPDATE,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_ACTION_THROTTLED,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DECLINE,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_GROUP_DESTROYED,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1306,6 +1326,9 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INVALIDATE_PLAYER,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INVALID_PROMOTION_CODE,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_INVENTORY_CHANGE_FAILURE,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ISLAND_AZERITE_XP_GAIN,                  STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ISLAND_COMPLETED,                        STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_ISLAND_OPEN_QUEUE_NPC,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_IS_QUEST_COMPLETE_RESPONSE,              STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_CHANGED,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ITEM_COOLDOWN,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1349,6 +1372,8 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_COMMAND_RESULT,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_POST,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LF_GUILD_RECRUITS,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIGHTNING_STORM_END,                     STATUS_UNHANDLED, CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIGHTNING_STORM_START,                   STATUS_UNHANDLED, CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_ACCOUNT_RESTORE_RESULT,      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_CHARACTER_COPY_RESULT,       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LIVE_REGION_GET_ACCOUNT_CHARACTER_LIST_RESULT, STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1362,6 +1387,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOGOUT_RESPONSE,                         STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOG_XP_GAIN,                             STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_ALL_PASSED,                         STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_LEGACY_RULES_IN_EFFECT,             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_LIST,                               STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_MONEY_NOTIFY,                       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_LOOT_RELEASE,                            STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1412,6 +1438,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_HOVERING,                       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_IGNORE_MOVEMENT_FORCES,         STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_LAND_WALK,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_MOVEMENT_FORCE_SPEED,           STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_NORMAL_FALL,                    STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_PITCH_RATE,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_SET_RUN_BACK_SPEED,                 STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1462,6 +1489,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_FLIGHT_BACK_SPEED,           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_FLIGHT_SPEED,                STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_KNOCK_BACK,                  STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_MOVEMENT_FORCE_SPEED,        STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_PITCH_RATE,                  STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_REMOVE_MOVEMENT_FORCE,       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_MOVE_UPDATE_RUN_BACK_SPEED,              STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1493,7 +1521,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_INVITE,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_KILL_LOG,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_MEMBER_STATE,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_MEMBER_STATE_UPDATE,               STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_MEMBER_STATE_UPDATE,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PARTY_UPDATE,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PAUSE_MIRROR_TIMER,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PENDING_RAID_LOCK,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1552,7 +1580,6 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PLAY_TIME_WARNING,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PONG,                                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_POWER_UPDATE,                            STATUS_NEVER,        CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_PRESTIGE_AND_HONOR_INVOLUNTARILY_CHANGED, STATUS_UNHANDLED,   CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PRE_RESSURECT,                           STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PRINT_NOTIFICATION,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PROC_RESIST,                             STATUS_NEVER,        CONNECTION_TYPE_REALM);
@@ -1563,6 +1590,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_OPTIONS_ENABLED,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_PVP_SEASON,                              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_BATTLE_PET_NAME_RESPONSE,          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_COMMUNITY_NAME_RESPONSE,           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_CREATURE_RESPONSE,                 STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_GAME_OBJECT_RESPONSE,              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_GARRISON_CREATURE_NAME_RESPONSE,   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1574,8 +1602,8 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_PET_NAME_RESPONSE,                 STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_PLAYER_NAME_RESPONSE,              STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_QUEST_INFO_RESPONSE,               STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_QUEST_REWARD_RESPONSE,             STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_TIME_RESPONSE,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUERY_TREASURE_PICKER_RESPONSE,          STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUEST_COMPLETION_NPC_RESPONSE,           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUEST_CONFIRM_ACCEPT,                    STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_QUEST_FORCE_REMOVED,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1629,7 +1657,6 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_REQUEST_PVP_BRAWL_INFO_RESPONSE,         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_REQUEST_PVP_REWARDS_RESPONSE,            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESEARCH_COMPLETE,                       STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_AREA_TRIGGER,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_COMPRESSION_CONTEXT,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_FAILED_NOTIFY,                     STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_RESET_RANGED_COMBAT_TIMER,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1668,7 +1695,6 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_SPELL_CHARGES,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_SPELL_HISTORY,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SEND_UNLEARN_SPELLS,                     STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_SERVER_FIRST_ACHIEVEMENT,                STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SERVER_FIRST_ACHIEVEMENTS,               STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SERVER_TIME,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_SETUP_CURRENCY,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
@@ -1809,6 +1835,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_WAIT_QUEUE_FINISH,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_WAIT_QUEUE_UPDATE,                       STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_WARDEN_DATA,                             STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_WARFRONT_COMPLETED,                      STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_WARGAME_REQUEST_SUCCESSFULLY_SENT_TO_OPPONENT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_WEATHER,                                 STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_WEEKLY_SPELL_USAGE,                      STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
diff --git a/src/server/game/Server/Protocol/Opcodes.h b/src/server/game/Server/Protocol/Opcodes.h
index c39cd5ca314..9164e453ad7 100644
--- a/src/server/game/Server/Protocol/Opcodes.h
+++ b/src/server/game/Server/Protocol/Opcodes.h
@@ -46,38 +46,36 @@ enum OpcodeMisc : uint16
 enum OpcodeClient : uint16
 {
     CMSG_ACCEPT_GUILD_INVITE                          = 0x35FC,
-    CMSG_ACCEPT_LEVEL_GRANT                           = 0x34FD,
+    CMSG_ACCEPT_LEVEL_GRANT                           = 0x34FA,
     CMSG_ACCEPT_TRADE                                 = 0x315A,
     CMSG_ACCEPT_WARGAME_INVITE                        = 0x35E0,
-    CMSG_ACTIVATE_TAXI                                = 0x34AE,
+    CMSG_ACTIVATE_TAXI                                = 0x34AB,
     CMSG_ADDON_LIST                                   = 0x35D8,
     CMSG_ADD_BATTLENET_FRIEND                         = 0x365A,
-    CMSG_ADD_FRIEND                                   = 0x36CF,
-    CMSG_ADD_IGNORE                                   = 0x36D3,
-    CMSG_ADD_TOY                                      = 0x328B,
-    CMSG_ADVENTURE_JOURNAL_OPEN_QUEST                 = 0x31F9,
-    CMSG_ADVENTURE_JOURNAL_START_QUEST                = 0x332E,
-    CMSG_ALTER_APPEARANCE                             = 0x34F9,
-    CMSG_AREA_SPIRIT_HEALER_QUERY                     = 0x34B3,
-    CMSG_AREA_SPIRIT_HEALER_QUEUE                     = 0x34B4,
-    CMSG_AREA_TRIGGER                                 = 0x31CD,
-    CMSG_ARTIFACT_ADD_POWER                           = 0x31A5,
-    CMSG_ARTIFACT_ADD_RELIC_TALENT                    = 0x31A8,
-    CMSG_ARTIFACT_ATTUNE_PREVIEW_RELIC                = 0x31A9,
-    CMSG_ARTIFACT_ATTUNE_SOCKETED_RELIC               = 0x31AA,
-    CMSG_ARTIFACT_SET_APPEARANCE                      = 0x31A7,
-    CMSG_ASSIGN_EQUIPMENT_SET_SPEC                    = 0x3200,
-    CMSG_ATTACK_STOP                                  = 0x324D,
-    CMSG_ATTACK_SWING                                 = 0x324C,
-    CMSG_AUCTION_HELLO_REQUEST                        = 0x34CF,
-    CMSG_AUCTION_LIST_BIDDER_ITEMS                    = 0x34D5,
-    CMSG_AUCTION_LIST_ITEMS                           = 0x34D2,
-    CMSG_AUCTION_LIST_OWNER_ITEMS                     = 0x34D4,
-    CMSG_AUCTION_LIST_PENDING_SALES                   = 0x34D7,
-    CMSG_AUCTION_PLACE_BID                            = 0x34D6,
-    CMSG_AUCTION_REMOVE_ITEM                          = 0x34D1,
-    CMSG_AUCTION_REPLICATE_ITEMS                      = 0x34D3,
-    CMSG_AUCTION_SELL_ITEM                            = 0x34D0,
+    CMSG_ADD_FRIEND                                   = 0x36D0,
+    CMSG_ADD_IGNORE                                   = 0x36D4,
+    CMSG_ADD_TOY                                      = 0x3298,
+    CMSG_ADVENTURE_JOURNAL_OPEN_QUEST                 = 0x3201,
+    CMSG_ADVENTURE_JOURNAL_START_QUEST                = 0x333D,
+    CMSG_ADVENTURE_MAP_POI_QUERY                      = 0x3244,
+    CMSG_ALTER_APPEARANCE                             = 0x34F6,
+    CMSG_AREA_SPIRIT_HEALER_QUERY                     = 0x34B0,
+    CMSG_AREA_SPIRIT_HEALER_QUEUE                     = 0x34B1,
+    CMSG_AREA_TRIGGER                                 = 0x31D5,
+    CMSG_ARTIFACT_ADD_POWER                           = 0x31A9,
+    CMSG_ARTIFACT_SET_APPEARANCE                      = 0x31AB,
+    CMSG_ASSIGN_EQUIPMENT_SET_SPEC                    = 0x3209,
+    CMSG_ATTACK_STOP                                  = 0x3256,
+    CMSG_ATTACK_SWING                                 = 0x3255,
+    CMSG_AUCTION_HELLO_REQUEST                        = 0x34CB,
+    CMSG_AUCTION_LIST_BIDDER_ITEMS                    = 0x34D1,
+    CMSG_AUCTION_LIST_ITEMS                           = 0x34CE,
+    CMSG_AUCTION_LIST_OWNER_ITEMS                     = 0x34D0,
+    CMSG_AUCTION_LIST_PENDING_SALES                   = 0x34D3,
+    CMSG_AUCTION_PLACE_BID                            = 0x34D2,
+    CMSG_AUCTION_REMOVE_ITEM                          = 0x34CD,
+    CMSG_AUCTION_REPLICATE_ITEMS                      = 0x34CF,
+    CMSG_AUCTION_SELL_ITEM                            = 0x34CC,
     CMSG_AUTH_CONTINUED_SESSION                       = 0x3766,
     CMSG_AUTH_SESSION                                 = 0x3765,
     CMSG_AUTOBANK_ITEM                                = 0x3996,
@@ -87,32 +85,37 @@ enum OpcodeClient : uint16
     CMSG_AUTO_EQUIP_ITEM                              = 0x399A,
     CMSG_AUTO_EQUIP_ITEM_SLOT                         = 0x399F,
     CMSG_AUTO_STORE_BAG_ITEM                          = 0x399B,
-    CMSG_BANKER_ACTIVATE                              = 0x34B6,
-    CMSG_BATTLEFIELD_LEAVE                            = 0x3171,
-    CMSG_BATTLEFIELD_LIST                             = 0x317D,
-    CMSG_BATTLEFIELD_PORT                             = 0x3529,
-    CMSG_BATTLEMASTER_HELLO                           = 0x32A1,
-    CMSG_BATTLEMASTER_JOIN                            = 0x3524,
-    CMSG_BATTLEMASTER_JOIN_ARENA                      = 0x3525,
-    CMSG_BATTLEMASTER_JOIN_BRAWL                      = 0x3527,
-    CMSG_BATTLEMASTER_JOIN_SKIRMISH                   = 0x3526,
-    CMSG_BATTLENET_CHALLENGE_RESPONSE                 = 0x36D2,
-    CMSG_BATTLENET_REQUEST                            = 0x36F6,
-    CMSG_BATTLENET_REQUEST_REALM_LIST_TICKET          = 0x36F7,
-    CMSG_BATTLE_PAY_ACK_FAILED_RESPONSE               = 0x36CA,
-    CMSG_BATTLE_PAY_CONFIRM_PURCHASE_RESPONSE         = 0x36C9,
-    CMSG_BATTLE_PAY_DISTRIBUTION_ASSIGN_TO_TARGET     = 0x36C0,
-    CMSG_BATTLE_PAY_GET_PRODUCT_LIST                  = 0x36BA,
-    CMSG_BATTLE_PAY_GET_PURCHASE_LIST                 = 0x36BB,
-    CMSG_BATTLE_PAY_QUERY_CLASS_TRIAL_BOOST_RESULT    = 0x36C3,
-    CMSG_BATTLE_PAY_REQUEST_CHARACTER_BOOST_UNREVOKE  = 0x36C1,
-    CMSG_BATTLE_PAY_REQUEST_CURRENT_VAS_TRANSFER_QUEUES = 0x3708,
-    CMSG_BATTLE_PAY_REQUEST_PRICE_INFO                = 0x3707,
-    CMSG_BATTLE_PAY_REQUEST_VAS_CHARACTER_QUEUE_TIME  = 0x3709,
-    CMSG_BATTLE_PAY_START_PURCHASE                    = 0x36F2,
-    CMSG_BATTLE_PAY_START_VAS_PURCHASE                = 0x36F3,
-    CMSG_BATTLE_PAY_TRIAL_BOOST_CHARACTER             = 0x36C2,
-    CMSG_BATTLE_PAY_VALIDATE_BNET_VAS_TRANSFER        = 0x370A,
+    CMSG_AZERITE_EMPOWERED_ITEM_SELECT_POWER          = 0x335B,
+    CMSG_AZERITE_EMPOWERED_ITEM_VIEWED                = 0x3347,
+    CMSG_BANKER_ACTIVATE                              = 0x34B3,
+    CMSG_BATTLEFIELD_LEAVE                            = 0x3172,
+    CMSG_BATTLEFIELD_LIST                             = 0x317E,
+    CMSG_BATTLEFIELD_PORT                             = 0x3527,
+    CMSG_BATTLEMASTER_HELLO                           = 0x32B0,
+    CMSG_BATTLEMASTER_JOIN                            = 0x3522,
+    CMSG_BATTLEMASTER_JOIN_ARENA                      = 0x3523,
+    CMSG_BATTLEMASTER_JOIN_BRAWL                      = 0x3525,
+    CMSG_BATTLEMASTER_JOIN_SKIRMISH                   = 0x3524,
+    CMSG_BATTLENET_CHALLENGE_RESPONSE                 = 0x36D3,
+    CMSG_BATTLENET_REQUEST                            = 0x36F7,
+    CMSG_BATTLENET_REQUEST_REALM_LIST_TICKET          = 0x36FB,
+    CMSG_BATTLE_PAY_ACK_FAILED_RESPONSE               = 0x36CB,
+    CMSG_BATTLE_PAY_CANCEL_OPEN_CHECKOUT              = 0x3716,
+    CMSG_BATTLE_PAY_CONFIRM_PURCHASE_RESPONSE         = 0x36CA,
+    CMSG_BATTLE_PAY_DISTRIBUTION_ASSIGN_TO_TARGET     = 0x36C1,
+    CMSG_BATTLE_PAY_GET_PRODUCT_LIST                  = 0x36BB,
+    CMSG_BATTLE_PAY_GET_PURCHASE_LIST                 = 0x36BC,
+    CMSG_BATTLE_PAY_OPEN_CHECKOUT                     = 0x370F,
+    CMSG_BATTLE_PAY_QUERY_CLASS_TRIAL_BOOST_RESULT    = 0x36C4,
+    CMSG_BATTLE_PAY_REQUEST_CHARACTER_BOOST_UNREVOKE  = 0x36C2,
+    CMSG_BATTLE_PAY_REQUEST_CURRENT_VAS_TRANSFER_QUEUES = 0x370C,
+    CMSG_BATTLE_PAY_REQUEST_PRICE_INFO                = 0x370B,
+    CMSG_BATTLE_PAY_REQUEST_VAS_CHARACTER_QUEUE_TIME  = 0x370D,
+    CMSG_BATTLE_PAY_START_PURCHASE                    = 0x36F3,
+    CMSG_BATTLE_PAY_START_VAS_PURCHASE                = 0x36F4,
+    CMSG_BATTLE_PAY_TRIAL_BOOST_CHARACTER             = 0x36C3,
+    CMSG_BATTLE_PAY_VALIDATE_BNET_VAS_TRANSFER        = 0x370E,
+    CMSG_BATTLE_PAY_VAS_PURCHASE_COMPLETE             = 0x36F2,
     CMSG_BATTLE_PET_CLEAR_FANFARE                     = 0x312C,
     CMSG_BATTLE_PET_DELETE_PET                        = 0x3624,
     CMSG_BATTLE_PET_DELETE_PET_CHEAT                  = 0x3625,
@@ -122,23 +125,25 @@ enum OpcodeClient : uint16
     CMSG_BATTLE_PET_SET_BATTLE_SLOT                   = 0x362B,
     CMSG_BATTLE_PET_SET_FLAGS                         = 0x362F,
     CMSG_BATTLE_PET_SUMMON                            = 0x3628,
-    CMSG_BATTLE_PET_UPDATE_DISPLAY_NOTIFY             = 0x31D7,
-    CMSG_BATTLE_PET_UPDATE_NOTIFY                     = 0x31D6,
+    CMSG_BATTLE_PET_UPDATE_DISPLAY_NOTIFY             = 0x31DF,
+    CMSG_BATTLE_PET_UPDATE_NOTIFY                     = 0x31DE,
     CMSG_BEGIN_TRADE                                  = 0x3157,
-    CMSG_BINDER_ACTIVATE                              = 0x34B5,
-    CMSG_BLACK_MARKET_BID_ON_ITEM                     = 0x3531,
-    CMSG_BLACK_MARKET_OPEN                            = 0x352F,
-    CMSG_BLACK_MARKET_REQUEST_ITEMS                   = 0x3530,
+    CMSG_BINDER_ACTIVATE                              = 0x34B2,
+    CMSG_BLACK_MARKET_BID_ON_ITEM                     = 0x352F,
+    CMSG_BLACK_MARKET_OPEN                            = 0x352D,
+    CMSG_BLACK_MARKET_REQUEST_ITEMS                   = 0x352E,
+    CMSG_BONUS_ROLL                                   = 0x335C,
     CMSG_BUG_REPORT                                   = 0x3686,
     CMSG_BUSY_TRADE                                   = 0x3158,
-    CMSG_BUY_BACK_ITEM                                = 0x34A7,
-    CMSG_BUY_BANK_SLOT                                = 0x34B7,
-    CMSG_BUY_ITEM                                     = 0x34A6,
-    CMSG_BUY_REAGENT_BANK                             = 0x34B8,
-    CMSG_BUY_WOW_TOKEN_CONFIRM                        = 0x36EB,
-    CMSG_BUY_WOW_TOKEN_START                          = 0x36EA,
-    CMSG_CAGE_BATTLE_PET                              = 0x31E8,
+    CMSG_BUY_BACK_ITEM                                = 0x34A4,
+    CMSG_BUY_BANK_SLOT                                = 0x34B4,
+    CMSG_BUY_ITEM                                     = 0x34A3,
+    CMSG_BUY_REAGENT_BANK                             = 0x34B5,
+    CMSG_BUY_WOW_TOKEN_CONFIRM                        = 0x36EC,
+    CMSG_BUY_WOW_TOKEN_START                          = 0x36EB,
+    CMSG_CAGE_BATTLE_PET                              = 0x31F0,
     CMSG_CALENDAR_ADD_EVENT                           = 0x367D,
+    CMSG_CALENDAR_COMMUNITY_FILTER                    = 0x3671,
     CMSG_CALENDAR_COMPLAIN                            = 0x3679,
     CMSG_CALENDAR_COPY_EVENT                          = 0x3678,
     CMSG_CALENDAR_EVENT_INVITE                        = 0x3672,
@@ -149,84 +154,78 @@ enum OpcodeClient : uint16
     CMSG_CALENDAR_GET                                 = 0x366F,
     CMSG_CALENDAR_GET_EVENT                           = 0x3670,
     CMSG_CALENDAR_GET_NUM_PENDING                     = 0x367A,
-    CMSG_CALENDAR_GUILD_FILTER                        = 0x3671,
     CMSG_CALENDAR_REMOVE_EVENT                        = 0x3677,
     CMSG_CALENDAR_REMOVE_INVITE                       = 0x3673,
     CMSG_CALENDAR_UPDATE_EVENT                        = 0x367E,
-    CMSG_CANCEL_AURA                                  = 0x31AC,
-    CMSG_CANCEL_AUTO_REPEAT_SPELL                     = 0x34EB,
-    CMSG_CANCEL_CAST                                  = 0x3291,
-    CMSG_CANCEL_CHANNELLING                           = 0x325C,
-    CMSG_CANCEL_GROWTH_AURA                           = 0x3261,
-    CMSG_CANCEL_MASTER_LOOT_ROLL                      = 0x3208,
-    CMSG_CANCEL_MOD_SPEED_NO_CONTROL_AURAS            = 0x31AB,
-    CMSG_CANCEL_MOUNT_AURA                            = 0x3272,
-    CMSG_CANCEL_QUEUED_SPELL                          = 0x317E,
-    CMSG_CANCEL_TEMP_ENCHANTMENT                      = 0x34F6,
+    CMSG_CANCEL_AURA                                  = 0x31AD,
+    CMSG_CANCEL_AUTO_REPEAT_SPELL                     = 0x34E8,
+    CMSG_CANCEL_CAST                                  = 0x329E,
+    CMSG_CANCEL_CHANNELLING                           = 0x326A,
+    CMSG_CANCEL_GROWTH_AURA                           = 0x326F,
+    CMSG_CANCEL_MASTER_LOOT_ROLL                      = 0x3211,
+    CMSG_CANCEL_MOD_SPEED_NO_CONTROL_AURAS            = 0x31AC,
+    CMSG_CANCEL_MOUNT_AURA                            = 0x3280,
+    CMSG_CANCEL_QUEUED_SPELL                          = 0x317F,
+    CMSG_CANCEL_TEMP_ENCHANTMENT                      = 0x34F3,
     CMSG_CANCEL_TRADE                                 = 0x315C,
     CMSG_CAN_DUEL                                     = 0x3662,
-    CMSG_CAN_REDEEM_WOW_TOKEN_FOR_BALANCE             = 0x3706,
-    CMSG_CAST_SPELL                                   = 0x328E,
+    CMSG_CAN_REDEEM_WOW_TOKEN_FOR_BALANCE             = 0x370A,
+    CMSG_CAST_SPELL                                   = 0x329B,
     CMSG_CHALLENGE_MODE_REQUEST_LEADERS               = 0x308F,
     CMSG_CHALLENGE_MODE_REQUEST_MAP_STATS             = 0x308E,
-    CMSG_CHANGE_BAG_SLOT_FLAG                         = 0x3312,
-    CMSG_CHANGE_MONUMENT_APPEARANCE                   = 0x32F4,
+    CMSG_CHANGE_BAG_SLOT_FLAG                         = 0x3321,
+    CMSG_CHANGE_BANK_BAG_SLOT_FLAG                    = 0x3322,
+    CMSG_CHANGE_MONUMENT_APPEARANCE                   = 0x3303,
     CMSG_CHANGE_SUB_GROUP                             = 0x364C,
-    CMSG_CHARACTER_RENAME_REQUEST                     = 0x36BE,
-    CMSG_CHAR_CUSTOMIZE                               = 0x368E,
-    CMSG_CHAR_DELETE                                  = 0x369B,
-    CMSG_CHAR_RACE_OR_FACTION_CHANGE                  = 0x3694,
-    CMSG_CHAT_ADDON_MESSAGE_CHANNEL                   = 0x37D0,
-    CMSG_CHAT_ADDON_MESSAGE_GUILD                     = 0x37D4,
-    CMSG_CHAT_ADDON_MESSAGE_INSTANCE_CHAT             = 0x37F3,
-    CMSG_CHAT_ADDON_MESSAGE_OFFICER                   = 0x37D6,
-    CMSG_CHAT_ADDON_MESSAGE_PARTY                     = 0x37EF,
-    CMSG_CHAT_ADDON_MESSAGE_RAID                      = 0x37F1,
-    CMSG_CHAT_ADDON_MESSAGE_WHISPER                   = 0x37D2,
-    CMSG_CHAT_CHANNEL_ANNOUNCEMENTS                   = 0x37E7,
-    CMSG_CHAT_CHANNEL_BAN                             = 0x37E5,
-    CMSG_CHAT_CHANNEL_DECLINE_INVITE                  = 0x37EA,
-    CMSG_CHAT_CHANNEL_DISPLAY_LIST                    = 0x37DA,
-    CMSG_CHAT_CHANNEL_INVITE                          = 0x37E3,
-    CMSG_CHAT_CHANNEL_KICK                            = 0x37E4,
-    CMSG_CHAT_CHANNEL_LIST                            = 0x37D9,
-    CMSG_CHAT_CHANNEL_MODERATE                        = 0x37DE,
-    CMSG_CHAT_CHANNEL_MODERATOR                       = 0x37DF,
-    CMSG_CHAT_CHANNEL_MUTE                            = 0x37E1,
-    CMSG_CHAT_CHANNEL_OWNER                           = 0x37DD,
-    CMSG_CHAT_CHANNEL_PASSWORD                        = 0x37DB,
-    CMSG_CHAT_CHANNEL_SET_OWNER                       = 0x37DC,
-    CMSG_CHAT_CHANNEL_SILENCE_ALL                     = 0x37E8,
-    CMSG_CHAT_CHANNEL_UNBAN                           = 0x37E6,
-    CMSG_CHAT_CHANNEL_UNMODERATOR                     = 0x37E0,
-    CMSG_CHAT_CHANNEL_UNMUTE                          = 0x37E2,
-    CMSG_CHAT_CHANNEL_UNSILENCE_ALL                   = 0x37E9,
+    CMSG_CHARACTER_RENAME_REQUEST                     = 0x36BF,
+    CMSG_CHAR_CUSTOMIZE                               = 0x368F,
+    CMSG_CHAR_DELETE                                  = 0x369C,
+    CMSG_CHAR_RACE_OR_FACTION_CHANGE                  = 0x3695,
+    CMSG_CHAT_ADDON_MESSAGE                           = 0x37EE,
+    CMSG_CHAT_ADDON_MESSAGE_TARGETED                  = 0x37EF,
+    CMSG_CHAT_CHANNEL_ANNOUNCEMENTS                   = 0x37E3,
+    CMSG_CHAT_CHANNEL_BAN                             = 0x37E1,
+    CMSG_CHAT_CHANNEL_DECLINE_INVITE                  = 0x37E6,
+    CMSG_CHAT_CHANNEL_DISPLAY_LIST                    = 0x37D6,
+    CMSG_CHAT_CHANNEL_INVITE                          = 0x37DF,
+    CMSG_CHAT_CHANNEL_KICK                            = 0x37E0,
+    CMSG_CHAT_CHANNEL_LIST                            = 0x37D5,
+    CMSG_CHAT_CHANNEL_MODERATOR                       = 0x37DB,
+    CMSG_CHAT_CHANNEL_OWNER                           = 0x37D9,
+    CMSG_CHAT_CHANNEL_PASSWORD                        = 0x37D7,
+    CMSG_CHAT_CHANNEL_SET_OWNER                       = 0x37D8,
+    CMSG_CHAT_CHANNEL_SILENCE_ALL                     = 0x37E4,
+    CMSG_CHAT_CHANNEL_UNBAN                           = 0x37E2,
+    CMSG_CHAT_CHANNEL_UNMODERATOR                     = 0x37DC,
+    CMSG_CHAT_CHANNEL_UNSILENCE_ALL                   = 0x37E5,
     CMSG_CHAT_JOIN_CHANNEL                            = 0x37C8,
     CMSG_CHAT_LEAVE_CHANNEL                           = 0x37C9,
-    CMSG_CHAT_MESSAGE_AFK                             = 0x37D7,
+    CMSG_CHAT_MESSAGE_AFK                             = 0x37D3,
     CMSG_CHAT_MESSAGE_CHANNEL                         = 0x37CF,
-    CMSG_CHAT_MESSAGE_DND                             = 0x37D8,
-    CMSG_CHAT_MESSAGE_EMOTE                           = 0x37EC,
-    CMSG_CHAT_MESSAGE_GUILD                           = 0x37D3,
-    CMSG_CHAT_MESSAGE_INSTANCE_CHAT                   = 0x37F2,
-    CMSG_CHAT_MESSAGE_OFFICER                         = 0x37D5,
-    CMSG_CHAT_MESSAGE_PARTY                           = 0x37EE,
-    CMSG_CHAT_MESSAGE_RAID                            = 0x37F0,
-    CMSG_CHAT_MESSAGE_RAID_WARNING                    = 0x37F4,
-    CMSG_CHAT_MESSAGE_SAY                             = 0x37EB,
-    CMSG_CHAT_MESSAGE_WHISPER                         = 0x37D1,
-    CMSG_CHAT_MESSAGE_YELL                            = 0x37ED,
+    CMSG_CHAT_MESSAGE_DND                             = 0x37D4,
+    CMSG_CHAT_MESSAGE_EMOTE                           = 0x37E8,
+    CMSG_CHAT_MESSAGE_GUILD                           = 0x37D1,
+    CMSG_CHAT_MESSAGE_INSTANCE_CHAT                   = 0x37EC,
+    CMSG_CHAT_MESSAGE_OFFICER                         = 0x37D2,
+    CMSG_CHAT_MESSAGE_PARTY                           = 0x37EA,
+    CMSG_CHAT_MESSAGE_RAID                            = 0x37EB,
+    CMSG_CHAT_MESSAGE_RAID_WARNING                    = 0x37ED,
+    CMSG_CHAT_MESSAGE_SAY                             = 0x37E7,
+    CMSG_CHAT_MESSAGE_WHISPER                         = 0x37D0,
+    CMSG_CHAT_MESSAGE_YELL                            = 0x37E9,
     CMSG_CHAT_REGISTER_ADDON_PREFIXES                 = 0x37CD,
     CMSG_CHAT_REPORT_FILTERED                         = 0x37CC,
     CMSG_CHAT_REPORT_IGNORED                          = 0x37CB,
     CMSG_CHAT_UNREGISTER_ALL_ADDON_PREFIXES           = 0x37CE,
-    CMSG_CHECK_RAF_EMAIL_ENABLED                      = 0x36CB,
-    CMSG_CHECK_WOW_TOKEN_VETERAN_ELIGIBILITY          = 0x36E9,
-    CMSG_CHOICE_RESPONSE                              = 0x3293,
-    CMSG_CLEAR_RAID_MARKER                            = 0x31A1,
+    CMSG_CHECK_RAF_EMAIL_ENABLED                      = 0x36CC,
+    CMSG_CHECK_WOW_TOKEN_VETERAN_ELIGIBILITY          = 0x36EA,
+    CMSG_CHOICE_RESPONSE                              = 0x32A0,
+    CMSG_CLEAR_RAID_MARKER                            = 0x31A5,
     CMSG_CLEAR_TRADE_ITEM                             = 0x315E,
-    CMSG_CLIENT_PORT_GRAVEYARD                        = 0x352B,
-    CMSG_CLOSE_INTERACTION                            = 0x3496,
+    CMSG_CLIENT_PORT_GRAVEYARD                        = 0x3529,
+    CMSG_CLOSE_INTERACTION                            = 0x3493,
+    CMSG_CLOSE_QUEST_CHOICE                           = 0x32A1,
+    CMSG_CLUB_INVITE                                  = 0x36FA,
     CMSG_COLLECTION_ITEM_SET_FAVORITE                 = 0x3632,
     CMSG_COMMENTATOR_ENABLE                           = 0x35F0,
     CMSG_COMMENTATOR_ENTER_INSTANCE                   = 0x35F4,
@@ -236,26 +235,26 @@ enum OpcodeClient : uint16
     CMSG_COMMENTATOR_GET_PLAYER_INFO                  = 0x35F2,
     CMSG_COMMENTATOR_START_WARGAME                    = 0x35EF,
     CMSG_COMPLAINT                                    = 0x366C,
-    CMSG_COMPLETE_CINEMATIC                           = 0x3549,
-    CMSG_COMPLETE_MOVIE                               = 0x34E1,
-    CMSG_CONFIRM_ARTIFACT_RESPEC                      = 0x31A6,
-    CMSG_CONFIRM_RESPEC_WIPE                          = 0x3202,
+    CMSG_COMPLETE_CINEMATIC                           = 0x3547,
+    CMSG_COMPLETE_MOVIE                               = 0x34DE,
+    CMSG_CONFIRM_ARTIFACT_RESPEC                      = 0x31AA,
+    CMSG_CONFIRM_RESPEC_WIPE                          = 0x320B,
     CMSG_CONNECT_TO_FAILED                            = 0x35D4,
-    CMSG_CONTRIBUTION_CONTRIBUTE                      = 0x3558,
-    CMSG_CONTRIBUTION_GET_STATE                       = 0x3559,
-    CMSG_CONVERSATION_LINE_STARTED                    = 0x354A,
-    CMSG_CONVERT_CONSUMPTION_TIME                     = 0x36F9,
+    CMSG_CONTRIBUTION_CONTRIBUTE                      = 0x3557,
+    CMSG_CONTRIBUTION_GET_STATE                       = 0x3558,
+    CMSG_CONVERSATION_LINE_STARTED                    = 0x3548,
+    CMSG_CONVERT_CONSUMPTION_TIME                     = 0x36FD,
     CMSG_CONVERT_RAID                                 = 0x364E,
     CMSG_CREATE_CHARACTER                             = 0x3643,
-    CMSG_CREATE_SHIPMENT                              = 0x32E0,
+    CMSG_CREATE_SHIPMENT                              = 0x32EF,
     CMSG_DB_QUERY_BULK                                = 0x35E4,
-    CMSG_DECLINE_GUILD_INVITES                        = 0x3522,
-    CMSG_DECLINE_PETITION                             = 0x3538,
-    CMSG_DELETE_EQUIPMENT_SET                         = 0x3510,
-    CMSG_DEL_FRIEND                                   = 0x36D0,
-    CMSG_DEL_IGNORE                                   = 0x36D4,
-    CMSG_DEPOSIT_REAGENT_BANK                         = 0x331B,
-    CMSG_DESTROY_ITEM                                 = 0x3285,
+    CMSG_DECLINE_GUILD_INVITES                        = 0x3520,
+    CMSG_DECLINE_PETITION                             = 0x3536,
+    CMSG_DELETE_EQUIPMENT_SET                         = 0x350D,
+    CMSG_DEL_FRIEND                                   = 0x36D1,
+    CMSG_DEL_IGNORE                                   = 0x36D5,
+    CMSG_DEPOSIT_REAGENT_BANK                         = 0x332A,
+    CMSG_DESTROY_ITEM                                 = 0x3292,
     CMSG_DF_BOOT_PLAYER_VOTE                          = 0x3615,
     CMSG_DF_GET_JOIN_STATUS                           = 0x3613,
     CMSG_DF_GET_SYSTEM_INFO                           = 0x3612,
@@ -266,74 +265,76 @@ enum OpcodeClient : uint16
     CMSG_DF_SET_ROLES                                 = 0x3614,
     CMSG_DF_TELEPORT                                  = 0x3616,
     CMSG_DISCARDED_TIME_SYNC_ACKS                     = 0x3A3C,
-    CMSG_DISMISS_CRITTER                              = 0x34FF,
-    CMSG_DO_MASTER_LOOT_ROLL                          = 0x3207,
+    CMSG_DISMISS_CRITTER                              = 0x34FC,
+    CMSG_DO_MASTER_LOOT_ROLL                          = 0x3210,
     CMSG_DO_READY_CHECK                               = 0x3633,
-    CMSG_DUEL_RESPONSE                                = 0x34E6,
-    CMSG_EJECT_PASSENGER                              = 0x3230,
-    CMSG_EMOTE                                        = 0x3545,
+    CMSG_DUEL_RESPONSE                                = 0x34E3,
+    CMSG_EJECT_PASSENGER                              = 0x3239,
+    CMSG_EMOTE                                        = 0x3543,
     CMSG_ENABLE_ENCRYPTION_ACK                        = 0x3767,
     CMSG_ENABLE_NAGLE                                 = 0x376B,
-    CMSG_ENABLE_TAXI_NODE                             = 0x34AC,
-    CMSG_ENGINE_SURVEY                                = 0x36E3,
+    CMSG_ENABLE_TAXI_NODE                             = 0x34A9,
+    CMSG_ENGINE_SURVEY                                = 0x36E4,
     CMSG_ENUM_CHARACTERS                              = 0x35E8,
-    CMSG_ENUM_CHARACTERS_DELETED_BY_CLIENT            = 0x36DD,
-    CMSG_FAR_SIGHT                                    = 0x34EC,
-    CMSG_GAME_OBJ_REPORT_USE                          = 0x34F3,
-    CMSG_GAME_OBJ_USE                                 = 0x34F2,
-    CMSG_GARRISON_ASSIGN_FOLLOWER_TO_BUILDING         = 0x32CB,
-    CMSG_GARRISON_CANCEL_CONSTRUCTION                 = 0x32BC,
-    CMSG_GARRISON_CHECK_UPGRADEABLE                   = 0x330E,
-    CMSG_GARRISON_COMPLETE_MISSION                    = 0x3301,
-    CMSG_GARRISON_GENERATE_RECRUITS                   = 0x32CE,
-    CMSG_GARRISON_GET_BUILDING_LANDMARKS              = 0x32DC,
-    CMSG_GARRISON_GET_MISSION_REWARD                  = 0x3334,
-    CMSG_GARRISON_MISSION_BONUS_ROLL                  = 0x3303,
-    CMSG_GARRISON_PURCHASE_BUILDING                   = 0x32B8,
-    CMSG_GARRISON_RECRUIT_FOLLOWER                    = 0x32D0,
-    CMSG_GARRISON_REMOVE_FOLLOWER                     = 0x32F8,
-    CMSG_GARRISON_REMOVE_FOLLOWER_FROM_BUILDING       = 0x32CC,
-    CMSG_GARRISON_RENAME_FOLLOWER                     = 0x32CD,
-    CMSG_GARRISON_REQUEST_BLUEPRINT_AND_SPECIALIZATION_DATA = 0x32B7,
-    CMSG_GARRISON_REQUEST_CLASS_SPEC_CATEGORY_INFO    = 0x32D5,
-    CMSG_GARRISON_REQUEST_LANDING_PAGE_SHIPMENT_INFO  = 0x32DF,
-    CMSG_GARRISON_REQUEST_SHIPMENT_INFO               = 0x32DE,
-    CMSG_GARRISON_RESEARCH_TALENT                     = 0x32D1,
-    CMSG_GARRISON_SET_BUILDING_ACTIVE                 = 0x32B9,
-    CMSG_GARRISON_SET_FOLLOWER_FAVORITE               = 0x32C9,
-    CMSG_GARRISON_SET_FOLLOWER_INACTIVE               = 0x32C5,
-    CMSG_GARRISON_SET_RECRUITMENT_PREFERENCES         = 0x32CF,
-    CMSG_GARRISON_START_MISSION                       = 0x3300,
-    CMSG_GARRISON_SWAP_BUILDINGS                      = 0x32BD,
+    CMSG_ENUM_CHARACTERS_DELETED_BY_CLIENT            = 0x36DE,
+    CMSG_FAR_SIGHT                                    = 0x34E9,
+    CMSG_GAME_EVENT_DEBUG_DISABLE                     = 0x31B0,
+    CMSG_GAME_EVENT_DEBUG_ENABLE                      = 0x31AF,
+    CMSG_GAME_OBJ_REPORT_USE                          = 0x34F0,
+    CMSG_GAME_OBJ_USE                                 = 0x34EF,
+    CMSG_GARRISON_ASSIGN_FOLLOWER_TO_BUILDING         = 0x32DA,
+    CMSG_GARRISON_CANCEL_CONSTRUCTION                 = 0x32CB,
+    CMSG_GARRISON_CHECK_UPGRADEABLE                   = 0x331D,
+    CMSG_GARRISON_COMPLETE_MISSION                    = 0x3310,
+    CMSG_GARRISON_GENERATE_RECRUITS                   = 0x32DD,
+    CMSG_GARRISON_GET_BUILDING_LANDMARKS              = 0x32EB,
+    CMSG_GARRISON_GET_MISSION_REWARD                  = 0x3341,
+    CMSG_GARRISON_MISSION_BONUS_ROLL                  = 0x3312,
+    CMSG_GARRISON_PURCHASE_BUILDING                   = 0x32C7,
+    CMSG_GARRISON_RECRUIT_FOLLOWER                    = 0x32DF,
+    CMSG_GARRISON_REMOVE_FOLLOWER                     = 0x3307,
+    CMSG_GARRISON_REMOVE_FOLLOWER_FROM_BUILDING       = 0x32DB,
+    CMSG_GARRISON_RENAME_FOLLOWER                     = 0x32DC,
+    CMSG_GARRISON_REQUEST_BLUEPRINT_AND_SPECIALIZATION_DATA = 0x32C6,
+    CMSG_GARRISON_REQUEST_CLASS_SPEC_CATEGORY_INFO    = 0x32E4,
+    CMSG_GARRISON_REQUEST_LANDING_PAGE_SHIPMENT_INFO  = 0x32EE,
+    CMSG_GARRISON_REQUEST_SHIPMENT_INFO               = 0x32ED,
+    CMSG_GARRISON_RESEARCH_TALENT                     = 0x32E0,
+    CMSG_GARRISON_SET_BUILDING_ACTIVE                 = 0x32C8,
+    CMSG_GARRISON_SET_FOLLOWER_FAVORITE               = 0x32D8,
+    CMSG_GARRISON_SET_FOLLOWER_INACTIVE               = 0x32D4,
+    CMSG_GARRISON_SET_RECRUITMENT_PREFERENCES         = 0x32DE,
+    CMSG_GARRISON_START_MISSION                       = 0x330F,
+    CMSG_GARRISON_SWAP_BUILDINGS                      = 0x32CC,
     CMSG_GENERATE_RANDOM_CHARACTER_NAME               = 0x35E7,
+    CMSG_GET_ACCOUNT_CHARACTER_LIST                   = 0x36B7,
     CMSG_GET_CHALLENGE_MODE_REWARDS                   = 0x3683,
-    CMSG_GET_GARRISON_INFO                            = 0x32B2,
-    CMSG_GET_ITEM_PURCHASE_DATA                       = 0x3533,
-    CMSG_GET_MIRROR_IMAGE_DATA                        = 0x3289,
+    CMSG_GET_GARRISON_INFO                            = 0x32C1,
+    CMSG_GET_ITEM_PURCHASE_DATA                       = 0x3531,
+    CMSG_GET_MIRROR_IMAGE_DATA                        = 0x3296,
     CMSG_GET_PVP_OPTIONS_ENABLED                      = 0x35EE,
-    CMSG_GET_REMAINING_GAME_TIME                      = 0x36EC,
-    CMSG_GET_TROPHY_LIST                              = 0x32F1,
-    CMSG_GET_UNDELETE_CHARACTER_COOLDOWN_STATUS       = 0x36DF,
-    CMSG_GM_TICKET_ACKNOWLEDGE_SURVEY                 = 0x3692,
-    CMSG_GM_TICKET_GET_CASE_STATUS                    = 0x3691,
-    CMSG_GM_TICKET_GET_SYSTEM_STATUS                  = 0x3690,
-    CMSG_GOSSIP_SELECT_OPTION                         = 0x3497,
-    CMSG_GRANT_LEVEL                                  = 0x34FB,
+    CMSG_GET_REMAINING_GAME_TIME                      = 0x36ED,
+    CMSG_GET_TROPHY_LIST                              = 0x3300,
+    CMSG_GET_UNDELETE_CHARACTER_COOLDOWN_STATUS       = 0x36E0,
+    CMSG_GM_TICKET_ACKNOWLEDGE_SURVEY                 = 0x3693,
+    CMSG_GM_TICKET_GET_CASE_STATUS                    = 0x3692,
+    CMSG_GM_TICKET_GET_SYSTEM_STATUS                  = 0x3691,
+    CMSG_GOSSIP_SELECT_OPTION                         = 0x3494,
+    CMSG_GRANT_LEVEL                                  = 0x34F8,
     CMSG_GUILD_ADD_BATTLENET_FRIEND                   = 0x308D,
     CMSG_GUILD_ADD_RANK                               = 0x3064,
     CMSG_GUILD_ASSIGN_MEMBER_RANK                     = 0x305F,
     CMSG_GUILD_AUTO_DECLINE_INVITATION                = 0x3061,
-    CMSG_GUILD_BANK_ACTIVATE                          = 0x34B9,
-    CMSG_GUILD_BANK_BUY_TAB                           = 0x34C8,
-    CMSG_GUILD_BANK_DEPOSIT_MONEY                     = 0x34CA,
+    CMSG_GUILD_BANK_ACTIVATE                          = 0x34B6,
+    CMSG_GUILD_BANK_BUY_TAB                           = 0x34C4,
+    CMSG_GUILD_BANK_DEPOSIT_MONEY                     = 0x34C6,
     CMSG_GUILD_BANK_LOG_QUERY                         = 0x3082,
-    CMSG_GUILD_BANK_QUERY_TAB                         = 0x34C7,
+    CMSG_GUILD_BANK_QUERY_TAB                         = 0x34C3,
     CMSG_GUILD_BANK_REMAINING_WITHDRAW_MONEY_QUERY    = 0x3083,
     CMSG_GUILD_BANK_SET_TAB_TEXT                      = 0x3086,
-    CMSG_GUILD_BANK_SWAP_ITEMS                        = 0x34BA,
     CMSG_GUILD_BANK_TEXT_QUERY                        = 0x3087,
-    CMSG_GUILD_BANK_UPDATE_TAB                        = 0x34C9,
-    CMSG_GUILD_BANK_WITHDRAW_MONEY                    = 0x34CB,
+    CMSG_GUILD_BANK_UPDATE_TAB                        = 0x34C5,
+    CMSG_GUILD_BANK_WITHDRAW_MONEY                    = 0x34C7,
     CMSG_GUILD_CHALLENGE_UPDATE_REQUEST               = 0x307B,
     CMSG_GUILD_CHANGE_NAME_REQUEST                    = 0x307E,
     CMSG_GUILD_DECLINE_INVITATION                     = 0x3060,
@@ -358,40 +359,41 @@ enum OpcodeClient : uint16
     CMSG_GUILD_REPLACE_GUILD_MASTER                   = 0x3088,
     CMSG_GUILD_SET_ACHIEVEMENT_TRACKING               = 0x306F,
     CMSG_GUILD_SET_FOCUSED_ACHIEVEMENT                = 0x3070,
-    CMSG_GUILD_SET_GUILD_MASTER                       = 0x36C5,
+    CMSG_GUILD_SET_GUILD_MASTER                       = 0x36C6,
     CMSG_GUILD_SET_MEMBER_NOTE                        = 0x3072,
     CMSG_GUILD_SET_RANK_PERMISSIONS                   = 0x3067,
     CMSG_GUILD_SHIFT_RANK                             = 0x3066,
     CMSG_GUILD_UPDATE_INFO_TEXT                       = 0x3075,
     CMSG_GUILD_UPDATE_MOTD_TEXT                       = 0x3074,
-    CMSG_HEARTH_AND_RESURRECT                         = 0x350C,
+    CMSG_HEARTH_AND_RESURRECT                         = 0x3509,
     CMSG_HOTFIX_REQUEST                               = 0x35E5,
     CMSG_IGNORE_TRADE                                 = 0x3159,
     CMSG_INITIATE_ROLE_POLL                           = 0x35DA,
     CMSG_INITIATE_TRADE                               = 0x3156,
-    CMSG_INSPECT                                      = 0x352D,
-    CMSG_INSPECT_PVP                                  = 0x36A1,
-    CMSG_INSTANCE_LOCK_RESPONSE                       = 0x3511,
-    CMSG_ITEM_PURCHASE_REFUND                         = 0x3534,
-    CMSG_ITEM_TEXT_QUERY                              = 0x330F,
-    CMSG_JOIN_PET_BATTLE_QUEUE                        = 0x31D4,
-    CMSG_JOIN_RATED_BATTLEGROUND                      = 0x3176,
+    CMSG_INSPECT                                      = 0x352B,
+    CMSG_INSPECT_PVP                                  = 0x36A2,
+    CMSG_INSTANCE_LOCK_RESPONSE                       = 0x350E,
+    CMSG_ISLAND_QUEUE                                 = 0x3387,
+    CMSG_ITEM_PURCHASE_REFUND                         = 0x3532,
+    CMSG_ITEM_TEXT_QUERY                              = 0x331E,
+    CMSG_JOIN_PET_BATTLE_QUEUE                        = 0x31DC,
+    CMSG_JOIN_RATED_BATTLEGROUND                      = 0x3177,
     CMSG_KEEP_ALIVE                                   = 0x367F,
-    CMSG_KEYBOUND_OVERRIDE                            = 0x3219,
-    CMSG_LEARN_PVP_TALENTS                            = 0x3557,
-    CMSG_LEARN_TALENTS                                = 0x3556,
+    CMSG_KEYBOUND_OVERRIDE                            = 0x3222,
+    CMSG_LEARN_PVP_TALENTS                            = 0x3556,
+    CMSG_LEARN_TALENTS                                = 0x3554,
     CMSG_LEAVE_GROUP                                  = 0x3649,
-    CMSG_LEAVE_PET_BATTLE_QUEUE                       = 0x31D5,
+    CMSG_LEAVE_PET_BATTLE_QUEUE                       = 0x31DD,
     CMSG_LFG_LIST_APPLY_TO_GROUP                      = 0x360C,
     CMSG_LFG_LIST_CANCEL_APPLICATION                  = 0x360D,
     CMSG_LFG_LIST_DECLINE_APPLICANT                   = 0x360E,
     CMSG_LFG_LIST_GET_STATUS                          = 0x360A,
     CMSG_LFG_LIST_INVITE_APPLICANT                    = 0x360F,
     CMSG_LFG_LIST_INVITE_RESPONSE                     = 0x3610,
-    CMSG_LFG_LIST_JOIN                                = 0x3345,
+    CMSG_LFG_LIST_JOIN                                = 0x3359,
     CMSG_LFG_LIST_LEAVE                               = 0x3609,
     CMSG_LFG_LIST_SEARCH                              = 0x360B,
-    CMSG_LFG_LIST_UPDATE_REQUEST                      = 0x3346,
+    CMSG_LFG_LIST_UPDATE_REQUEST                      = 0x335A,
     CMSG_LF_GUILD_ADD_RECRUIT                         = 0x361B,
     CMSG_LF_GUILD_BROWSE                              = 0x361D,
     CMSG_LF_GUILD_DECLINE_RECRUIT                     = 0x3078,
@@ -400,37 +402,38 @@ enum OpcodeClient : uint16
     CMSG_LF_GUILD_GET_RECRUITS                        = 0x3077,
     CMSG_LF_GUILD_REMOVE_RECRUIT                      = 0x307A,
     CMSG_LF_GUILD_SET_GUILD_POST                      = 0x361C,
-    CMSG_LIST_INVENTORY                               = 0x34A4,
-    CMSG_LIVE_REGION_ACCOUNT_RESTORE                  = 0x36B9,
-    CMSG_LIVE_REGION_CHARACTER_COPY                   = 0x36B8,
-    CMSG_LIVE_REGION_GET_ACCOUNT_CHARACTER_LIST       = 0x36B7,
+    CMSG_LIST_INVENTORY                               = 0x34A1,
+    CMSG_LIVE_REGION_ACCOUNT_RESTORE                  = 0x36BA,
+    CMSG_LIVE_REGION_CHARACTER_COPY                   = 0x36B9,
+    CMSG_LIVE_REGION_GET_ACCOUNT_CHARACTER_LIST       = 0x36B8,
     CMSG_LOADING_SCREEN_NOTIFY                        = 0x35F8,
-    CMSG_LOAD_SELECTED_TROPHY                         = 0x32F2,
-    CMSG_LOGOUT_CANCEL                                = 0x34DC,
-    CMSG_LOGOUT_INSTANT                               = 0x34DD,
-    CMSG_LOGOUT_REQUEST                               = 0x34DB,
+    CMSG_LOAD_SELECTED_TROPHY                         = 0x3301,
+    CMSG_LOGOUT_CANCEL                                = 0x34D9,
+    CMSG_LOGOUT_INSTANT                               = 0x34DA,
+    CMSG_LOGOUT_REQUEST                               = 0x34D7,
     CMSG_LOG_DISCONNECT                               = 0x3769,
     CMSG_LOG_STREAMING_ERROR                          = 0x376D,
-    CMSG_LOOT_ITEM                                    = 0x3205,
-    CMSG_LOOT_MONEY                                   = 0x3204,
-    CMSG_LOOT_RELEASE                                 = 0x3209,
-    CMSG_LOOT_ROLL                                    = 0x320A,
-    CMSG_LOOT_UNIT                                    = 0x3203,
-    CMSG_LOW_LEVEL_RAID1                              = 0x369F,
-    CMSG_LOW_LEVEL_RAID2                              = 0x3518,
-    CMSG_MAIL_CREATE_TEXT_ITEM                        = 0x353F,
-    CMSG_MAIL_DELETE                                  = 0x321B,
-    CMSG_MAIL_GET_LIST                                = 0x353A,
-    CMSG_MAIL_MARK_AS_READ                            = 0x353E,
+    CMSG_LOOT_ITEM                                    = 0x320E,
+    CMSG_LOOT_MONEY                                   = 0x320D,
+    CMSG_LOOT_RELEASE                                 = 0x3212,
+    CMSG_LOOT_ROLL                                    = 0x3213,
+    CMSG_LOOT_UNIT                                    = 0x320C,
+    CMSG_LOW_LEVEL_RAID1                              = 0x36A0,
+    CMSG_LOW_LEVEL_RAID2                              = 0x3515,
+    CMSG_MAIL_CREATE_TEXT_ITEM                        = 0x353D,
+    CMSG_MAIL_DELETE                                  = 0x3224,
+    CMSG_MAIL_GET_LIST                                = 0x3538,
+    CMSG_MAIL_MARK_AS_READ                            = 0x353C,
     CMSG_MAIL_RETURN_TO_SENDER                        = 0x3655,
-    CMSG_MAIL_TAKE_ITEM                               = 0x353C,
-    CMSG_MAIL_TAKE_MONEY                              = 0x353B,
-    CMSG_MASTER_LOOT_ITEM                             = 0x3206,
+    CMSG_MAIL_TAKE_ITEM                               = 0x353A,
+    CMSG_MAIL_TAKE_MONEY                              = 0x3539,
+    CMSG_MAKE_CONTITIONAL_APPEARANCE_PERMANENT        = 0x3227,
+    CMSG_MASTER_LOOT_ITEM                             = 0x320F,
     CMSG_MINIMAP_PING                                 = 0x364B,
-    CMSG_MISSILE_TRAJECTORY_COLLISION                 = 0x3189,
+    CMSG_MISSILE_TRAJECTORY_COLLISION                 = 0x318A,
     CMSG_MOUNT_CLEAR_FANFARE                          = 0x312D,
     CMSG_MOUNT_SET_FAVORITE                           = 0x3631,
-    CMSG_MOUNT_SPECIAL_ANIM                           = 0x3273,
+    CMSG_MOUNT_SPECIAL_ANIM                           = 0x3281,
     CMSG_MOVE_APPLY_MOVEMENT_FORCE_ACK                = 0x3A12,
     CMSG_MOVE_CHANGE_TRANSPORT                        = 0x3A2C,
     CMSG_MOVE_CHANGE_VEHICLE_SEATS                    = 0x3A31,
@@ -443,6 +446,7 @@ enum OpcodeClient : uint16
     CMSG_MOVE_FEATHER_FALL_ACK                        = 0x3A19,
     CMSG_MOVE_FORCE_FLIGHT_BACK_SPEED_CHANGE_ACK      = 0x3A2B,
     CMSG_MOVE_FORCE_FLIGHT_SPEED_CHANGE_ACK           = 0x3A2A,
+    CMSG_MOVE_FORCE_MOVEMENT_FORCE_SPEED_CHANGE_ACK   = 0x3A3D,
     CMSG_MOVE_FORCE_PITCH_RATE_CHANGE_ACK             = 0x3A2F,
     CMSG_MOVE_FORCE_ROOT_ACK                          = 0x3A0B,
     CMSG_MOVE_FORCE_RUN_BACK_SPEED_CHANGE_ACK         = 0x3A09,
@@ -492,264 +496,268 @@ enum OpcodeClient : uint16
     CMSG_MOVE_TIME_SKIPPED                            = 0x3A18,
     CMSG_MOVE_TOGGLE_COLLISION_CHEAT                  = 0x3A05,
     CMSG_MOVE_WATER_WALK_ACK                          = 0x3A1A,
-    CMSG_NEUTRAL_PLAYER_SELECT_FACTION                = 0x31CA,
-    CMSG_NEXT_CINEMATIC_CAMERA                        = 0x3548,
-    CMSG_OBJECT_UPDATE_FAILED                         = 0x317F,
-    CMSG_OBJECT_UPDATE_RESCUED                        = 0x3180,
-    CMSG_OFFER_PETITION                               = 0x36AF,
-    CMSG_OPENING_CINEMATIC                            = 0x3547,
-    CMSG_OPEN_ITEM                                    = 0x3310,
-    CMSG_OPEN_MISSION_NPC                             = 0x32D7,
-    CMSG_OPEN_SHIPMENT_NPC                            = 0x32DD,
-    CMSG_OPEN_TRADESKILL_NPC                          = 0x32E8,
-    CMSG_OPT_OUT_OF_LOOT                              = 0x34FA,
+    CMSG_NEUTRAL_PLAYER_SELECT_FACTION                = 0x31D2,
+    CMSG_NEXT_CINEMATIC_CAMERA                        = 0x3546,
+    CMSG_OBJECT_UPDATE_FAILED                         = 0x3180,
+    CMSG_OBJECT_UPDATE_RESCUED                        = 0x3181,
+    CMSG_OFFER_PETITION                               = 0x36B0,
+    CMSG_OPENING_CINEMATIC                            = 0x3545,
+    CMSG_OPEN_ITEM                                    = 0x331F,
+    CMSG_OPEN_MISSION_NPC                             = 0x32E6,
+    CMSG_OPEN_SHIPMENT_NPC                            = 0x32EC,
+    CMSG_OPEN_TRADESKILL_NPC                          = 0x32F7,
+    CMSG_OPT_OUT_OF_LOOT                              = 0x34F7,
     CMSG_PARTY_INVITE                                 = 0x3602,
     CMSG_PARTY_INVITE_RESPONSE                        = 0x3603,
     CMSG_PARTY_UNINVITE                               = 0x3647,
-    CMSG_PETITION_BUY                                 = 0x34CD,
-    CMSG_PETITION_RENAME_GUILD                        = 0x36C6,
-    CMSG_PETITION_SHOW_LIST                           = 0x34CC,
-    CMSG_PETITION_SHOW_SIGNATURES                     = 0x34CE,
-    CMSG_PET_ABANDON                                  = 0x3490,
-    CMSG_PET_ACTION                                   = 0x348E,
-    CMSG_PET_BATTLE_FINAL_NOTIFY                      = 0x31D9,
+    CMSG_PETITION_BUY                                 = 0x34C9,
+    CMSG_PETITION_RENAME_GUILD                        = 0x36C7,
+    CMSG_PETITION_SHOW_LIST                           = 0x34C8,
+    CMSG_PETITION_SHOW_SIGNATURES                     = 0x34CA,
+    CMSG_PET_ABANDON                                  = 0x348D,
+    CMSG_PET_ACTION                                   = 0x348B,
+    CMSG_PET_BATTLE_FINAL_NOTIFY                      = 0x31E1,
     CMSG_PET_BATTLE_INPUT                             = 0x3640,
-    CMSG_PET_BATTLE_QUEUE_PROPOSE_MATCH_RESULT        = 0x321A,
-    CMSG_PET_BATTLE_QUIT_NOTIFY                       = 0x31D8,
+    CMSG_PET_BATTLE_QUEUE_PROPOSE_MATCH_RESULT        = 0x3223,
+    CMSG_PET_BATTLE_QUIT_NOTIFY                       = 0x31E0,
     CMSG_PET_BATTLE_REPLACE_FRONT_PET                 = 0x3641,
-    CMSG_PET_BATTLE_REQUEST_PVP                       = 0x31D2,
-    CMSG_PET_BATTLE_REQUEST_UPDATE                    = 0x31D3,
-    CMSG_PET_BATTLE_REQUEST_WILD                      = 0x31D0,
-    CMSG_PET_BATTLE_SCRIPT_ERROR_NOTIFY               = 0x31DA,
-    CMSG_PET_BATTLE_WILD_LOCATION_FAIL                = 0x31D1,
-    CMSG_PET_CANCEL_AURA                              = 0x3491,
-    CMSG_PET_CAST_SPELL                               = 0x328D,
+    CMSG_PET_BATTLE_REQUEST_PVP                       = 0x31DA,
+    CMSG_PET_BATTLE_REQUEST_UPDATE                    = 0x31DB,
+    CMSG_PET_BATTLE_REQUEST_WILD                      = 0x31D8,
+    CMSG_PET_BATTLE_SCRIPT_ERROR_NOTIFY               = 0x31E2,
+    CMSG_PET_BATTLE_WILD_LOCATION_FAIL                = 0x31D9,
+    CMSG_PET_CANCEL_AURA                              = 0x348E,
+    CMSG_PET_CAST_SPELL                               = 0x329A,
     CMSG_PET_RENAME                                   = 0x3685,
-    CMSG_PET_SET_ACTION                               = 0x348D,
-    CMSG_PET_SPELL_AUTOCAST                           = 0x3492,
-    CMSG_PET_STOP_ATTACK                              = 0x348F,
+    CMSG_PET_SET_ACTION                               = 0x348A,
+    CMSG_PET_SPELL_AUTOCAST                           = 0x348F,
+    CMSG_PET_STOP_ATTACK                              = 0x348C,
     CMSG_PING                                         = 0x3768,
     CMSG_PLAYER_LOGIN                                 = 0x35EA,
     CMSG_PROTOCOL_MISMATCH                            = 0x376E,
-    CMSG_PUSH_QUEST_TO_PARTY                          = 0x34A2,
-    CMSG_PVP_LOG_DATA                                 = 0x317A,
-    CMSG_PVP_PRESTIGE_RANK_UP                         = 0x3332,
-    CMSG_QUERY_BATTLE_PET_NAME                        = 0x3268,
+    CMSG_PUSH_QUEST_TO_PARTY                          = 0x349F,
+    CMSG_PVP_LOG_DATA                                 = 0x317B,
+    CMSG_QUERY_BATTLE_PET_NAME                        = 0x3276,
+    CMSG_QUERY_COMMUNITY_NAME                         = 0x368C,
     CMSG_QUERY_CORPSE_LOCATION_FROM_CLIENT            = 0x3660,
     CMSG_QUERY_CORPSE_TRANSPORT                       = 0x3661,
-    CMSG_QUERY_COUNTDOWN_TIMER                        = 0x31A4,
-    CMSG_QUERY_CREATURE                               = 0x3262,
-    CMSG_QUERY_GAME_OBJECT                            = 0x3263,
-    CMSG_QUERY_GARRISON_CREATURE_NAME                 = 0x3269,
-    CMSG_QUERY_GUILD_INFO                             = 0x368D,
-    CMSG_QUERY_INSPECT_ACHIEVEMENTS                   = 0x3506,
-    CMSG_QUERY_NEXT_MAIL_TIME                         = 0x353D,
-    CMSG_QUERY_NPC_TEXT                               = 0x3264,
-    CMSG_QUERY_PAGE_TEXT                              = 0x3266,
-    CMSG_QUERY_PETITION                               = 0x326A,
-    CMSG_QUERY_PET_NAME                               = 0x3267,
+    CMSG_QUERY_COUNTDOWN_TIMER                        = 0x31A8,
+    CMSG_QUERY_CREATURE                               = 0x3270,
+    CMSG_QUERY_GAME_OBJECT                            = 0x3271,
+    CMSG_QUERY_GARRISON_CREATURE_NAME                 = 0x3277,
+    CMSG_QUERY_GUILD_INFO                             = 0x368E,
+    CMSG_QUERY_INSPECT_ACHIEVEMENTS                   = 0x3503,
+    CMSG_QUERY_NEXT_MAIL_TIME                         = 0x353B,
+    CMSG_QUERY_NPC_TEXT                               = 0x3272,
+    CMSG_QUERY_PAGE_TEXT                              = 0x3274,
+    CMSG_QUERY_PETITION                               = 0x3278,
+    CMSG_QUERY_PET_NAME                               = 0x3275,
     CMSG_QUERY_PLAYER_NAME                            = 0x368B,
-    CMSG_QUERY_QUEST_COMPLETION_NPCS                  = 0x3173,
-    CMSG_QUERY_QUEST_INFO                             = 0x3265,
-    CMSG_QUERY_QUEST_REWARDS                          = 0x3336,
-    CMSG_QUERY_REALM_NAME                             = 0x368C,
+    CMSG_QUERY_QUEST_COMPLETION_NPCS                  = 0x3174,
+    CMSG_QUERY_QUEST_INFO                             = 0x3273,
+    CMSG_QUERY_REALM_NAME                             = 0x368D,
     CMSG_QUERY_SCENARIO_POI                           = 0x3656,
-    CMSG_QUERY_TIME                                   = 0x34DA,
-    CMSG_QUERY_VOID_STORAGE                           = 0x319D,
-    CMSG_QUEST_CONFIRM_ACCEPT                         = 0x34A1,
-    CMSG_QUEST_GIVER_ACCEPT_QUEST                     = 0x349B,
-    CMSG_QUEST_GIVER_CHOOSE_REWARD                    = 0x349D,
-    CMSG_QUEST_GIVER_COMPLETE_QUEST                   = 0x349C,
-    CMSG_QUEST_GIVER_HELLO                            = 0x3499,
-    CMSG_QUEST_GIVER_QUERY_QUEST                      = 0x349A,
-    CMSG_QUEST_GIVER_REQUEST_REWARD                   = 0x349E,
-    CMSG_QUEST_GIVER_STATUS_MULTIPLE_QUERY            = 0x34A0,
-    CMSG_QUEST_GIVER_STATUS_QUERY                     = 0x349F,
-    CMSG_QUEST_LOG_REMOVE_QUEST                       = 0x3532,
-    CMSG_QUEST_POI_QUERY                              = 0x36B0,
-    CMSG_QUEST_PUSH_RESULT                            = 0x34A3,
+    CMSG_QUERY_TIME                                   = 0x34D6,
+    CMSG_QUERY_TREASURE_PICKER                        = 0x3343,
+    CMSG_QUERY_VOID_STORAGE                           = 0x31A1,
+    CMSG_QUEST_CONFIRM_ACCEPT                         = 0x349E,
+    CMSG_QUEST_GIVER_ACCEPT_QUEST                     = 0x3498,
+    CMSG_QUEST_GIVER_CHOOSE_REWARD                    = 0x349A,
+    CMSG_QUEST_GIVER_COMPLETE_QUEST                   = 0x3499,
+    CMSG_QUEST_GIVER_HELLO                            = 0x3496,
+    CMSG_QUEST_GIVER_QUERY_QUEST                      = 0x3497,
+    CMSG_QUEST_GIVER_REQUEST_REWARD                   = 0x349B,
+    CMSG_QUEST_GIVER_STATUS_MULTIPLE_QUERY            = 0x349D,
+    CMSG_QUEST_GIVER_STATUS_QUERY                     = 0x349C,
+    CMSG_QUEST_LOG_REMOVE_QUEST                       = 0x3530,
+    CMSG_QUEST_POI_QUERY                              = 0x36B1,
+    CMSG_QUEST_PUSH_RESULT                            = 0x34A0,
     CMSG_QUEUED_MESSAGES_END                          = 0x376C,
-    CMSG_QUICK_JOIN_AUTO_ACCEPT_REQUESTS              = 0x3705,
-    CMSG_QUICK_JOIN_REQUEST_INVITE                    = 0x3704,
-    CMSG_QUICK_JOIN_RESPOND_TO_INVITE                 = 0x3703,
-    CMSG_QUICK_JOIN_SIGNAL_TOAST_DISPLAYED            = 0x3702,
-    CMSG_RAID_OR_BATTLEGROUND_ENGINE_SURVEY           = 0x36E4,
+    CMSG_QUICK_JOIN_AUTO_ACCEPT_REQUESTS              = 0x3709,
+    CMSG_QUICK_JOIN_REQUEST_INVITE                    = 0x3708,
+    CMSG_QUICK_JOIN_RESPOND_TO_INVITE                 = 0x3707,
+    CMSG_QUICK_JOIN_SIGNAL_TOAST_DISPLAYED            = 0x3706,
+    CMSG_RAID_OR_BATTLEGROUND_ENGINE_SURVEY           = 0x36E5,
     CMSG_RANDOM_ROLL                                  = 0x3654,
     CMSG_READY_CHECK_RESPONSE                         = 0x3634,
-    CMSG_READ_ITEM                                    = 0x3311,
-    CMSG_RECLAIM_CORPSE                               = 0x34DF,
-    CMSG_RECRUIT_A_FRIEND                             = 0x36CC,
-    CMSG_REDEEM_WOW_TOKEN_CONFIRM                     = 0x36EE,
-    CMSG_REDEEM_WOW_TOKEN_START                       = 0x36ED,
-    CMSG_REMOVE_NEW_ITEM                              = 0x3339,
+    CMSG_READ_ITEM                                    = 0x3320,
+    CMSG_RECLAIM_CORPSE                               = 0x34DC,
+    CMSG_RECRUIT_A_FRIEND                             = 0x36CD,
+    CMSG_REDEEM_WOW_TOKEN_CONFIRM                     = 0x36EF,
+    CMSG_REDEEM_WOW_TOKEN_START                       = 0x36EE,
+    CMSG_REMOVE_NEW_ITEM                              = 0x3346,
     CMSG_REORDER_CHARACTERS                           = 0x35E9,
-    CMSG_REPAIR_ITEM                                  = 0x34F0,
-    CMSG_REPLACE_TROPHY                               = 0x32F3,
-    CMSG_REPOP_REQUEST                                = 0x352A,
-    CMSG_REPORT_CLIENT_VARIABLES                      = 0x36FF,
-    CMSG_REPORT_ENABLED_ADDONS                        = 0x36FE,
-    CMSG_REPORT_KEYBINDING_EXECUTION_COUNTS           = 0x3700,
-    CMSG_REPORT_PVP_PLAYER_AFK                        = 0x34F8,
-    CMSG_REQUEST_ACCOUNT_DATA                         = 0x3695,
-    CMSG_REQUEST_AREA_POI_UPDATE                      = 0x3338,
+    CMSG_REPAIR_ITEM                                  = 0x34ED,
+    CMSG_REPLACE_TROPHY                               = 0x3302,
+    CMSG_REPOP_REQUEST                                = 0x3528,
+    CMSG_REPORT_CLIENT_VARIABLES                      = 0x3703,
+    CMSG_REPORT_ENABLED_ADDONS                        = 0x3702,
+    CMSG_REPORT_KEYBINDING_EXECUTION_COUNTS           = 0x3704,
+    CMSG_REPORT_PVP_PLAYER_AFK                        = 0x34F5,
+    CMSG_REQUEST_ACCOUNT_DATA                         = 0x3696,
+    CMSG_REQUEST_AREA_POI_UPDATE                      = 0x3345,
     CMSG_REQUEST_BATTLEFIELD_STATUS                   = 0x35DC,
-    CMSG_REQUEST_CATEGORY_COOLDOWNS                   = 0x317C,
-    CMSG_REQUEST_CEMETERY_LIST                        = 0x3174,
-    CMSG_REQUEST_CONQUEST_FORMULA_CONSTANTS           = 0x32A4,
-    CMSG_REQUEST_CONSUMPTION_CONVERSION_INFO          = 0x36F8,
-    CMSG_REQUEST_CROWD_CONTROL_SPELL                  = 0x352E,
-    CMSG_REQUEST_FORCED_REACTIONS                     = 0x31FE,
-    CMSG_REQUEST_GUILD_PARTY_STATE                    = 0x31A3,
-    CMSG_REQUEST_GUILD_REWARDS_LIST                   = 0x31A2,
-    CMSG_REQUEST_HONOR_STATS                          = 0x3179,
-    CMSG_REQUEST_LFG_LIST_BLACKLIST                   = 0x3295,
+    CMSG_REQUEST_CATEGORY_COOLDOWNS                   = 0x317D,
+    CMSG_REQUEST_CEMETERY_LIST                        = 0x3175,
+    CMSG_REQUEST_CHALLENGE_MODE_AFFIXES               = 0x3205,
+    CMSG_REQUEST_CONQUEST_FORMULA_CONSTANTS           = 0x32B3,
+    CMSG_REQUEST_CONSUMPTION_CONVERSION_INFO          = 0x36FC,
+    CMSG_REQUEST_CROWD_CONTROL_SPELL                  = 0x352C,
+    CMSG_REQUEST_FORCED_REACTIONS                     = 0x3207,
+    CMSG_REQUEST_GUILD_PARTY_STATE                    = 0x31A7,
+    CMSG_REQUEST_GUILD_REWARDS_LIST                   = 0x31A6,
+    CMSG_REQUEST_HONOR_STATS                          = 0x317A,
+    CMSG_REQUEST_LFG_LIST_BLACKLIST                   = 0x32A3,
     CMSG_REQUEST_PARTY_JOIN_UPDATES                   = 0x35F7,
     CMSG_REQUEST_PARTY_MEMBER_STATS                   = 0x3653,
-    CMSG_REQUEST_PET_INFO                             = 0x3493,
-    CMSG_REQUEST_PLAYED_TIME                          = 0x326D,
-    CMSG_REQUEST_PVP_BRAWL_INFO                       = 0x3191,
-    CMSG_REQUEST_PVP_REWARDS                          = 0x3190,
-    CMSG_REQUEST_RAID_INFO                            = 0x36C7,
+    CMSG_REQUEST_PET_INFO                             = 0x3490,
+    CMSG_REQUEST_PLAYED_TIME                          = 0x327B,
+    CMSG_REQUEST_PVP_BRAWL_INFO                       = 0x3195,
+    CMSG_REQUEST_PVP_REWARDS                          = 0x3194,
+    CMSG_REQUEST_RAID_INFO                            = 0x36C8,
     CMSG_REQUEST_RATED_BATTLEFIELD_INFO               = 0x35E3,
     CMSG_REQUEST_RESEARCH_HISTORY                     = 0x3167,
-    CMSG_REQUEST_STABLED_PETS                         = 0x3494,
-    CMSG_REQUEST_VEHICLE_EXIT                         = 0x322B,
-    CMSG_REQUEST_VEHICLE_NEXT_SEAT                    = 0x322D,
-    CMSG_REQUEST_VEHICLE_PREV_SEAT                    = 0x322C,
-    CMSG_REQUEST_VEHICLE_SWITCH_SEAT                  = 0x322E,
-    CMSG_REQUEST_WORLD_QUEST_UPDATE                   = 0x3337,
-    CMSG_REQUEST_WOW_TOKEN_MARKET_PRICE               = 0x36E6,
-    CMSG_RESET_CHALLENGE_MODE                         = 0x31FB,
-    CMSG_RESET_CHALLENGE_MODE_CHEAT                   = 0x31FC,
+    CMSG_REQUEST_STABLED_PETS                         = 0x3491,
+    CMSG_REQUEST_VEHICLE_EXIT                         = 0x3234,
+    CMSG_REQUEST_VEHICLE_NEXT_SEAT                    = 0x3236,
+    CMSG_REQUEST_VEHICLE_PREV_SEAT                    = 0x3235,
+    CMSG_REQUEST_VEHICLE_SWITCH_SEAT                  = 0x3237,
+    CMSG_REQUEST_WORLD_QUEST_UPDATE                   = 0x3344,
+    CMSG_REQUEST_WOW_TOKEN_MARKET_PRICE               = 0x36E7,
+    CMSG_RESET_CHALLENGE_MODE                         = 0x3203,
+    CMSG_RESET_CHALLENGE_MODE_CHEAT                   = 0x3204,
     CMSG_RESET_INSTANCES                              = 0x3668,
     CMSG_RESURRECT_RESPONSE                           = 0x3684,
-    CMSG_REVERT_MONUMENT_APPEARANCE                   = 0x32F5,
-    CMSG_RIDE_VEHICLE_INTERACT                        = 0x322F,
-    CMSG_SAVE_CUF_PROFILES                            = 0x318A,
-    CMSG_SAVE_EQUIPMENT_SET                           = 0x350F,
-    CMSG_SAVE_GUILD_EMBLEM                            = 0x3299,
-    CMSG_SCENE_PLAYBACK_CANCELED                      = 0x3216,
-    CMSG_SCENE_PLAYBACK_COMPLETE                      = 0x3215,
-    CMSG_SCENE_TRIGGER_EVENT                          = 0x3217,
-    CMSG_SELF_RES                                     = 0x3535,
-    CMSG_SELL_ITEM                                    = 0x34A5,
-    CMSG_SELL_WOW_TOKEN_CONFIRM                       = 0x36E8,
-    CMSG_SELL_WOW_TOKEN_START                         = 0x36E7,
-    CMSG_SEND_CONTACT_LIST                            = 0x36CE,
+    CMSG_REVERT_MONUMENT_APPEARANCE                   = 0x3304,
+    CMSG_RIDE_VEHICLE_INTERACT                        = 0x3238,
+    CMSG_SAVE_CUF_PROFILES                            = 0x318B,
+    CMSG_SAVE_EQUIPMENT_SET                           = 0x350C,
+    CMSG_SAVE_GUILD_EMBLEM                            = 0x32A7,
+    CMSG_SCENE_PLAYBACK_CANCELED                      = 0x321F,
+    CMSG_SCENE_PLAYBACK_COMPLETE                      = 0x321E,
+    CMSG_SCENE_TRIGGER_EVENT                          = 0x3220,
+    CMSG_SELF_RES                                     = 0x3533,
+    CMSG_SELL_ITEM                                    = 0x34A2,
+    CMSG_SELL_WOW_TOKEN_CONFIRM                       = 0x36E9,
+    CMSG_SELL_WOW_TOKEN_START                         = 0x36E8,
+    CMSG_SEND_CONTACT_LIST                            = 0x36CF,
     CMSG_SEND_MAIL                                    = 0x35FA,
     CMSG_SEND_SOR_REQUEST_VIA_ADDRESS                 = 0x3620,
-    CMSG_SEND_TEXT_EMOTE                              = 0x348A,
-    CMSG_SET_ACHIEVEMENTS_HIDDEN                      = 0x321C,
-    CMSG_SET_ACTION_BAR_TOGGLES                       = 0x3536,
+    CMSG_SEND_TEXT_EMOTE                              = 0x3488,
+    CMSG_SET_ACHIEVEMENTS_HIDDEN                      = 0x3225,
+    CMSG_SET_ACTION_BAR_TOGGLES                       = 0x3534,
     CMSG_SET_ACTION_BUTTON                            = 0x3635,
     CMSG_SET_ACTIVE_MOVER                             = 0x3A37,
-    CMSG_SET_ADVANCED_COMBAT_LOGGING                  = 0x32A5,
+    CMSG_SET_ADVANCED_COMBAT_LOGGING                  = 0x32B4,
     CMSG_SET_ASSISTANT_LEADER                         = 0x364F,
-    CMSG_SET_BACKPACK_AUTOSORT_DISABLED               = 0x3314,
-    CMSG_SET_BANK_AUTOSORT_DISABLED                   = 0x3315,
-    CMSG_SET_BANK_BAG_SLOT_FLAG                       = 0x3313,
-    CMSG_SET_CONTACT_NOTES                            = 0x36D1,
+    CMSG_SET_BACKPACK_AUTOSORT_DISABLED               = 0x3323,
+    CMSG_SET_BANK_AUTOSORT_DISABLED                   = 0x3324,
+    CMSG_SET_CONTACT_NOTES                            = 0x36D2,
     CMSG_SET_CURRENCY_FLAGS                           = 0x3169,
-    CMSG_SET_DIFFICULTY_ID                            = 0x3218,
+    CMSG_SET_DIFFICULTY_ID                            = 0x3221,
     CMSG_SET_DUNGEON_DIFFICULTY                       = 0x3682,
     CMSG_SET_EVERYONE_IS_ASSISTANT                    = 0x3617,
-    CMSG_SET_FACTION_AT_WAR                           = 0x34E2,
-    CMSG_SET_FACTION_INACTIVE                         = 0x34E4,
-    CMSG_SET_FACTION_NOT_AT_WAR                       = 0x34E3,
-    CMSG_SET_INSERT_ITEMS_LEFT_TO_RIGHT               = 0x3317,
-    CMSG_SET_LFG_BONUS_FACTION_ID                     = 0x3294,
+    CMSG_SET_FACTION_AT_WAR                           = 0x34DF,
+    CMSG_SET_FACTION_INACTIVE                         = 0x34E1,
+    CMSG_SET_FACTION_NOT_AT_WAR                       = 0x34E0,
+    CMSG_SET_GAME_EVENT_DEBUG_VIEW_STATE              = 0x31B8,
+    CMSG_SET_INSERT_ITEMS_LEFT_TO_RIGHT               = 0x3326,
+    CMSG_SET_LFG_BONUS_FACTION_ID                     = 0x32A2,
     CMSG_SET_LOOT_METHOD                              = 0x3648,
-    CMSG_SET_LOOT_SPECIALIZATION                      = 0x3543,
+    CMSG_SET_LOOT_SPECIALIZATION                      = 0x3541,
     CMSG_SET_PARTY_ASSIGNMENT                         = 0x3651,
     CMSG_SET_PARTY_LEADER                             = 0x364A,
     CMSG_SET_PET_SLOT                                 = 0x3168,
     CMSG_SET_PLAYER_DECLINED_NAMES                    = 0x368A,
-    CMSG_SET_PREFERRED_CEMETERY                       = 0x3175,
-    CMSG_SET_PVP                                      = 0x329D,
-    CMSG_SET_RAID_DIFFICULTY                          = 0x36DB,
+    CMSG_SET_PREFERRED_CEMETERY                       = 0x3176,
+    CMSG_SET_PVP                                      = 0x32AB,
+    CMSG_SET_RAID_DIFFICULTY                          = 0x36DC,
     CMSG_SET_ROLE                                     = 0x35D9,
     CMSG_SET_SAVED_INSTANCE_EXTEND                    = 0x3688,
-    CMSG_SET_SELECTION                                = 0x352C,
-    CMSG_SET_SHEATHED                                 = 0x348B,
-    CMSG_SET_SORT_BAGS_RIGHT_TO_LEFT                  = 0x3316,
-    CMSG_SET_TAXI_BENCHMARK_MODE                      = 0x34F7,
-    CMSG_SET_TITLE                                    = 0x3271,
+    CMSG_SET_SELECTION                                = 0x352A,
+    CMSG_SET_SHEATHED                                 = 0x3489,
+    CMSG_SET_SORT_BAGS_RIGHT_TO_LEFT                  = 0x3325,
+    CMSG_SET_TAXI_BENCHMARK_MODE                      = 0x34F4,
+    CMSG_SET_TITLE                                    = 0x327F,
     CMSG_SET_TRADE_CURRENCY                           = 0x3160,
     CMSG_SET_TRADE_GOLD                               = 0x315F,
     CMSG_SET_TRADE_ITEM                               = 0x315D,
-    CMSG_SET_USING_PARTY_GARRISON                     = 0x32D9,
-    CMSG_SET_WATCHED_FACTION                          = 0x34E5,
-    CMSG_SHOW_TRADE_SKILL                             = 0x36BF,
-    CMSG_SIGN_PETITION                                = 0x3537,
+    CMSG_SET_USING_PARTY_GARRISON                     = 0x32E8,
+    CMSG_SET_WAR_MODE                                 = 0x32AC,
+    CMSG_SET_WATCHED_FACTION                          = 0x34E2,
+    CMSG_SHOW_TRADE_SKILL                             = 0x36C0,
+    CMSG_SIGN_PETITION                                = 0x3535,
     CMSG_SILENCE_PARTY_TALKER                         = 0x3652,
-    CMSG_SOCKET_GEMS                                  = 0x34EF,
-    CMSG_SORT_BAGS                                    = 0x3318,
-    CMSG_SORT_BANK_BAGS                               = 0x3319,
-    CMSG_SORT_REAGENT_BANK_BAGS                       = 0x331A,
-    CMSG_SPELL_CLICK                                  = 0x3498,
-    CMSG_SPIRIT_HEALER_ACTIVATE                       = 0x34B2,
+    CMSG_SOCKET_GEMS                                  = 0x34EC,
+    CMSG_SORT_BAGS                                    = 0x3327,
+    CMSG_SORT_BANK_BAGS                               = 0x3328,
+    CMSG_SORT_REAGENT_BANK_BAGS                       = 0x3329,
+    CMSG_SPELL_CLICK                                  = 0x3495,
+    CMSG_SPIRIT_HEALER_ACTIVATE                       = 0x34AF,
     CMSG_SPLIT_ITEM                                   = 0x399E,
-    CMSG_STAND_STATE_CHANGE                           = 0x3188,
-    CMSG_START_CHALLENGE_MODE                         = 0x354E,
+    CMSG_STAND_STATE_CHANGE                           = 0x3189,
+    CMSG_START_CHALLENGE_MODE                         = 0x354C,
     CMSG_START_SPECTATOR_WAR_GAME                     = 0x35DF,
     CMSG_START_WAR_GAME                               = 0x35DE,
     CMSG_SUMMON_RESPONSE                              = 0x366A,
     CMSG_SUPPORT_TICKET_SUBMIT_BUG                    = 0x3645,
     CMSG_SUPPORT_TICKET_SUBMIT_COMPLAINT              = 0x3644,
     CMSG_SUPPORT_TICKET_SUBMIT_SUGGESTION             = 0x3646,
-    CMSG_SURRENDER_ARENA                              = 0x3172,
+    CMSG_SURRENDER_ARENA                              = 0x3173,
     CMSG_SUSPEND_COMMS_ACK                            = 0x3764,
     CMSG_SUSPEND_TOKEN_RESPONSE                       = 0x376A,
     CMSG_SWAP_INV_ITEM                                = 0x399D,
     CMSG_SWAP_ITEM                                    = 0x399C,
     CMSG_SWAP_SUB_GROUPS                              = 0x364D,
-    CMSG_SWAP_VOID_ITEM                               = 0x319F,
-    CMSG_TABARD_VENDOR_ACTIVATE                       = 0x329A,
-    CMSG_TALK_TO_GOSSIP                               = 0x3495,
-    CMSG_TAXI_NODE_STATUS_QUERY                       = 0x34AB,
-    CMSG_TAXI_QUERY_AVAILABLE_NODES                   = 0x34AD,
-    CMSG_TAXI_REQUEST_EARLY_LANDING                   = 0x34AF,
+    CMSG_SWAP_VOID_ITEM                               = 0x31A3,
+    CMSG_TABARD_VENDOR_ACTIVATE                       = 0x32A8,
+    CMSG_TALK_TO_GOSSIP                               = 0x3492,
+    CMSG_TAXI_NODE_STATUS_QUERY                       = 0x34A8,
+    CMSG_TAXI_QUERY_AVAILABLE_NODES                   = 0x34AA,
+    CMSG_TAXI_REQUEST_EARLY_LANDING                   = 0x34AC,
     CMSG_TIME_ADJUSTMENT_RESPONSE                     = 0x3A3B,
     CMSG_TIME_SYNC_RESPONSE                           = 0x3A38,
     CMSG_TIME_SYNC_RESPONSE_DROPPED                   = 0x3A3A,
     CMSG_TIME_SYNC_RESPONSE_FAILED                    = 0x3A39,
     CMSG_TOGGLE_DIFFICULTY                            = 0x3657,
-    CMSG_TOGGLE_PVP                                   = 0x329C,
-    CMSG_TOTEM_DESTROYED                              = 0x34FE,
-    CMSG_TRADE_SKILL_SET_FAVORITE                     = 0x3335,
-    CMSG_TRAINER_BUY_SPELL                            = 0x34B1,
-    CMSG_TRAINER_LIST                                 = 0x34B0,
-    CMSG_TRANSMOGRIFY_ITEMS                           = 0x3192,
-    CMSG_TURN_IN_PETITION                             = 0x3539,
-    CMSG_TUTORIAL                                     = 0x36DC,
+    CMSG_TOGGLE_PVP                                   = 0x32AA,
+    CMSG_TOTEM_DESTROYED                              = 0x34FB,
+    CMSG_TRADE_SKILL_SET_FAVORITE                     = 0x3342,
+    CMSG_TRAINER_BUY_SPELL                            = 0x34AE,
+    CMSG_TRAINER_LIST                                 = 0x34AD,
+    CMSG_TRANSMOGRIFY_ITEMS                           = 0x3196,
+    CMSG_TURN_IN_PETITION                             = 0x3537,
+    CMSG_TUTORIAL                                     = 0x36DD,
     CMSG_TWITTER_CHECK_STATUS                         = 0x312A,
     CMSG_TWITTER_CONNECT                              = 0x3127,
     CMSG_TWITTER_DISCONNECT                           = 0x312B,
-    CMSG_TWITTER_POST                                 = 0x331C,
-    CMSG_UI_TIME_REQUEST                              = 0x369A,
+    CMSG_TWITTER_POST                                 = 0x332B,
+    CMSG_UI_TIME_REQUEST                              = 0x369B,
     CMSG_UNACCEPT_TRADE                               = 0x315B,
-    CMSG_UNDELETE_CHARACTER                           = 0x36DE,
-    CMSG_UNLEARN_SKILL                                = 0x34E9,
-    CMSG_UNLEARN_SPECIALIZATION                       = 0x31A0,
-    CMSG_UNLOCK_VOID_STORAGE                          = 0x319C,
-    CMSG_UPDATE_ACCOUNT_DATA                          = 0x3696,
-    CMSG_UPDATE_AREA_TRIGGER_VISUAL                   = 0x3290,
+    CMSG_UNDELETE_CHARACTER                           = 0x36DF,
+    CMSG_UNLEARN_SKILL                                = 0x34E6,
+    CMSG_UNLEARN_SPECIALIZATION                       = 0x31A4,
+    CMSG_UNLOCK_VOID_STORAGE                          = 0x31A0,
+    CMSG_UPDATE_ACCOUNT_DATA                          = 0x3697,
+    CMSG_UPDATE_AREA_TRIGGER_VISUAL                   = 0x329D,
     CMSG_UPDATE_CLIENT_SETTINGS                       = 0x3664,
     CMSG_UPDATE_MISSILE_TRAJECTORY                    = 0x3A3E,
     CMSG_UPDATE_RAID_TARGET                           = 0x3650,
-    CMSG_UPDATE_SPELL_VISUAL                          = 0x328F,
-    CMSG_UPDATE_VAS_PURCHASE_STATES                   = 0x36F4,
-    CMSG_UPDATE_WOW_TOKEN_AUCTIONABLE_LIST            = 0x36EF,
-    CMSG_UPDATE_WOW_TOKEN_COUNT                       = 0x36E5,
-    CMSG_UPGRADE_GARRISON                             = 0x32AD,
-    CMSG_UPGRADE_ITEM                                 = 0x321D,
-    CMSG_USED_FOLLOW                                  = 0x3185,
-    CMSG_USE_CRITTER_ITEM                             = 0x3235,
+    CMSG_UPDATE_SPELL_VISUAL                          = 0x329C,
+    CMSG_UPDATE_VAS_PURCHASE_STATES                   = 0x36F5,
+    CMSG_UPDATE_WOW_TOKEN_AUCTIONABLE_LIST            = 0x36F0,
+    CMSG_UPDATE_WOW_TOKEN_COUNT                       = 0x36E6,
+    CMSG_UPGRADE_GARRISON                             = 0x32BC,
+    CMSG_UPGRADE_ITEM                                 = 0x3226,
+    CMSG_USED_FOLLOW                                  = 0x3186,
+    CMSG_USE_CRITTER_ITEM                             = 0x323E,
     CMSG_USE_EQUIPMENT_SET                            = 0x3995,
-    CMSG_USE_ITEM                                     = 0x328A,
-    CMSG_USE_TOY                                      = 0x328C,
-    CMSG_VIOLENCE_LEVEL                               = 0x3183,
-    CMSG_VOID_STORAGE_TRANSFER                        = 0x319E,
+    CMSG_USE_ITEM                                     = 0x3297,
+    CMSG_USE_TOY                                      = 0x3299,
+    CMSG_VIOLENCE_LEVEL                               = 0x3184,
+    CMSG_VOICE_CHAT_JOIN_CHANNEL                      = 0x3712,
+    CMSG_VOICE_CHAT_LOGIN                             = 0x3711,
+    CMSG_VOID_STORAGE_TRANSFER                        = 0x31A2,
     CMSG_WARDEN_DATA                                  = 0x35EC,
     CMSG_WHO                                          = 0x3681,
     CMSG_WHO_IS                                       = 0x3680,
@@ -764,63 +772,65 @@ enum OpcodeClient : uint16
 enum OpcodeServer : uint16
 {
     SMSG_ABORT_NEW_WORLD                              = 0x25AD,
-    SMSG_ACCOUNT_CRITERIA_UPDATE                      = 0x2652,
-    SMSG_ACCOUNT_DATA_TIMES                           = 0x2749,
+    SMSG_ACCOUNT_CRITERIA_UPDATE                      = 0x2654,
+    SMSG_ACCOUNT_DATA_TIMES                           = 0x2752,
     SMSG_ACCOUNT_MOUNT_UPDATE                         = 0x25C3,
     SMSG_ACCOUNT_TOYS_UPDATE                          = 0x25C4,
-    SMSG_ACHIEVEMENT_DELETED                          = 0x271E,
-    SMSG_ACHIEVEMENT_EARNED                           = 0x2660,
-    SMSG_ACTIVATE_TAXI_REPLY                          = 0x26A6,
+    SMSG_ACHIEVEMENT_DELETED                          = 0x2727,
+    SMSG_ACHIEVEMENT_EARNED                           = 0x2662,
+    SMSG_ACTIVATE_TAXI_REPLY                          = 0x26AB,
     SMSG_ACTIVE_GLYPHS                                = 0x2C53,
-    SMSG_ADD_BATTLENET_FRIEND_RESPONSE                = 0x265A,
+    SMSG_ADD_BATTLENET_FRIEND_RESPONSE                = 0x265C,
     SMSG_ADD_ITEM_PASSIVE                             = 0x25BF,
-    SMSG_ADD_LOSS_OF_CONTROL                          = 0x2696,
-    SMSG_ADD_RUNE_POWER                               = 0x26E2,
+    SMSG_ADD_LOSS_OF_CONTROL                          = 0x269B,
+    SMSG_ADD_RUNE_POWER                               = 0x26EA,
     SMSG_ADJUST_SPLINE_DURATION                       = 0x25E8,
-    SMSG_AE_LOOT_TARGETS                              = 0x262C,
-    SMSG_AE_LOOT_TARGET_ACK                           = 0x262D,
-    SMSG_AI_REACTION                                  = 0x26DF,
+    SMSG_ADVENTURE_MAP_POI_QUERY_RESPONSE             = 0x2845,
+    SMSG_AE_LOOT_TARGETS                              = 0x262E,
+    SMSG_AE_LOOT_TARGET_ACK                           = 0x262F,
+    SMSG_AI_REACTION                                  = 0x26E7,
     SMSG_ALL_ACCOUNT_CRITERIA                         = 0x2570,
     SMSG_ALL_ACHIEVEMENT_DATA                         = 0x256F,
     SMSG_ALL_GUILD_ACHIEVEMENTS                       = 0x29B8,
     SMSG_ARCHAEOLOGY_SURVERY_CAST                     = 0x2586,
-    SMSG_AREA_POI_UPDATE                              = 0x2848,
-    SMSG_AREA_SPIRIT_HEALER_TIME                      = 0x2782,
-    SMSG_AREA_TRIGGER_DENIED                          = 0x269D,
-    SMSG_AREA_TRIGGER_NO_CORPSE                       = 0x2755,
-    SMSG_AREA_TRIGGER_RE_PATH                         = 0x263F,
-    SMSG_AREA_TRIGGER_RE_SHAPE                        = 0x263C,
-    SMSG_ARENA_CROWD_CONTROL_SPELLS                   = 0x264E,
-    SMSG_ARENA_ERROR                                  = 0x2711,
-    SMSG_ARENA_PREP_OPPONENT_SPECIALIZATIONS          = 0x2665,
-    SMSG_ARTIFACT_FORGE_OPENED                        = 0x27E2,
-    SMSG_ARTIFACT_KNOWLEDGE                           = 0x27EA,
-    SMSG_ARTIFACT_RESPEC_CONFIRM                      = 0x27E5,
-    SMSG_ARTIFACT_TRAITS_REFUNDED                     = 0x27E6,
-    SMSG_ARTIFACT_XP_GAIN                             = 0x282D,
-    SMSG_ATTACKER_STATE_UPDATE                        = 0x27CF,
-    SMSG_ATTACK_START                                 = 0x266D,
-    SMSG_ATTACK_STOP                                  = 0x266E,
-    SMSG_ATTACK_SWING_ERROR                           = 0x2733,
-    SMSG_ATTACK_SWING_LANDED_LOG                      = 0x2734,
-    SMSG_AUCTION_CLOSED_NOTIFICATION                  = 0x2728,
-    SMSG_AUCTION_COMMAND_RESULT                       = 0x2725,
-    SMSG_AUCTION_HELLO_RESPONSE                       = 0x2723,
-    SMSG_AUCTION_LIST_BIDDER_ITEMS_RESULT             = 0x272C,
-    SMSG_AUCTION_LIST_ITEMS_RESULT                    = 0x272A,
-    SMSG_AUCTION_LIST_OWNER_ITEMS_RESULT              = 0x272B,
-    SMSG_AUCTION_LIST_PENDING_SALES_RESULT            = 0x272D,
-    SMSG_AUCTION_OUTBID_NOTIFICATION                  = 0x2727,
-    SMSG_AUCTION_OWNER_BID_NOTIFICATION               = 0x2729,
-    SMSG_AUCTION_REPLICATE_RESPONSE                   = 0x2724,
-    SMSG_AUCTION_WON_NOTIFICATION                     = 0x2726,
+    SMSG_AREA_POI_UPDATE                              = 0x2852,
+    SMSG_AREA_SPIRIT_HEALER_TIME                      = 0x278A,
+    SMSG_AREA_TRIGGER_DENIED                          = 0x26A2,
+    SMSG_AREA_TRIGGER_NO_CORPSE                       = 0x275E,
+    SMSG_AREA_TRIGGER_RE_PATH                         = 0x263E,
+    SMSG_AREA_TRIGGER_RE_SHAPE                        = 0x2642,
+    SMSG_ARENA_CROWD_CONTROL_SPELLS                   = 0x2650,
+    SMSG_ARENA_ERROR                                  = 0x271A,
+    SMSG_ARENA_PREP_OPPONENT_SPECIALIZATIONS          = 0x2667,
+    SMSG_ARTIFACT_FORGE_OPENED                        = 0x27EE,
+    SMSG_ARTIFACT_RESPEC_CONFIRM                      = 0x27F1,
+    SMSG_ARTIFACT_TRAITS_REFUNDED                     = 0x27F2,
+    SMSG_ARTIFACT_XP_GAIN                             = 0x2835,
+    SMSG_ATTACKER_STATE_UPDATE                        = 0x27DB,
+    SMSG_ATTACK_START                                 = 0x266F,
+    SMSG_ATTACK_STOP                                  = 0x2670,
+    SMSG_ATTACK_SWING_ERROR                           = 0x273C,
+    SMSG_ATTACK_SWING_LANDED_LOG                      = 0x273D,
+    SMSG_AUCTION_CLOSED_NOTIFICATION                  = 0x2731,
+    SMSG_AUCTION_COMMAND_RESULT                       = 0x272E,
+    SMSG_AUCTION_HELLO_RESPONSE                       = 0x272C,
+    SMSG_AUCTION_LIST_BIDDER_ITEMS_RESULT             = 0x2735,
+    SMSG_AUCTION_LIST_ITEMS_RESULT                    = 0x2733,
+    SMSG_AUCTION_LIST_OWNER_ITEMS_RESULT              = 0x2734,
+    SMSG_AUCTION_LIST_PENDING_SALES_RESULT            = 0x2736,
+    SMSG_AUCTION_OUTBID_NOTIFICATION                  = 0x2730,
+    SMSG_AUCTION_OWNER_BID_NOTIFICATION               = 0x2732,
+    SMSG_AUCTION_REPLICATE_RESPONSE                   = 0x272D,
+    SMSG_AUCTION_WON_NOTIFICATION                     = 0x272F,
     SMSG_AURA_POINTS_DEPLETED                         = 0x2C23,
     SMSG_AURA_UPDATE                                  = 0x2C22,
     SMSG_AUTH_CHALLENGE                               = 0x3048,
     SMSG_AUTH_RESPONSE                                = 0x256C,
     SMSG_AVAILABLE_HOTFIXES                           = 0x25A1,
-    SMSG_BAN_REASON                                   = 0x26B2,
-    SMSG_BARBER_SHOP_RESULT                           = 0x26E8,
+    SMSG_AZERITE_EMPOWERED_ITEM_RESPEC_OPEN           = 0x283F,
+    SMSG_AZERITE_XP_GAIN                              = 0x2878,
+    SMSG_BAN_REASON                                   = 0x26B7,
+    SMSG_BARBER_SHOP_RESULT                           = 0x26F0,
     SMSG_BATTLEFIELD_LIST                             = 0x2594,
     SMSG_BATTLEFIELD_PORT_DENIED                      = 0x259A,
     SMSG_BATTLEFIELD_STATUS_ACTIVE                    = 0x2590,
@@ -830,125 +840,130 @@ enum OpcodeServer : uint16
     SMSG_BATTLEFIELD_STATUS_QUEUED                    = 0x2591,
     SMSG_BATTLEFIELD_STATUS_WAIT_FOR_GROUPS           = 0x25A5,
     SMSG_BATTLEGROUND_INFO_THROTTLED                  = 0x259B,
-    SMSG_BATTLEGROUND_INIT                            = 0x27A0,
+    SMSG_BATTLEGROUND_INIT                            = 0x27A9,
     SMSG_BATTLEGROUND_PLAYER_JOINED                   = 0x2598,
     SMSG_BATTLEGROUND_PLAYER_LEFT                     = 0x2599,
     SMSG_BATTLEGROUND_PLAYER_POSITIONS                = 0x2595,
-    SMSG_BATTLEGROUND_POINTS                          = 0x279F,
-    SMSG_BATTLENET_CHALLENGE_ABORT                    = 0x27CE,
-    SMSG_BATTLENET_CHALLENGE_START                    = 0x27CD,
-    SMSG_BATTLENET_NOTIFICATION                       = 0x2843,
-    SMSG_BATTLENET_REALM_LIST_TICKET                  = 0x2845,
-    SMSG_BATTLENET_RESPONSE                           = 0x2842,
-    SMSG_BATTLENET_SET_SESSION_STATE                  = 0x2844,
-    SMSG_BATTLE_PAY_ACK_FAILED                        = 0x27C6,
-    SMSG_BATTLE_PAY_BATTLE_PET_DELIVERED              = 0x27BB,
-    SMSG_BATTLE_PAY_CONFIRM_PURCHASE                  = 0x27C5,
-    SMSG_BATTLE_PAY_DELIVERY_ENDED                    = 0x27B9,
-    SMSG_BATTLE_PAY_DELIVERY_STARTED                  = 0x27B8,
-    SMSG_BATTLE_PAY_DISTRIBUTION_UPDATE               = 0x27B7,
-    SMSG_BATTLE_PAY_GET_DISTRIBUTION_LIST_RESPONSE    = 0x27B5,
-    SMSG_BATTLE_PAY_GET_PRODUCT_LIST_RESPONSE         = 0x27B3,
-    SMSG_BATTLE_PAY_GET_PURCHASE_LIST_RESPONSE        = 0x27B4,
-    SMSG_BATTLE_PAY_MOUNT_DELIVERED                   = 0x27BA,
-    SMSG_BATTLE_PAY_PURCHASE_UPDATE                   = 0x27C4,
-    SMSG_BATTLE_PAY_START_DISTRIBUTION_ASSIGN_TO_TARGET_RESPONSE = 0x27C2,
-    SMSG_BATTLE_PAY_START_PURCHASE_RESPONSE           = 0x27C1,
-    SMSG_BATTLE_PAY_SUBSCRIPTION_CHANGED              = 0x2864,
-    SMSG_BATTLE_PAY_VAS_BNET_TRANSFER_VALIDATION_RESULT = 0x285B,
-    SMSG_BATTLE_PAY_VAS_BOOST_CONSUMED                = 0x27B6,
-    SMSG_BATTLE_PAY_VAS_CHARACTER_LIST                = 0x2830,
-    SMSG_BATTLE_PAY_VAS_CHARACTER_QUEUE_STATUS        = 0x2859,
-    SMSG_BATTLE_PAY_VAS_PURCHASE_COMPLETE             = 0x2833,
-    SMSG_BATTLE_PAY_VAS_PURCHASE_LIST                 = 0x2834,
-    SMSG_BATTLE_PAY_VAS_PURCHASE_STARTED              = 0x2832,
-    SMSG_BATTLE_PAY_VAS_REALM_LIST                    = 0x2831,
-    SMSG_BATTLE_PAY_VAS_TRANSFER_QUEUE_STATUS         = 0x2858,
-    SMSG_BATTLE_PETS_HEALED                           = 0x2609,
-    SMSG_BATTLE_PET_CAGE_DATE_ERROR                   = 0x26A0,
-    SMSG_BATTLE_PET_DELETED                           = 0x2606,
-    SMSG_BATTLE_PET_ERROR                             = 0x2655,
-    SMSG_BATTLE_PET_JOURNAL                           = 0x2605,
-    SMSG_BATTLE_PET_JOURNAL_LOCK_ACQUIRED             = 0x2603,
-    SMSG_BATTLE_PET_JOURNAL_LOCK_DENIED               = 0x2604,
-    SMSG_BATTLE_PET_LICENSE_CHANGED                   = 0x260A,
-    SMSG_BATTLE_PET_MAX_COUNT_CHANGED                 = 0x2601,
-    SMSG_BATTLE_PET_RESTORED                          = 0x2608,
-    SMSG_BATTLE_PET_REVOKED                           = 0x2607,
-    SMSG_BATTLE_PET_TRAP_LEVEL                        = 0x2600,
-    SMSG_BATTLE_PET_UPDATES                           = 0x25FF,
-    SMSG_BINDER_CONFIRM                               = 0x2739,
+    SMSG_BATTLEGROUND_POINTS                          = 0x27A8,
+    SMSG_BATTLENET_CHALLENGE_ABORT                    = 0x27DA,
+    SMSG_BATTLENET_CHALLENGE_START                    = 0x27D9,
+    SMSG_BATTLENET_NOTIFICATION                       = 0x284D,
+    SMSG_BATTLENET_REALM_LIST_TICKET                  = 0x284F,
+    SMSG_BATTLENET_RESPONSE                           = 0x284C,
+    SMSG_BATTLENET_SET_SESSION_STATE                  = 0x284E,
+    SMSG_BATTLENET_UPDATE_SESSION_KEY                 = 0x2872,
+    SMSG_BATTLE_PAY_ACK_FAILED                        = 0x27D2,
+    SMSG_BATTLE_PAY_BATTLE_PET_DELIVERED              = 0x27C7,
+    SMSG_BATTLE_PAY_CONFIRM_PURCHASE                  = 0x27D1,
+    SMSG_BATTLE_PAY_DELIVERY_ENDED                    = 0x27C5,
+    SMSG_BATTLE_PAY_DELIVERY_STARTED                  = 0x27C4,
+    SMSG_BATTLE_PAY_DISTRIBUTION_UPDATE               = 0x27C3,
+    SMSG_BATTLE_PAY_GET_DISTRIBUTION_LIST_RESPONSE    = 0x27C1,
+    SMSG_BATTLE_PAY_GET_PRODUCT_LIST_RESPONSE         = 0x27BF,
+    SMSG_BATTLE_PAY_GET_PURCHASE_LIST_RESPONSE        = 0x27C0,
+    SMSG_BATTLE_PAY_MOUNT_DELIVERED                   = 0x27C6,
+    SMSG_BATTLE_PAY_OPEN_CHECKOUT_RESULT              = 0x286B,
+    SMSG_BATTLE_PAY_PURCHASE_UPDATE                   = 0x27D0,
+    SMSG_BATTLE_PAY_START_DISTRIBUTION_ASSIGN_TO_TARGET_RESPONSE = 0x27CE,
+    SMSG_BATTLE_PAY_START_PURCHASE_RESPONSE           = 0x27CD,
+    SMSG_BATTLE_PAY_SUBSCRIPTION_CHANGED              = 0x2874,
+    SMSG_BATTLE_PAY_VAS_BNET_TRANSFER_VALIDATION_RESULT = 0x2869,
+    SMSG_BATTLE_PAY_VAS_BOOST_CONSUMED                = 0x27C2,
+    SMSG_BATTLE_PAY_VAS_CHARACTER_LIST                = 0x2838,
+    SMSG_BATTLE_PAY_VAS_CHARACTER_QUEUE_STATUS        = 0x2864,
+    SMSG_BATTLE_PAY_VAS_PURCHASE_COMPLETE             = 0x283B,
+    SMSG_BATTLE_PAY_VAS_PURCHASE_LIST                 = 0x283C,
+    SMSG_BATTLE_PAY_VAS_PURCHASE_STARTED              = 0x283A,
+    SMSG_BATTLE_PAY_VAS_REALM_LIST                    = 0x2839,
+    SMSG_BATTLE_PAY_VAS_TRANSFER_QUEUE_STATUS         = 0x2863,
+    SMSG_BATTLE_PETS_HEALED                           = 0x260A,
+    SMSG_BATTLE_PET_CAGE_DATE_ERROR                   = 0x26A5,
+    SMSG_BATTLE_PET_DELETED                           = 0x2607,
+    SMSG_BATTLE_PET_ERROR                             = 0x2657,
+    SMSG_BATTLE_PET_JOURNAL                           = 0x2606,
+    SMSG_BATTLE_PET_JOURNAL_LOCK_ACQUIRED             = 0x2604,
+    SMSG_BATTLE_PET_JOURNAL_LOCK_DENIED               = 0x2605,
+    SMSG_BATTLE_PET_LICENSE_CHANGED                   = 0x260B,
+    SMSG_BATTLE_PET_MAX_COUNT_CHANGED                 = 0x2602,
+    SMSG_BATTLE_PET_RESTORED                          = 0x2609,
+    SMSG_BATTLE_PET_REVOKED                           = 0x2608,
+    SMSG_BATTLE_PET_TRAP_LEVEL                        = 0x2601,
+    SMSG_BATTLE_PET_UPDATES                           = 0x2600,
+    SMSG_BINDER_CONFIRM                               = 0x2742,
     SMSG_BIND_POINT_UPDATE                            = 0x257C,
-    SMSG_BLACK_MARKET_BID_ON_ITEM_RESULT              = 0x2644,
-    SMSG_BLACK_MARKET_OPEN_RESULT                     = 0x2642,
-    SMSG_BLACK_MARKET_OUTBID                          = 0x2645,
-    SMSG_BLACK_MARKET_REQUEST_ITEMS_RESULT            = 0x2643,
-    SMSG_BLACK_MARKET_WON                             = 0x2646,
-    SMSG_BONUS_ROLL_EMPTY                             = 0x2662,
-    SMSG_BOSS_KILL_CREDIT                             = 0x27C0,
-    SMSG_BREAK_TARGET                                 = 0x266C,
-    SMSG_BUY_FAILED                                   = 0x26F1,
-    SMSG_BUY_SUCCEEDED                                = 0x26F0,
-    SMSG_CACHE_INFO                                   = 0x2743,
-    SMSG_CACHE_VERSION                                = 0x2742,
-    SMSG_CALENDAR_CLEAR_PENDING_ACTION                = 0x26C6,
-    SMSG_CALENDAR_COMMAND_RESULT                      = 0x26C7,
-    SMSG_CALENDAR_EVENT_INITIAL_INVITES               = 0x26B6,
-    SMSG_CALENDAR_EVENT_INVITE                        = 0x26B7,
-    SMSG_CALENDAR_EVENT_INVITE_ALERT                  = 0x26B8,
-    SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS       = 0x26BB,
-    SMSG_CALENDAR_EVENT_INVITE_NOTES                  = 0x26C0,
-    SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT            = 0x26C1,
-    SMSG_CALENDAR_EVENT_INVITE_REMOVED                = 0x26BC,
-    SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT          = 0x26BD,
-    SMSG_CALENDAR_EVENT_INVITE_STATUS                 = 0x26B9,
-    SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT           = 0x26BA,
-    SMSG_CALENDAR_EVENT_REMOVED_ALERT                 = 0x26BE,
-    SMSG_CALENDAR_EVENT_UPDATED_ALERT                 = 0x26BF,
-    SMSG_CALENDAR_RAID_LOCKOUT_ADDED                  = 0x26C2,
-    SMSG_CALENDAR_RAID_LOCKOUT_REMOVED                = 0x26C3,
-    SMSG_CALENDAR_RAID_LOCKOUT_UPDATED                = 0x26C4,
-    SMSG_CALENDAR_SEND_CALENDAR                       = 0x26B4,
-    SMSG_CALENDAR_SEND_EVENT                          = 0x26B5,
-    SMSG_CALENDAR_SEND_NUM_PENDING                    = 0x26C5,
-    SMSG_CAMERA_EFFECT                                = 0x2767,
-    SMSG_CANCEL_AUTO_REPEAT                           = 0x2712,
-    SMSG_CANCEL_COMBAT                                = 0x2731,
+    SMSG_BLACK_MARKET_BID_ON_ITEM_RESULT              = 0x2646,
+    SMSG_BLACK_MARKET_OPEN_RESULT                     = 0x2644,
+    SMSG_BLACK_MARKET_OUTBID                          = 0x2647,
+    SMSG_BLACK_MARKET_REQUEST_ITEMS_RESULT            = 0x2645,
+    SMSG_BLACK_MARKET_WON                             = 0x2648,
+    SMSG_BONUS_ROLL_EMPTY                             = 0x2664,
+    SMSG_BONUS_ROLL_FAILED                            = 0x287B,
+    SMSG_BOSS_KILL_CREDIT                             = 0x27CC,
+    SMSG_BREAK_TARGET                                 = 0x266E,
+    SMSG_BROADCAST_ACHIEVEMENT                        = 0x2BBC,
+    SMSG_BUY_FAILED                                   = 0x26F9,
+    SMSG_BUY_SUCCEEDED                                = 0x26F8,
+    SMSG_CACHE_INFO                                   = 0x274C,
+    SMSG_CACHE_VERSION                                = 0x274B,
+    SMSG_CALENDAR_CLEAR_PENDING_ACTION                = 0x26CB,
+    SMSG_CALENDAR_COMMAND_RESULT                      = 0x26CC,
+    SMSG_CALENDAR_EVENT_INITIAL_INVITES               = 0x26BB,
+    SMSG_CALENDAR_EVENT_INVITE                        = 0x26BC,
+    SMSG_CALENDAR_EVENT_INVITE_ALERT                  = 0x26C0,
+    SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS       = 0x26BF,
+    SMSG_CALENDAR_EVENT_INVITE_NOTES                  = 0x26C5,
+    SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT            = 0x26C6,
+    SMSG_CALENDAR_EVENT_INVITE_REMOVED                = 0x26BD,
+    SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT          = 0x26C2,
+    SMSG_CALENDAR_EVENT_INVITE_STATUS                 = 0x26BE,
+    SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT           = 0x26C1,
+    SMSG_CALENDAR_EVENT_REMOVED_ALERT                 = 0x26C3,
+    SMSG_CALENDAR_EVENT_UPDATED_ALERT                 = 0x26C4,
+    SMSG_CALENDAR_RAID_LOCKOUT_ADDED                  = 0x26C7,
+    SMSG_CALENDAR_RAID_LOCKOUT_REMOVED                = 0x26C8,
+    SMSG_CALENDAR_RAID_LOCKOUT_UPDATED                = 0x26C9,
+    SMSG_CALENDAR_SEND_CALENDAR                       = 0x26B9,
+    SMSG_CALENDAR_SEND_EVENT                          = 0x26BA,
+    SMSG_CALENDAR_SEND_NUM_PENDING                    = 0x26CA,
+    SMSG_CAMERA_EFFECT                                = 0x276F,
+    SMSG_CANCEL_AUTO_REPEAT                           = 0x271B,
+    SMSG_CANCEL_COMBAT                                = 0x273A,
     SMSG_CANCEL_ORPHAN_SPELL_VISUAL                   = 0x2C46,
-    SMSG_CANCEL_SCENE                                 = 0x2654,
+    SMSG_CANCEL_SCENE                                 = 0x2656,
     SMSG_CANCEL_SPELL_VISUAL                          = 0x2C44,
     SMSG_CANCEL_SPELL_VISUAL_KIT                      = 0x2C48,
-    SMSG_CAN_DUEL_RESULT                              = 0x2676,
+    SMSG_CAN_DUEL_RESULT                              = 0x2679,
     SMSG_CAST_FAILED                                  = 0x2C56,
     SMSG_CATEGORY_COOLDOWN                            = 0x2C16,
-    SMSG_CHALLENGE_MODE_ALL_MAP_STATS                 = 0x2622,
-    SMSG_CHALLENGE_MODE_COMPLETE                      = 0x2620,
-    SMSG_CHALLENGE_MODE_MAP_STATS_UPDATE              = 0x2623,
-    SMSG_CHALLENGE_MODE_NEW_PLAYER_RECORD             = 0x2625,
-    SMSG_CHALLENGE_MODE_REQUEST_LEADERS_RESULT        = 0x2624,
-    SMSG_CHALLENGE_MODE_RESET                         = 0x261F,
-    SMSG_CHALLENGE_MODE_REWARDS                       = 0x2621,
-    SMSG_CHALLENGE_MODE_START                         = 0x261D,
-    SMSG_CHALLENGE_MODE_UPDATE_DEATH_COUNT            = 0x261E,
-    SMSG_CHANGE_PLAYER_DIFFICULTY_RESULT              = 0x2735,
+    SMSG_CHALLENGE_MODE_AFFIXES                       = 0x2624,
+    SMSG_CHALLENGE_MODE_ALL_MAP_STATS                 = 0x2623,
+    SMSG_CHALLENGE_MODE_COMPLETE                      = 0x2621,
+    SMSG_CHALLENGE_MODE_NEW_PLAYER_RECORD             = 0x2626,
+    SMSG_CHALLENGE_MODE_NEW_PLAYER_SEASON_RECORD      = 0x2627,
+    SMSG_CHALLENGE_MODE_REQUEST_LEADERS_RESULT        = 0x2625,
+    SMSG_CHALLENGE_MODE_RESET                         = 0x2620,
+    SMSG_CHALLENGE_MODE_REWARDS                       = 0x2622,
+    SMSG_CHALLENGE_MODE_START                         = 0x261E,
+    SMSG_CHALLENGE_MODE_UPDATE_DEATH_COUNT            = 0x261F,
+    SMSG_CHANGE_PLAYER_DIFFICULTY_RESULT              = 0x273E,
     SMSG_CHANNEL_LIST                                 = 0x2BC3,
     SMSG_CHANNEL_NOTIFY                               = 0x2BC0,
     SMSG_CHANNEL_NOTIFY_JOINED                        = 0x2BC1,
     SMSG_CHANNEL_NOTIFY_LEFT                          = 0x2BC2,
-    SMSG_CHARACTER_CLASS_TRIAL_CREATE                 = 0x2804,
-    SMSG_CHARACTER_INVENTORY_OVERFLOW_WARNING         = 0x2863,
-    SMSG_CHARACTER_ITEM_FIXUP                         = 0x2854,
-    SMSG_CHARACTER_LOGIN_FAILED                       = 0x2744,
-    SMSG_CHARACTER_OBJECT_TEST_RESPONSE               = 0x27CC,
-    SMSG_CHARACTER_RENAME_RESULT                      = 0x27A5,
-    SMSG_CHARACTER_UPGRADE_COMPLETE                   = 0x2803,
-    SMSG_CHARACTER_UPGRADE_QUEUED                     = 0x2802,
-    SMSG_CHARACTER_UPGRADE_SPELL_TIER_SET             = 0x25F4,
-    SMSG_CHARACTER_UPGRADE_STARTED                    = 0x2801,
-    SMSG_CHARACTER_UPGRADE_UNREVOKE_RESULT            = 0x2805,
-    SMSG_CHAR_CUSTOMIZE                               = 0x2719,
-    SMSG_CHAR_CUSTOMIZE_FAILED                        = 0x2718,
-    SMSG_CHAR_FACTION_CHANGE_RESULT                   = 0x27EE,
+    SMSG_CHARACTER_CLASS_TRIAL_CREATE                 = 0x280C,
+    SMSG_CHARACTER_INVENTORY_OVERFLOW_WARNING         = 0x2873,
+    SMSG_CHARACTER_ITEM_FIXUP                         = 0x285F,
+    SMSG_CHARACTER_LOGIN_FAILED                       = 0x274D,
+    SMSG_CHARACTER_OBJECT_TEST_RESPONSE               = 0x27D8,
+    SMSG_CHARACTER_RENAME_RESULT                      = 0x27B1,
+    SMSG_CHARACTER_UPGRADE_COMPLETE                   = 0x280B,
+    SMSG_CHARACTER_UPGRADE_QUEUED                     = 0x280A,
+    SMSG_CHARACTER_UPGRADE_SPELL_TIER_SET             = 0x25F5,
+    SMSG_CHARACTER_UPGRADE_STARTED                    = 0x2809,
+    SMSG_CHARACTER_UPGRADE_UNREVOKE_RESULT            = 0x280D,
+    SMSG_CHAR_CUSTOMIZE                               = 0x2722,
+    SMSG_CHAR_CUSTOMIZE_FAILED                        = 0x2721,
+    SMSG_CHAR_FACTION_CHANGE_RESULT                   = 0x27F6,
     SMSG_CHAT                                         = 0x2BAD,
     SMSG_CHAT_AUTO_RESPONDED                          = 0x2BB8,
     SMSG_CHAT_DOWN                                    = 0x2BBD,
@@ -964,97 +979,101 @@ enum OpcodeServer : uint16
     SMSG_CHECK_WARGAME_ENTRY                          = 0x259E,
     SMSG_CLEAR_ALL_SPELL_CHARGES                      = 0x2C27,
     SMSG_CLEAR_BOSS_EMOTES                            = 0x25CD,
-    SMSG_CLEAR_COOLDOWN                               = 0x26E4,
+    SMSG_CLEAR_COOLDOWN                               = 0x26EC,
     SMSG_CLEAR_COOLDOWNS                              = 0x2C26,
-    SMSG_CLEAR_LOSS_OF_CONTROL                        = 0x2698,
+    SMSG_CLEAR_LOSS_OF_CONTROL                        = 0x269D,
     SMSG_CLEAR_SPELL_CHARGES                          = 0x2C28,
-    SMSG_CLEAR_TARGET                                 = 0x26DB,
-    SMSG_COIN_REMOVED                                 = 0x262B,
-    SMSG_COMBAT_EVENT_FAILED                          = 0x266F,
-    SMSG_COMMENTATOR_MAP_INFO                         = 0x2746,
-    SMSG_COMMENTATOR_PLAYER_INFO                      = 0x2747,
-    SMSG_COMMENTATOR_STATE_CHANGED                    = 0x2745,
-    SMSG_COMPLAINT_RESULT                             = 0x26D3,
-    SMSG_COMPLETE_SHIPMENT_RESPONSE                   = 0x27DE,
+    SMSG_CLEAR_TARGET                                 = 0x26E3,
+    SMSG_COIN_REMOVED                                 = 0x262D,
+    SMSG_COMBAT_EVENT_FAILED                          = 0x2671,
+    SMSG_COMMENTATOR_MAP_INFO                         = 0x274F,
+    SMSG_COMMENTATOR_PLAYER_INFO                      = 0x2750,
+    SMSG_COMMENTATOR_STATE_CHANGED                    = 0x274E,
+    SMSG_COMPLAINT_RESULT                             = 0x26DA,
+    SMSG_COMPLETE_SHIPMENT_RESPONSE                   = 0x27EA,
     SMSG_CONNECT_TO                                   = 0x304D,
-    SMSG_CONQUEST_FORMULA_CONSTANTS                   = 0x27C7,
-    SMSG_CONSOLE_WRITE                                = 0x2651,
-    SMSG_CONSUMPTION_CONVERSION_INFO_RESPONSE         = 0x2849,
-    SMSG_CONSUMPTION_CONVERSION_RESULT                = 0x284A,
-    SMSG_CONTACT_LIST                                 = 0x27CA,
-    SMSG_CONTROL_UPDATE                               = 0x2664,
-    SMSG_COOLDOWN_CHEAT                               = 0x277B,
-    SMSG_COOLDOWN_EVENT                               = 0x26E3,
-    SMSG_CORPSE_LOCATION                              = 0x266B,
-    SMSG_CORPSE_RECLAIM_DELAY                         = 0x278E,
-    SMSG_CORPSE_TRANSPORT_QUERY                       = 0x2751,
-    SMSG_CREATE_CHAR                                  = 0x273E,
-    SMSG_CREATE_SHIPMENT_RESPONSE                     = 0x27DD,
-    SMSG_CRITERIA_DELETED                             = 0x271D,
-    SMSG_CRITERIA_UPDATE                              = 0x2717,
-    SMSG_CROSSED_INEBRIATION_THRESHOLD                = 0x26EC,
+    SMSG_CONQUEST_FORMULA_CONSTANTS                   = 0x27D3,
+    SMSG_CONSOLE_WRITE                                = 0x2653,
+    SMSG_CONSUMPTION_CONVERSION_INFO_RESPONSE         = 0x2853,
+    SMSG_CONSUMPTION_CONVERSION_RESULT                = 0x2854,
+    SMSG_CONTACT_LIST                                 = 0x27D6,
+    SMSG_CONTRIBUTION_COLLECTOR_STATE                 = 0x286A,
+    SMSG_CONTROL_UPDATE                               = 0x2666,
+    SMSG_COOLDOWN_CHEAT                               = 0x2783,
+    SMSG_COOLDOWN_EVENT                               = 0x26EB,
+    SMSG_CORPSE_LOCATION                              = 0x266D,
+    SMSG_CORPSE_RECLAIM_DELAY                         = 0x2796,
+    SMSG_CORPSE_TRANSPORT_QUERY                       = 0x275A,
+    SMSG_CREATE_CHAR                                  = 0x2747,
+    SMSG_CREATE_SHIPMENT_RESPONSE                     = 0x27E9,
+    SMSG_CRITERIA_DELETED                             = 0x2726,
+    SMSG_CRITERIA_UPDATE                              = 0x2720,
+    SMSG_CROSSED_INEBRIATION_THRESHOLD                = 0x26F4,
     SMSG_CUSTOM_LOAD_SCREEN                           = 0x25E3,
     SMSG_DAILY_QUESTS_RESET                           = 0x2A80,
-    SMSG_DAMAGE_CALC_LOG                              = 0x280C,
+    SMSG_DAMAGE_CALC_LOG                              = 0x2814,
     SMSG_DB_REPLY                                     = 0x25A0,
-    SMSG_DEATH_RELEASE_LOC                            = 0x2705,
+    SMSG_DEATH_RELEASE_LOC                            = 0x270E,
     SMSG_DEFENSE_MESSAGE                              = 0x2BB6,
-    SMSG_DELETE_CHAR                                  = 0x273F,
-    SMSG_DESTROY_ARENA_UNIT                           = 0x2784,
-    SMSG_DESTRUCTIBLE_BUILDING_DAMAGE                 = 0x2732,
+    SMSG_DELETE_CHAR                                  = 0x2748,
+    SMSG_DESTROY_ARENA_UNIT                           = 0x278C,
+    SMSG_DESTRUCTIBLE_BUILDING_DAMAGE                 = 0x273B,
     SMSG_DIFFERENT_INSTANCE_FROM_PARTY                = 0x258A,
     SMSG_DISENCHANT_CREDIT                            = 0x25BC,
-    SMSG_DISMOUNT                                     = 0x26DA,
+    SMSG_DISMOUNT                                     = 0x26E2,
     SMSG_DISMOUNT_RESULT                              = 0x257B,
     SMSG_DISPEL_FAILED                                = 0x2C30,
     SMSG_DISPLAY_GAME_ERROR                           = 0x25B5,
-    SMSG_DISPLAY_PLAYER_CHOICE                        = 0x26A1,
-    SMSG_DISPLAY_PROMOTION                            = 0x2668,
+    SMSG_DISPLAY_PLAYER_CHOICE                        = 0x26A6,
+    SMSG_DISPLAY_PROMOTION                            = 0x266A,
     SMSG_DISPLAY_QUEST_POPUP                          = 0x2A9D,
-    SMSG_DISPLAY_TOAST                                = 0x2638,
-    SMSG_DONT_AUTO_PUSH_SPELLS_TO_ACTION_BAR          = 0x25F6,
+    SMSG_DISPLAY_TOAST                                = 0x263A,
+    SMSG_DONT_AUTO_PUSH_SPELLS_TO_ACTION_BAR          = 0x25F7,
     SMSG_DROP_NEW_CONNECTION                          = 0x304C,
-    SMSG_DUEL_COMPLETE                                = 0x2674,
-    SMSG_DUEL_COUNTDOWN                               = 0x2673,
-    SMSG_DUEL_IN_BOUNDS                               = 0x2672,
-    SMSG_DUEL_OUT_OF_BOUNDS                           = 0x2671,
-    SMSG_DUEL_REQUESTED                               = 0x2670,
-    SMSG_DUEL_WINNER                                  = 0x2675,
-    SMSG_DURABILITY_DAMAGE_DEATH                      = 0x278A,
-    SMSG_EMOTE                                        = 0x280D,
-    SMSG_ENABLE_BARBER_SHOP                           = 0x26E7,
+    SMSG_DUEL_COMPLETE                                = 0x2677,
+    SMSG_DUEL_COUNTDOWN                               = 0x2676,
+    SMSG_DUEL_IN_BOUNDS                               = 0x2675,
+    SMSG_DUEL_OPPONENT_SELECTED                       = 0x2673,
+    SMSG_DUEL_OUT_OF_BOUNDS                           = 0x2674,
+    SMSG_DUEL_REQUESTED                               = 0x2672,
+    SMSG_DUEL_WINNER                                  = 0x2678,
+    SMSG_DURABILITY_DAMAGE_DEATH                      = 0x2792,
+    SMSG_EMOTE                                        = 0x2815,
+    SMSG_ENABLE_BARBER_SHOP                           = 0x26EF,
     SMSG_ENABLE_ENCRYPTION                            = 0x3049,
-    SMSG_ENCHANTMENT_LOG                              = 0x2752,
-    SMSG_ENCOUNTER_END                                = 0x27BF,
-    SMSG_ENCOUNTER_START                              = 0x27BE,
+    SMSG_ENCHANTMENT_LOG                              = 0x275B,
+    SMSG_ENCOUNTER_END                                = 0x27CB,
+    SMSG_ENCOUNTER_START                              = 0x27CA,
     SMSG_ENUM_CHARACTERS_RESULT                       = 0x2582,
     SMSG_ENVIRONMENTAL_DAMAGE_LOG                     = 0x2C21,
-    SMSG_EQUIPMENT_SET_ID                             = 0x26DC,
+    SMSG_EQUIPMENT_SET_ID                             = 0x26E4,
     SMSG_EXPECTED_SPAM_RECORDS                        = 0x2BB1,
-    SMSG_EXPLORATION_EXPERIENCE                       = 0x27A2,
-    SMSG_FACTION_BONUS_INFO                           = 0x2766,
+    SMSG_EXPLORATION_EXPERIENCE                       = 0x27AE,
+    SMSG_FACTION_BONUS_INFO                           = 0x276E,
     SMSG_FAILED_PLAYER_CONDITION                      = 0x25E2,
     SMSG_FEATURE_SYSTEM_STATUS                        = 0x25D1,
     SMSG_FEATURE_SYSTEM_STATUS_GLUE_SCREEN            = 0x25D2,
-    SMSG_FEIGN_DEATH_RESISTED                         = 0x2787,
-    SMSG_FISH_ESCAPED                                 = 0x26F9,
-    SMSG_FISH_NOT_HOOKED                              = 0x26F8,
+    SMSG_FEIGN_DEATH_RESISTED                         = 0x278F,
+    SMSG_FISH_ESCAPED                                 = 0x2701,
+    SMSG_FISH_NOT_HOOKED                              = 0x2700,
     SMSG_FLIGHT_SPLINE_SYNC                           = 0x2DF7,
-    SMSG_FORCED_DEATH_UPDATE                          = 0x2706,
-    SMSG_FORCE_ANIM                                   = 0x2794,
-    SMSG_FORCE_OBJECT_RELINK                          = 0x2667,
-    SMSG_FRIEND_STATUS                                = 0x27CB,
+    SMSG_FORCED_DEATH_UPDATE                          = 0x270F,
+    SMSG_FORCE_ANIM                                   = 0x279D,
+    SMSG_FORCE_OBJECT_RELINK                          = 0x2669,
+    SMSG_FRIEND_STATUS                                = 0x27D7,
+    SMSG_GAME_EVENT_DEBUG_INITIALIZE                  = 0x267F,
     SMSG_GAME_OBJECT_ACTIVATE_ANIM_KIT                = 0x25D6,
     SMSG_GAME_OBJECT_CUSTOM_ANIM                      = 0x25D7,
     SMSG_GAME_OBJECT_DESPAWN                          = 0x25D8,
+    SMSG_GAME_OBJECT_MULTI_TRANSITION                 = 0x2879,
     SMSG_GAME_OBJECT_PLAY_SPELL_VISUAL                = 0x2C4B,
     SMSG_GAME_OBJECT_PLAY_SPELL_VISUAL_KIT            = 0x2C4A,
-    SMSG_GAME_OBJECT_RESET_STATE                      = 0x275D,
-    SMSG_GAME_OBJECT_SET_STATE                        = 0x2841,
-    SMSG_GAME_OBJECT_UI_ACTION                        = 0x275A,
-    SMSG_GAME_SPEED_SET                               = 0x26AA,
-    SMSG_GAME_TIME_SET                                = 0x274B,
-    SMSG_GAME_TIME_UPDATE                             = 0x274A,
+    SMSG_GAME_OBJECT_RESET_STATE                      = 0x2765,
+    SMSG_GAME_OBJECT_SET_STATE                        = 0x284B,
+    SMSG_GAME_OBJECT_UI_ACTION                        = 0x2762,
+    SMSG_GAME_SPEED_SET                               = 0x26AF,
+    SMSG_GAME_TIME_SET                                = 0x2754,
+    SMSG_GAME_TIME_UPDATE                             = 0x2753,
     SMSG_GARRISON_ADD_FOLLOWER_RESULT                 = 0x2902,
     SMSG_GARRISON_ADD_MISSION_RESULT                  = 0x2906,
     SMSG_GARRISON_ASSIGN_FOLLOWER_TO_BUILDING_RESULT  = 0x2918,
@@ -1063,16 +1082,17 @@ enum OpcodeServer : uint16
     SMSG_GARRISON_BUILDING_REMOVED                    = 0x28F4,
     SMSG_GARRISON_BUILDING_SET_ACTIVE_SPECIALIZATION_RESULT = 0x28F6,
     SMSG_GARRISON_CLEAR_ALL_FOLLOWERS_EXHAUSTION      = 0x2916,
-    SMSG_GARRISON_COMPLETE_MISSION_RESULT             = 0x2909,
+    SMSG_GARRISON_COMPLETE_MISSION_RESULT             = 0x2908,
     SMSG_GARRISON_CREATE_RESULT                       = 0x28FC,
     SMSG_GARRISON_DELETE_RESULT                       = 0x2920,
+    SMSG_GARRISON_FOLLOWER_CATEGORIES                 = 0x2901,
     SMSG_GARRISON_FOLLOWER_CHANGED_ABILITIES          = 0x2914,
     SMSG_GARRISON_FOLLOWER_CHANGED_DURABILITY         = 0x2904,
     SMSG_GARRISON_FOLLOWER_CHANGED_ITEM_LEVEL         = 0x2913,
     SMSG_GARRISON_FOLLOWER_CHANGED_STATUS             = 0x2915,
     SMSG_GARRISON_FOLLOWER_CHANGED_XP                 = 0x2912,
     SMSG_GARRISON_IS_UPGRADEABLE_RESULT               = 0x2929,
-    SMSG_GARRISON_LANDING_PAGE_SHIPMENT_INFO          = 0x27E0,
+    SMSG_GARRISON_LANDING_PAGE_SHIPMENT_INFO          = 0x27EC,
     SMSG_GARRISON_LEARN_BLUEPRINT_RESULT              = 0x28F7,
     SMSG_GARRISON_LEARN_SPECIALIZATION_RESULT         = 0x28F5,
     SMSG_GARRISON_LIST_FOLLOWERS_CHEAT_RESULT         = 0x2905,
@@ -1102,26 +1122,27 @@ enum OpcodeServer : uint16
     SMSG_GARRISON_UNLEARN_BLUEPRINT_RESULT            = 0x28F8,
     SMSG_GARRISON_UPGRADE_RESULT                      = 0x28FD,
     SMSG_GENERATE_RANDOM_CHARACTER_NAME_RESULT        = 0x2583,
-    SMSG_GET_ACCOUNT_CHARACTER_LIST_RESULT            = 0x27A3,
+    SMSG_GET_ACCOUNT_CHARACTER_LIST_RESULT            = 0x27AF,
     SMSG_GET_DISPLAYED_TROPHY_LIST_RESPONSE           = 0x2928,
     SMSG_GET_GARRISON_INFO_RESULT                     = 0x28F0,
-    SMSG_GET_SHIPMENTS_OF_TYPE_RESPONSE               = 0x27DF,
-    SMSG_GET_SHIPMENT_INFO_RESPONSE                   = 0x27DB,
-    SMSG_GET_TROPHY_LIST_RESPONSE                     = 0x2808,
-    SMSG_GM_PLAYER_INFO                               = 0x277A,
-    SMSG_GM_REQUEST_PLAYER_INFO                       = 0x25ED,
-    SMSG_GM_TICKET_CASE_STATUS                        = 0x26CC,
-    SMSG_GM_TICKET_SYSTEM_STATUS                      = 0x26CB,
-    SMSG_GOD_MODE                                     = 0x2738,
+    SMSG_GET_SHIPMENTS_OF_TYPE_RESPONSE               = 0x27EB,
+    SMSG_GET_SHIPMENT_INFO_RESPONSE                   = 0x27E7,
+    SMSG_GET_TROPHY_LIST_RESPONSE                     = 0x2810,
+    SMSG_GM_PLAYER_INFO                               = 0x2782,
+    SMSG_GM_REQUEST_PLAYER_INFO                       = 0x25EE,
+    SMSG_GM_TICKET_CASE_STATUS                        = 0x26D1,
+    SMSG_GM_TICKET_SYSTEM_STATUS                      = 0x26D0,
+    SMSG_GOD_MODE                                     = 0x2741,
     SMSG_GOSSIP_COMPLETE                              = 0x2A96,
     SMSG_GOSSIP_MESSAGE                               = 0x2A97,
-    SMSG_GOSSIP_POI                                   = 0x27D8,
+    SMSG_GOSSIP_POI                                   = 0x27E4,
+    SMSG_GOSSIP_TEXT_UPDATE                           = 0x2A98,
     SMSG_GROUP_ACTION_THROTTLED                       = 0x259C,
-    SMSG_GROUP_DECLINE                                = 0x27D3,
-    SMSG_GROUP_DESTROYED                              = 0x27D5,
-    SMSG_GROUP_INVITE_CONFIRMATION                    = 0x2855,
-    SMSG_GROUP_NEW_LEADER                             = 0x2649,
-    SMSG_GROUP_UNINVITE                               = 0x27D4,
+    SMSG_GROUP_DECLINE                                = 0x27DF,
+    SMSG_GROUP_DESTROYED                              = 0x27E1,
+    SMSG_GROUP_INVITE_CONFIRMATION                    = 0x2860,
+    SMSG_GROUP_NEW_LEADER                             = 0x264B,
+    SMSG_GROUP_UNINVITE                               = 0x27E0,
     SMSG_GUILD_ACHIEVEMENT_DELETED                    = 0x29C5,
     SMSG_GUILD_ACHIEVEMENT_EARNED                     = 0x29C4,
     SMSG_GUILD_ACHIEVEMENT_MEMBERS                    = 0x29C7,
@@ -1174,53 +1195,56 @@ enum OpcodeServer : uint16
     SMSG_GUILD_ROSTER                                 = 0x29BB,
     SMSG_GUILD_ROSTER_UPDATE                          = 0x29BC,
     SMSG_GUILD_SEND_RANK_CHANGE                       = 0x29B9,
-    SMSG_HEALTH_UPDATE                                = 0x26FC,
-    SMSG_HIGHEST_THREAT_UPDATE                        = 0x270C,
+    SMSG_HEALTH_UPDATE                                = 0x2704,
+    SMSG_HIGHEST_THREAT_UPDATE                        = 0x2715,
     SMSG_HOTFIX_MESSAGE                               = 0x25A2,
     SMSG_HOTFIX_RESPONSE                              = 0x25A3,
-    SMSG_INITIALIZE_FACTIONS                          = 0x2765,
+    SMSG_INITIALIZE_FACTIONS                          = 0x276D,
     SMSG_INITIAL_SETUP                                = 0x257F,
-    SMSG_INIT_WORLD_STATES                            = 0x278B,
+    SMSG_INIT_WORLD_STATES                            = 0x2793,
     SMSG_INSPECT_HONOR_STATS                          = 0x25B2,
-    SMSG_INSPECT_PVP                                  = 0x2761,
-    SMSG_INSPECT_RESULT                               = 0x264D,
-    SMSG_INSTANCE_ENCOUNTER_CHANGE_PRIORITY           = 0x27F4,
-    SMSG_INSTANCE_ENCOUNTER_DISENGAGE_UNIT            = 0x27F3,
-    SMSG_INSTANCE_ENCOUNTER_END                       = 0x27FC,
-    SMSG_INSTANCE_ENCOUNTER_ENGAGE_UNIT               = 0x27F2,
-    SMSG_INSTANCE_ENCOUNTER_GAIN_COMBAT_RESURRECTION_CHARGE = 0x27FE,
-    SMSG_INSTANCE_ENCOUNTER_IN_COMBAT_RESURRECTION    = 0x27FD,
-    SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_COMPLETE        = 0x27F7,
-    SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_START           = 0x27F6,
-    SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_UPDATE          = 0x27FB,
-    SMSG_INSTANCE_ENCOUNTER_PHASE_SHIFT_CHANGED       = 0x27FF,
-    SMSG_INSTANCE_ENCOUNTER_SET_ALLOWING_RELEASE      = 0x27FA,
-    SMSG_INSTANCE_ENCOUNTER_SET_SUPPRESSING_RELEASE   = 0x27F9,
-    SMSG_INSTANCE_ENCOUNTER_START                     = 0x27F8,
-    SMSG_INSTANCE_ENCOUNTER_TIMER_START               = 0x27F5,
-    SMSG_INSTANCE_GROUP_SIZE_CHANGED                  = 0x2736,
-    SMSG_INSTANCE_INFO                                = 0x2650,
-    SMSG_INSTANCE_RESET                               = 0x26AF,
-    SMSG_INSTANCE_RESET_FAILED                        = 0x26B0,
-    SMSG_INSTANCE_SAVE_CREATED                        = 0x27BD,
-    SMSG_INVALIDATE_PAGE_TEXT                         = 0x2701,
-    SMSG_INVALIDATE_PLAYER                            = 0x26D2,
-    SMSG_INVALID_PROMOTION_CODE                       = 0x2795,
-    SMSG_INVENTORY_CHANGE_FAILURE                     = 0x2763,
+    SMSG_INSPECT_PVP                                  = 0x2769,
+    SMSG_INSPECT_RESULT                               = 0x264F,
+    SMSG_INSTANCE_ENCOUNTER_CHANGE_PRIORITY           = 0x27FC,
+    SMSG_INSTANCE_ENCOUNTER_DISENGAGE_UNIT            = 0x27FB,
+    SMSG_INSTANCE_ENCOUNTER_END                       = 0x2804,
+    SMSG_INSTANCE_ENCOUNTER_ENGAGE_UNIT               = 0x27FA,
+    SMSG_INSTANCE_ENCOUNTER_GAIN_COMBAT_RESURRECTION_CHARGE = 0x2806,
+    SMSG_INSTANCE_ENCOUNTER_IN_COMBAT_RESURRECTION    = 0x2805,
+    SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_COMPLETE        = 0x27FF,
+    SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_START           = 0x27FE,
+    SMSG_INSTANCE_ENCOUNTER_OBJECTIVE_UPDATE          = 0x2803,
+    SMSG_INSTANCE_ENCOUNTER_PHASE_SHIFT_CHANGED       = 0x2807,
+    SMSG_INSTANCE_ENCOUNTER_SET_ALLOWING_RELEASE      = 0x2802,
+    SMSG_INSTANCE_ENCOUNTER_SET_SUPPRESSING_RELEASE   = 0x2801,
+    SMSG_INSTANCE_ENCOUNTER_START                     = 0x2800,
+    SMSG_INSTANCE_ENCOUNTER_TIMER_START               = 0x27FD,
+    SMSG_INSTANCE_GROUP_SIZE_CHANGED                  = 0x273F,
+    SMSG_INSTANCE_INFO                                = 0x2652,
+    SMSG_INSTANCE_RESET                               = 0x26B4,
+    SMSG_INSTANCE_RESET_FAILED                        = 0x26B5,
+    SMSG_INSTANCE_SAVE_CREATED                        = 0x27C9,
+    SMSG_INVALIDATE_PAGE_TEXT                         = 0x270A,
+    SMSG_INVALIDATE_PLAYER                            = 0x26D9,
+    SMSG_INVALID_PROMOTION_CODE                       = 0x279E,
+    SMSG_INVENTORY_CHANGE_FAILURE                     = 0x276B,
+    SMSG_ISLAND_AZERITE_XP_GAIN                       = 0x27AB,
+    SMSG_ISLAND_COMPLETED                             = 0x27AC,
+    SMSG_ISLAND_OPEN_QUEUE_NPC                        = 0x2840,
     SMSG_IS_QUEST_COMPLETE_RESPONSE                   = 0x2A83,
-    SMSG_ITEM_CHANGED                                 = 0x2720,
-    SMSG_ITEM_COOLDOWN                                = 0x280B,
-    SMSG_ITEM_ENCHANT_TIME_UPDATE                     = 0x2797,
+    SMSG_ITEM_CHANGED                                 = 0x2729,
+    SMSG_ITEM_COOLDOWN                                = 0x2813,
+    SMSG_ITEM_ENCHANT_TIME_UPDATE                     = 0x27A0,
     SMSG_ITEM_EXPIRE_PURCHASE_REFUND                  = 0x25B1,
     SMSG_ITEM_PURCHASE_REFUND_RESULT                  = 0x25AF,
-    SMSG_ITEM_PUSH_RESULT                             = 0x2637,
-    SMSG_ITEM_TIME_UPDATE                             = 0x2796,
-    SMSG_KICK_REASON                                  = 0x282F,
+    SMSG_ITEM_PUSH_RESULT                             = 0x2639,
+    SMSG_ITEM_TIME_UPDATE                             = 0x279F,
+    SMSG_KICK_REASON                                  = 0x2837,
     SMSG_LEARNED_SPELLS                               = 0x2C4D,
     SMSG_LEARN_PVP_TALENTS_FAILED                     = 0x25EA,
     SMSG_LEARN_TALENTS_FAILED                         = 0x25E9,
     SMSG_LEVEL_UPDATE                                 = 0x2587,
-    SMSG_LEVEL_UP_INFO                                = 0x271F,
+    SMSG_LEVEL_UP_INFO                                = 0x2728,
     SMSG_LFG_BOOT_PLAYER                              = 0x2A35,
     SMSG_LFG_DISABLED                                 = 0x2A33,
     SMSG_LFG_INSTANCE_SHUTDOWN_COUNTDOWN              = 0x2A25,
@@ -1249,44 +1273,47 @@ enum OpcodeServer : uint16
     SMSG_LF_GUILD_COMMAND_RESULT                      = 0x29D0,
     SMSG_LF_GUILD_POST                                = 0x29CD,
     SMSG_LF_GUILD_RECRUITS                            = 0x29CF,
-    SMSG_LIVE_REGION_ACCOUNT_RESTORE_RESULT           = 0x27B1,
-    SMSG_LIVE_REGION_CHARACTER_COPY_RESULT            = 0x27AF,
-    SMSG_LIVE_REGION_GET_ACCOUNT_CHARACTER_LIST_RESULT = 0x27A4,
+    SMSG_LIGHTNING_STORM_END                          = 0x26D6,
+    SMSG_LIGHTNING_STORM_START                        = 0x26D5,
+    SMSG_LIVE_REGION_ACCOUNT_RESTORE_RESULT           = 0x27BD,
+    SMSG_LIVE_REGION_CHARACTER_COPY_RESULT            = 0x27BB,
+    SMSG_LIVE_REGION_GET_ACCOUNT_CHARACTER_LIST_RESULT = 0x27B0,
     SMSG_LOAD_CUF_PROFILES                            = 0x25CE,
-    SMSG_LOAD_EQUIPMENT_SET                           = 0x274D,
-    SMSG_LOAD_SELECTED_TROPHY_RESULT                  = 0x2809,
-    SMSG_LOGIN_SET_TIME_SPEED                         = 0x274C,
+    SMSG_LOAD_EQUIPMENT_SET                           = 0x2756,
+    SMSG_LOAD_SELECTED_TROPHY_RESULT                  = 0x2811,
+    SMSG_LOGIN_SET_TIME_SPEED                         = 0x2755,
     SMSG_LOGIN_VERIFY_WORLD                           = 0x25AC,
-    SMSG_LOGOUT_CANCEL_ACK                            = 0x26AE,
-    SMSG_LOGOUT_COMPLETE                              = 0x26AD,
-    SMSG_LOGOUT_RESPONSE                              = 0x26AC,
-    SMSG_LOG_XP_GAIN                                  = 0x271B,
-    SMSG_LOOT_ALL_PASSED                              = 0x2635,
-    SMSG_LOOT_LIST                                    = 0x2783,
-    SMSG_LOOT_MONEY_NOTIFY                            = 0x2630,
-    SMSG_LOOT_RELEASE                                 = 0x262F,
-    SMSG_LOOT_RELEASE_ALL                             = 0x262E,
-    SMSG_LOOT_REMOVED                                 = 0x2629,
-    SMSG_LOOT_RESPONSE                                = 0x2628,
-    SMSG_LOOT_ROLL                                    = 0x2632,
-    SMSG_LOOT_ROLLS_COMPLETE                          = 0x2634,
-    SMSG_LOOT_ROLL_WON                                = 0x2636,
-    SMSG_LOSS_OF_CONTROL_AURA_UPDATE                  = 0x2695,
-    SMSG_MAIL_COMMAND_RESULT                          = 0x2658,
-    SMSG_MAIL_LIST_RESULT                             = 0x2798,
-    SMSG_MAIL_QUERY_NEXT_TIME_RESULT                  = 0x2799,
-    SMSG_MAP_OBJECTIVES_INIT                          = 0x27A1,
+    SMSG_LOGOUT_CANCEL_ACK                            = 0x26B3,
+    SMSG_LOGOUT_COMPLETE                              = 0x26B2,
+    SMSG_LOGOUT_RESPONSE                              = 0x26B1,
+    SMSG_LOG_XP_GAIN                                  = 0x2724,
+    SMSG_LOOT_ALL_PASSED                              = 0x2637,
+    SMSG_LOOT_LEGACY_RULES_IN_EFFECT                  = 0x287A,
+    SMSG_LOOT_LIST                                    = 0x278B,
+    SMSG_LOOT_MONEY_NOTIFY                            = 0x2632,
+    SMSG_LOOT_RELEASE                                 = 0x2631,
+    SMSG_LOOT_RELEASE_ALL                             = 0x2630,
+    SMSG_LOOT_REMOVED                                 = 0x262B,
+    SMSG_LOOT_RESPONSE                                = 0x262A,
+    SMSG_LOOT_ROLL                                    = 0x2634,
+    SMSG_LOOT_ROLLS_COMPLETE                          = 0x2636,
+    SMSG_LOOT_ROLL_WON                                = 0x2638,
+    SMSG_LOSS_OF_CONTROL_AURA_UPDATE                  = 0x269A,
+    SMSG_MAIL_COMMAND_RESULT                          = 0x265A,
+    SMSG_MAIL_LIST_RESULT                             = 0x27A1,
+    SMSG_MAIL_QUERY_NEXT_TIME_RESULT                  = 0x27A2,
+    SMSG_MAP_OBJECTIVES_INIT                          = 0x27AA,
     SMSG_MAP_OBJ_EVENTS                               = 0x25D9,
-    SMSG_MASTER_LOOT_CANDIDATE_LIST                   = 0x2633,
+    SMSG_MASTER_LOOT_CANDIDATE_LIST                   = 0x2635,
     SMSG_MESSAGE_BOX                                  = 0x2575,
-    SMSG_MINIMAP_PING                                 = 0x26F7,
+    SMSG_MINIMAP_PING                                 = 0x26FF,
     SMSG_MIRROR_IMAGE_COMPONENTED_DATA                = 0x2C14,
     SMSG_MIRROR_IMAGE_CREATURE_DATA                   = 0x2C13,
     SMSG_MISSILE_CANCEL                               = 0x25DA,
-    SMSG_MODIFY_CHARGE_RECOVERY_SPEED                 = 0x27A8,
-    SMSG_MODIFY_COOLDOWN                              = 0x27A6,
-    SMSG_MODIFY_COOLDOWN_RECOVERY_SPEED               = 0x27A7,
-    SMSG_MODIFY_PARTY_RANGE                           = 0x2786,
+    SMSG_MODIFY_CHARGE_RECOVERY_SPEED                 = 0x27B4,
+    SMSG_MODIFY_COOLDOWN                              = 0x27B2,
+    SMSG_MODIFY_COOLDOWN_RECOVERY_SPEED               = 0x27B3,
+    SMSG_MODIFY_PARTY_RANGE                           = 0x278E,
     SMSG_MOTD                                         = 0x2BAF,
     SMSG_MOUNT_RESULT                                 = 0x257A,
     SMSG_MOVE_APPLY_MOVEMENT_FORCE                    = 0x2DE1,
@@ -1312,6 +1339,7 @@ enum OpcodeServer : uint16
     SMSG_MOVE_SET_HOVERING                            = 0x2DCF,
     SMSG_MOVE_SET_IGNORE_MOVEMENT_FORCES              = 0x2DD7,
     SMSG_MOVE_SET_LAND_WALK                           = 0x2DCC,
+    SMSG_MOVE_SET_MOVEMENT_FORCE_SPEED                = 0x2DB4,
     SMSG_MOVE_SET_NORMAL_FALL                         = 0x2DCE,
     SMSG_MOVE_SET_PITCH_RATE                          = 0x2DC6,
     SMSG_MOVE_SET_RUN_BACK_SPEED                      = 0x2DBF,
@@ -1362,6 +1390,7 @@ enum OpcodeServer : uint16
     SMSG_MOVE_UPDATE_FLIGHT_BACK_SPEED                = 0x2DAA,
     SMSG_MOVE_UPDATE_FLIGHT_SPEED                     = 0x2DA9,
     SMSG_MOVE_UPDATE_KNOCK_BACK                       = 0x2DB0,
+    SMSG_MOVE_UPDATE_MOVEMENT_FORCE_SPEED             = 0x2DB1,
     SMSG_MOVE_UPDATE_PITCH_RATE                       = 0x2DAC,
     SMSG_MOVE_UPDATE_REMOVE_MOVEMENT_FORCE            = 0x2DB3,
     SMSG_MOVE_UPDATE_RUN_BACK_SPEED                   = 0x2DA5,
@@ -1371,111 +1400,111 @@ enum OpcodeServer : uint16
     SMSG_MOVE_UPDATE_TELEPORT                         = 0x2DAF,
     SMSG_MOVE_UPDATE_TURN_RATE                        = 0x2DAB,
     SMSG_MOVE_UPDATE_WALK_SPEED                       = 0x2DA6,
-    SMSG_NEUTRAL_PLAYER_FACTION_SELECT_RESULT         = 0x25F1,
-    SMSG_NEW_TAXI_PATH                                = 0x26A7,
+    SMSG_NEUTRAL_PLAYER_FACTION_SELECT_RESULT         = 0x25F2,
+    SMSG_NEW_TAXI_PATH                                = 0x26AC,
     SMSG_NEW_WORLD                                    = 0x25AB,
     SMSG_NOTIFY_DEST_LOC_SPELL_CAST                   = 0x2C43,
-    SMSG_NOTIFY_MISSILE_TRAJECTORY_COLLISION          = 0x26D1,
+    SMSG_NOTIFY_MISSILE_TRAJECTORY_COLLISION          = 0x26D8,
     SMSG_NOTIFY_MONEY                                 = 0x25AE,
-    SMSG_NOTIFY_RECEIVED_MAIL                         = 0x2659,
-    SMSG_OFFER_PETITION_ERROR                         = 0x26E0,
-    SMSG_ON_CANCEL_EXPECTED_RIDE_VEHICLE_AURA         = 0x271C,
+    SMSG_NOTIFY_RECEIVED_MAIL                         = 0x265B,
+    SMSG_OFFER_PETITION_ERROR                         = 0x26E8,
+    SMSG_ON_CANCEL_EXPECTED_RIDE_VEHICLE_AURA         = 0x2725,
     SMSG_ON_MONSTER_MOVE                              = 0x2DA2,
-    SMSG_OPEN_ALLIED_RACE_DETAILS_GIVER               = 0x2837,
-    SMSG_OPEN_CONTAINER                               = 0x2764,
+    SMSG_OPEN_ALLIED_RACE_DETAILS_GIVER               = 0x2841,
+    SMSG_OPEN_CONTAINER                               = 0x276C,
     SMSG_OPEN_LFG_DUNGEON_FINDER                      = 0x2A31,
-    SMSG_OPEN_SHIPMENT_NPC_FROM_GOSSIP                = 0x27DA,
-    SMSG_OPEN_SHIPMENT_NPC_RESULT                     = 0x27DC,
-    SMSG_OPEN_TRANSMOGRIFIER                          = 0x2836,
-    SMSG_OVERRIDE_LIGHT                               = 0x26E6,
-    SMSG_PAGE_TEXT                                    = 0x2759,
-    SMSG_PARTY_COMMAND_RESULT                         = 0x27D7,
+    SMSG_OPEN_SHIPMENT_NPC_FROM_GOSSIP                = 0x27E6,
+    SMSG_OPEN_SHIPMENT_NPC_RESULT                     = 0x27E8,
+    SMSG_OPEN_TRANSMOGRIFIER                          = 0x283E,
+    SMSG_OVERRIDE_LIGHT                               = 0x26EE,
+    SMSG_PAGE_TEXT                                    = 0x2761,
+    SMSG_PARTY_COMMAND_RESULT                         = 0x27E3,
     SMSG_PARTY_INVITE                                 = 0x25CF,
-    SMSG_PARTY_KILL_LOG                               = 0x279D,
-    SMSG_PARTY_MEMBER_STATE                           = 0x279B,
-    SMSG_PARTY_MEMBER_STATE_UPDATE                    = 0x279A,
-    SMSG_PARTY_UPDATE                                 = 0x260B,
-    SMSG_PAUSE_MIRROR_TIMER                           = 0x274F,
-    SMSG_PENDING_RAID_LOCK                            = 0x2730,
+    SMSG_PARTY_KILL_LOG                               = 0x27A6,
+    SMSG_PARTY_MEMBER_STATE                           = 0x27A4,
+    SMSG_PARTY_MEMBER_STATE_UPDATE                    = 0x27A3,
+    SMSG_PARTY_UPDATE                                 = 0x260C,
+    SMSG_PAUSE_MIRROR_TIMER                           = 0x2758,
+    SMSG_PENDING_RAID_LOCK                            = 0x2739,
     SMSG_PETITION_ALREADY_SIGNED                      = 0x25B8,
     SMSG_PETITION_RENAME_GUILD_RESPONSE               = 0x29F7,
-    SMSG_PETITION_SHOW_LIST                           = 0x26E9,
-    SMSG_PETITION_SHOW_SIGNATURES                     = 0x26EA,
-    SMSG_PETITION_SIGN_RESULTS                        = 0x278F,
-    SMSG_PET_ACTION_FEEDBACK                          = 0x278D,
-    SMSG_PET_ACTION_SOUND                             = 0x26C9,
+    SMSG_PETITION_SHOW_LIST                           = 0x26F1,
+    SMSG_PETITION_SHOW_SIGNATURES                     = 0x26F2,
+    SMSG_PETITION_SIGN_RESULTS                        = 0x2798,
+    SMSG_PET_ACTION_FEEDBACK                          = 0x2795,
+    SMSG_PET_ACTION_SOUND                             = 0x26CE,
     SMSG_PET_ADDED                                    = 0x25A8,
-    SMSG_PET_BATTLE_CHAT_RESTRICTED                   = 0x2618,
-    SMSG_PET_BATTLE_DEBUG_QUEUE_DUMP_RESPONSE         = 0x269C,
-    SMSG_PET_BATTLE_FINALIZE_LOCATION                 = 0x2611,
-    SMSG_PET_BATTLE_FINAL_ROUND                       = 0x2616,
-    SMSG_PET_BATTLE_FINISHED                          = 0x2617,
-    SMSG_PET_BATTLE_FIRST_ROUND                       = 0x2613,
-    SMSG_PET_BATTLE_INITIAL_UPDATE                    = 0x2612,
-    SMSG_PET_BATTLE_MAX_GAME_LENGTH_WARNING           = 0x2619,
-    SMSG_PET_BATTLE_PVP_CHALLENGE                     = 0x2610,
-    SMSG_PET_BATTLE_QUEUE_PROPOSE_MATCH               = 0x2656,
-    SMSG_PET_BATTLE_QUEUE_STATUS                      = 0x2657,
-    SMSG_PET_BATTLE_REPLACEMENTS_MADE                 = 0x2615,
-    SMSG_PET_BATTLE_REQUEST_FAILED                    = 0x260F,
-    SMSG_PET_BATTLE_ROUND_RESULT                      = 0x2614,
-    SMSG_PET_BATTLE_SLOT_UPDATES                      = 0x2602,
+    SMSG_PET_BATTLE_CHAT_RESTRICTED                   = 0x2619,
+    SMSG_PET_BATTLE_DEBUG_QUEUE_DUMP_RESPONSE         = 0x26A1,
+    SMSG_PET_BATTLE_FINALIZE_LOCATION                 = 0x2612,
+    SMSG_PET_BATTLE_FINAL_ROUND                       = 0x2617,
+    SMSG_PET_BATTLE_FINISHED                          = 0x2618,
+    SMSG_PET_BATTLE_FIRST_ROUND                       = 0x2614,
+    SMSG_PET_BATTLE_INITIAL_UPDATE                    = 0x2613,
+    SMSG_PET_BATTLE_MAX_GAME_LENGTH_WARNING           = 0x261A,
+    SMSG_PET_BATTLE_PVP_CHALLENGE                     = 0x2611,
+    SMSG_PET_BATTLE_QUEUE_PROPOSE_MATCH               = 0x2658,
+    SMSG_PET_BATTLE_QUEUE_STATUS                      = 0x2659,
+    SMSG_PET_BATTLE_REPLACEMENTS_MADE                 = 0x2616,
+    SMSG_PET_BATTLE_REQUEST_FAILED                    = 0x2610,
+    SMSG_PET_BATTLE_ROUND_RESULT                      = 0x2615,
+    SMSG_PET_BATTLE_SLOT_UPDATES                      = 0x2603,
     SMSG_PET_CAST_FAILED                              = 0x2C57,
     SMSG_PET_CLEAR_SPELLS                             = 0x2C24,
-    SMSG_PET_DISMISS_SOUND                            = 0x26CA,
-    SMSG_PET_GOD_MODE                                 = 0x26A4,
-    SMSG_PET_GUIDS                                    = 0x2741,
+    SMSG_PET_DISMISS_SOUND                            = 0x26CF,
+    SMSG_PET_GOD_MODE                                 = 0x26A9,
+    SMSG_PET_GUIDS                                    = 0x274A,
     SMSG_PET_LEARNED_SPELLS                           = 0x2C4F,
     SMSG_PET_MODE                                     = 0x2589,
-    SMSG_PET_NAME_INVALID                             = 0x26EE,
+    SMSG_PET_NAME_INVALID                             = 0x26F6,
     SMSG_PET_SLOT_UPDATED                             = 0x2588,
     SMSG_PET_SPELLS_MESSAGE                           = 0x2C25,
     SMSG_PET_STABLE_LIST                              = 0x25A9,
     SMSG_PET_STABLE_RESULT                            = 0x25AA,
-    SMSG_PET_TAME_FAILURE                             = 0x26DD,
+    SMSG_PET_TAME_FAILURE                             = 0x26E5,
     SMSG_PET_UNLEARNED_SPELLS                         = 0x2C50,
     SMSG_PHASE_SHIFT_CHANGE                           = 0x2577,
-    SMSG_PLAYED_TIME                                  = 0x2708,
+    SMSG_PLAYED_TIME                                  = 0x2711,
     SMSG_PLAYER_BOUND                                 = 0x257D,
     SMSG_PLAYER_SAVE_GUILD_EMBLEM                     = 0x29F6,
-    SMSG_PLAYER_SKINNED                               = 0x2788,
-    SMSG_PLAYER_TABARD_VENDOR_ACTIVATE                = 0x279C,
-    SMSG_PLAY_MUSIC                                   = 0x27AB,
-    SMSG_PLAY_OBJECT_SOUND                            = 0x27AC,
-    SMSG_PLAY_ONE_SHOT_ANIM_KIT                       = 0x2772,
+    SMSG_PLAYER_SKINNED                               = 0x2790,
+    SMSG_PLAYER_TABARD_VENDOR_ACTIVATE                = 0x27A5,
+    SMSG_PLAY_MUSIC                                   = 0x27B7,
+    SMSG_PLAY_OBJECT_SOUND                            = 0x27B8,
+    SMSG_PLAY_ONE_SHOT_ANIM_KIT                       = 0x277A,
     SMSG_PLAY_ORPHAN_SPELL_VISUAL                     = 0x2C47,
-    SMSG_PLAY_SCENE                                   = 0x2653,
-    SMSG_PLAY_SOUND                                   = 0x27AA,
-    SMSG_PLAY_SPEAKERBOT_SOUND                        = 0x27AD,
+    SMSG_PLAY_SCENE                                   = 0x2655,
+    SMSG_PLAY_SOUND                                   = 0x27B6,
+    SMSG_PLAY_SPEAKERBOT_SOUND                        = 0x27B9,
     SMSG_PLAY_SPELL_VISUAL                            = 0x2C45,
     SMSG_PLAY_SPELL_VISUAL_KIT                        = 0x2C49,
-    SMSG_PLAY_TIME_WARNING                            = 0x273A,
+    SMSG_PLAY_TIME_WARNING                            = 0x2743,
     SMSG_PONG                                         = 0x304E,
-    SMSG_POWER_UPDATE                                 = 0x26FD,
-    SMSG_PRESTIGE_AND_HONOR_INVOLUNTARILY_CHANGED     = 0x2758,
-    SMSG_PRE_RESSURECT                                = 0x27A9,
+    SMSG_POWER_UPDATE                                 = 0x2705,
+    SMSG_PRE_RESSURECT                                = 0x27B5,
     SMSG_PRINT_NOTIFICATION                           = 0x25E1,
-    SMSG_PROC_RESIST                                  = 0x279E,
-    SMSG_PROPOSE_LEVEL_GRANT                          = 0x2710,
+    SMSG_PROC_RESIST                                  = 0x27A7,
+    SMSG_PROPOSE_LEVEL_GRANT                          = 0x2719,
     SMSG_PUSH_SPELL_TO_ACTION_BAR                     = 0x2C51,
-    SMSG_PVP_CREDIT                                   = 0x2716,
+    SMSG_PVP_CREDIT                                   = 0x271F,
     SMSG_PVP_LOG_DATA                                 = 0x25B3,
     SMSG_PVP_OPTIONS_ENABLED                          = 0x25B6,
     SMSG_PVP_SEASON                                   = 0x25D3,
-    SMSG_QUERY_BATTLE_PET_NAME_RESPONSE               = 0x2703,
-    SMSG_QUERY_CREATURE_RESPONSE                      = 0x26FA,
-    SMSG_QUERY_GAME_OBJECT_RESPONSE                   = 0x26FB,
+    SMSG_QUERY_BATTLE_PET_NAME_RESPONSE               = 0x270C,
+    SMSG_QUERY_COMMUNITY_NAME_RESPONSE                = 0x2708,
+    SMSG_QUERY_CREATURE_RESPONSE                      = 0x2702,
+    SMSG_QUERY_GAME_OBJECT_RESPONSE                   = 0x2703,
     SMSG_QUERY_GARRISON_CREATURE_NAME_RESPONSE        = 0x292B,
     SMSG_QUERY_GUILD_INFO_RESPONSE                    = 0x29E5,
-    SMSG_QUERY_ITEM_TEXT_RESPONSE                     = 0x280A,
-    SMSG_QUERY_NPC_TEXT_RESPONSE                      = 0x26FE,
-    SMSG_QUERY_PAGE_TEXT_RESPONSE                     = 0x2700,
-    SMSG_QUERY_PETITION_RESPONSE                      = 0x2704,
-    SMSG_QUERY_PET_NAME_RESPONSE                      = 0x2702,
-    SMSG_QUERY_PLAYER_NAME_RESPONSE                   = 0x26FF,
+    SMSG_QUERY_ITEM_TEXT_RESPONSE                     = 0x2812,
+    SMSG_QUERY_NPC_TEXT_RESPONSE                      = 0x2706,
+    SMSG_QUERY_PAGE_TEXT_RESPONSE                     = 0x2709,
+    SMSG_QUERY_PETITION_RESPONSE                      = 0x270D,
+    SMSG_QUERY_PET_NAME_RESPONSE                      = 0x270B,
+    SMSG_QUERY_PLAYER_NAME_RESPONSE                   = 0x2707,
     SMSG_QUERY_QUEST_INFO_RESPONSE                    = 0x2A95,
-    SMSG_QUERY_QUEST_REWARD_RESPONSE                  = 0x2846,
-    SMSG_QUERY_TIME_RESPONSE                          = 0x271A,
+    SMSG_QUERY_TIME_RESPONSE                          = 0x2723,
+    SMSG_QUERY_TREASURE_PICKER_RESPONSE               = 0x2850,
     SMSG_QUEST_COMPLETION_NPC_RESPONSE                = 0x2A81,
     SMSG_QUEST_CONFIRM_ACCEPT                         = 0x2A8E,
     SMSG_QUEST_FORCE_REMOVED                          = 0x2A9B,
@@ -1485,7 +1514,7 @@ enum OpcodeServer : uint16
     SMSG_QUEST_GIVER_QUEST_DETAILS                    = 0x2A91,
     SMSG_QUEST_GIVER_QUEST_FAILED                     = 0x2A85,
     SMSG_QUEST_GIVER_QUEST_LIST_MESSAGE               = 0x2A99,
-    SMSG_QUEST_GIVER_QUEST_TURN_IN_FAILURE            = 0x2852,
+    SMSG_QUEST_GIVER_QUEST_TURN_IN_FAILURE            = 0x285D,
     SMSG_QUEST_GIVER_REQUEST_ITEMS                    = 0x2A92,
     SMSG_QUEST_GIVER_STATUS                           = 0x2A9A,
     SMSG_QUEST_GIVER_STATUS_MULTIPLE                  = 0x2A90,
@@ -1501,117 +1530,115 @@ enum OpcodeServer : uint16
     SMSG_QUEST_UPDATE_COMPLETE_BY_SPELL               = 0x2A87,
     SMSG_QUEST_UPDATE_FAILED                          = 0x2A89,
     SMSG_QUEST_UPDATE_FAILED_TIMER                    = 0x2A8A,
-    SMSG_RAF_EMAIL_ENABLED_RESPONSE                   = 0x27C8,
-    SMSG_RAID_DIFFICULTY_SET                          = 0x27EF,
-    SMSG_RAID_GROUP_ONLY                              = 0x27F1,
+    SMSG_RAF_EMAIL_ENABLED_RESPONSE                   = 0x27D4,
+    SMSG_RAID_DIFFICULTY_SET                          = 0x27F7,
+    SMSG_RAID_GROUP_ONLY                              = 0x27F9,
     SMSG_RAID_INSTANCE_MESSAGE                        = 0x2BB4,
     SMSG_RAID_MARKERS_CHANGED                         = 0x25B9,
-    SMSG_RANDOM_ROLL                                  = 0x264C,
+    SMSG_RANDOM_ROLL                                  = 0x264E,
     SMSG_RATED_BATTLEFIELD_INFO                       = 0x25A6,
-    SMSG_READY_CHECK_COMPLETED                        = 0x260E,
-    SMSG_READY_CHECK_RESPONSE                         = 0x260D,
-    SMSG_READY_CHECK_STARTED                          = 0x260C,
-    SMSG_READ_ITEM_RESULT_FAILED                      = 0x27EB,
-    SMSG_READ_ITEM_RESULT_OK                          = 0x27E1,
-    SMSG_REALM_LOOKUP_INFORMATION                     = 0x2810,
-    SMSG_REALM_QUERY_RESPONSE                         = 0x26E5,
-    SMSG_RECRUIT_A_FRIEND_RESPONSE                    = 0x27C9,
-    SMSG_REFER_A_FRIEND_EXPIRED                       = 0x2762,
-    SMSG_REFER_A_FRIEND_FAILURE                       = 0x26EB,
-    SMSG_REFRESH_COMPONENT                            = 0x2678,
+    SMSG_READY_CHECK_COMPLETED                        = 0x260F,
+    SMSG_READY_CHECK_RESPONSE                         = 0x260E,
+    SMSG_READY_CHECK_STARTED                          = 0x260D,
+    SMSG_READ_ITEM_RESULT_FAILED                      = 0x27F3,
+    SMSG_READ_ITEM_RESULT_OK                          = 0x27ED,
+    SMSG_REALM_LOOKUP_INFORMATION                     = 0x2818,
+    SMSG_REALM_QUERY_RESPONSE                         = 0x26ED,
+    SMSG_RECRUIT_A_FRIEND_RESPONSE                    = 0x27D5,
+    SMSG_REFER_A_FRIEND_EXPIRED                       = 0x276A,
+    SMSG_REFER_A_FRIEND_FAILURE                       = 0x26F3,
+    SMSG_REFRESH_COMPONENT                            = 0x267B,
     SMSG_REFRESH_SPELL_HISTORY                        = 0x2C2C,
     SMSG_REMOVE_ITEM_PASSIVE                          = 0x25C0,
-    SMSG_REMOVE_LOSS_OF_CONTROL                       = 0x2697,
-    SMSG_REPLACE_TROPHY_RESPONSE                      = 0x2807,
-    SMSG_REPORT_PVP_PLAYER_AFK_RESULT                 = 0x26D9,
-    SMSG_REQUEST_ADDON_LIST                           = 0x265F,
+    SMSG_REMOVE_LOSS_OF_CONTROL                       = 0x269C,
+    SMSG_REPLACE_TROPHY_RESPONSE                      = 0x280F,
+    SMSG_REPORT_PVP_PLAYER_AFK_RESULT                 = 0x26E1,
+    SMSG_REQUEST_ADDON_LIST                           = 0x2661,
     SMSG_REQUEST_CEMETERY_LIST_RESPONSE               = 0x259D,
     SMSG_REQUEST_PVP_BRAWL_INFO_RESPONSE              = 0x25D5,
     SMSG_REQUEST_PVP_REWARDS_RESPONSE                 = 0x25D4,
     SMSG_RESEARCH_COMPLETE                            = 0x2585,
-    SMSG_RESET_AREA_TRIGGER                           = 0x2640,
     SMSG_RESET_COMPRESSION_CONTEXT                    = 0x304F,
-    SMSG_RESET_FAILED_NOTIFY                          = 0x26E1,
-    SMSG_RESET_RANGED_COMBAT_TIMER                    = 0x2713,
+    SMSG_RESET_FAILED_NOTIFY                          = 0x26E9,
+    SMSG_RESET_RANGED_COMBAT_TIMER                    = 0x271C,
     SMSG_RESET_WEEKLY_CURRENCY                        = 0x2574,
-    SMSG_RESPEC_WIPE_CONFIRM                          = 0x2626,
+    SMSG_RESPEC_WIPE_CONFIRM                          = 0x2628,
     SMSG_RESPOND_INSPECT_ACHIEVEMENTS                 = 0x2571,
     SMSG_RESUME_CAST_BAR                              = 0x2C3E,
     SMSG_RESUME_COMMS                                 = 0x304B,
     SMSG_RESUME_TOKEN                                 = 0x25BE,
     SMSG_RESURRECT_REQUEST                            = 0x257E,
-    SMSG_RESYNC_RUNES                                 = 0x273D,
+    SMSG_RESYNC_RUNES                                 = 0x2746,
     SMSG_ROLE_CHANGED_INFORM                          = 0x258C,
     SMSG_ROLE_CHOSEN                                  = 0x2A39,
     SMSG_ROLE_POLL_INFORM                             = 0x258D,
     SMSG_RUNE_REGEN_DEBUG                             = 0x25C8,
-    SMSG_SCENARIO_BOOT                                = 0x27EC,
-    SMSG_SCENARIO_COMPLETED                           = 0x282C,
-    SMSG_SCENARIO_POIS                                = 0x264F,
-    SMSG_SCENARIO_PROGRESS_UPDATE                     = 0x2648,
-    SMSG_SCENARIO_SET_SHOULD_SHOW_CRITERIA            = 0x283A,
-    SMSG_SCENARIO_SPELL_UPDATE                        = 0x2839,
-    SMSG_SCENARIO_STATE                               = 0x2647,
-    SMSG_SCENE_OBJECT_EVENT                           = 0x25F7,
-    SMSG_SCENE_OBJECT_PET_BATTLE_FINAL_ROUND          = 0x25FC,
-    SMSG_SCENE_OBJECT_PET_BATTLE_FINISHED             = 0x25FD,
-    SMSG_SCENE_OBJECT_PET_BATTLE_FIRST_ROUND          = 0x25F9,
-    SMSG_SCENE_OBJECT_PET_BATTLE_INITIAL_UPDATE       = 0x25F8,
-    SMSG_SCENE_OBJECT_PET_BATTLE_REPLACEMENTS_MADE    = 0x25FB,
-    SMSG_SCENE_OBJECT_PET_BATTLE_ROUND_RESULT         = 0x25FA,
+    SMSG_SCENARIO_BOOT                                = 0x27F4,
+    SMSG_SCENARIO_COMPLETED                           = 0x2834,
+    SMSG_SCENARIO_POIS                                = 0x2651,
+    SMSG_SCENARIO_PROGRESS_UPDATE                     = 0x264A,
+    SMSG_SCENARIO_SET_SHOULD_SHOW_CRITERIA            = 0x2844,
+    SMSG_SCENARIO_SPELL_UPDATE                        = 0x2843,
+    SMSG_SCENARIO_STATE                               = 0x2649,
+    SMSG_SCENE_OBJECT_EVENT                           = 0x25F8,
+    SMSG_SCENE_OBJECT_PET_BATTLE_FINAL_ROUND          = 0x25FD,
+    SMSG_SCENE_OBJECT_PET_BATTLE_FINISHED             = 0x25FE,
+    SMSG_SCENE_OBJECT_PET_BATTLE_FIRST_ROUND          = 0x25FA,
+    SMSG_SCENE_OBJECT_PET_BATTLE_INITIAL_UPDATE       = 0x25F9,
+    SMSG_SCENE_OBJECT_PET_BATTLE_REPLACEMENTS_MADE    = 0x25FC,
+    SMSG_SCENE_OBJECT_PET_BATTLE_ROUND_RESULT         = 0x25FB,
     SMSG_SCRIPT_CAST                                  = 0x2C55,
-    SMSG_SELL_RESPONSE                                = 0x26EF,
+    SMSG_SELL_RESPONSE                                = 0x26F7,
     SMSG_SEND_ITEM_PASSIVES                           = 0x25C1,
     SMSG_SEND_KNOWN_SPELLS                            = 0x2C2A,
-    SMSG_SEND_RAID_TARGET_UPDATE_ALL                  = 0x264A,
-    SMSG_SEND_RAID_TARGET_UPDATE_SINGLE               = 0x264B,
+    SMSG_SEND_RAID_TARGET_UPDATE_ALL                  = 0x264C,
+    SMSG_SEND_RAID_TARGET_UPDATE_SINGLE               = 0x264D,
     SMSG_SEND_SPELL_CHARGES                           = 0x2C2D,
     SMSG_SEND_SPELL_HISTORY                           = 0x2C2B,
     SMSG_SEND_UNLEARN_SPELLS                          = 0x2C2E,
-    SMSG_SERVER_FIRST_ACHIEVEMENT                     = 0x2BBC,
-    SMSG_SERVER_FIRST_ACHIEVEMENTS                    = 0x266A,
-    SMSG_SERVER_TIME                                  = 0x26AB,
+    SMSG_SERVER_FIRST_ACHIEVEMENTS                    = 0x266C,
+    SMSG_SERVER_TIME                                  = 0x26B0,
     SMSG_SETUP_CURRENCY                               = 0x2572,
     SMSG_SETUP_RESEARCH_HISTORY                       = 0x2584,
-    SMSG_SET_AI_ANIM_KIT                              = 0x2771,
-    SMSG_SET_ALL_TASK_PROGRESS                        = 0x27D1,
-    SMSG_SET_ANIM_TIER                                = 0x2775,
+    SMSG_SET_AI_ANIM_KIT                              = 0x2779,
+    SMSG_SET_ALL_TASK_PROGRESS                        = 0x27DD,
+    SMSG_SET_ANIM_TIER                                = 0x277D,
     SMSG_SET_CURRENCY                                 = 0x2573,
     SMSG_SET_DF_FAST_LAUNCH_RESULT                    = 0x2A2E,
-    SMSG_SET_DUNGEON_DIFFICULTY                       = 0x26CD,
-    SMSG_SET_FACTION_AT_WAR                           = 0x273C,
-    SMSG_SET_FACTION_NOT_VISIBLE                      = 0x276C,
-    SMSG_SET_FACTION_STANDING                         = 0x276D,
-    SMSG_SET_FACTION_VISIBLE                          = 0x276B,
+    SMSG_SET_DUNGEON_DIFFICULTY                       = 0x26D2,
+    SMSG_SET_FACTION_AT_WAR                           = 0x2745,
+    SMSG_SET_FACTION_NOT_VISIBLE                      = 0x2774,
+    SMSG_SET_FACTION_STANDING                         = 0x2775,
+    SMSG_SET_FACTION_VISIBLE                          = 0x2773,
     SMSG_SET_FLAT_SPELL_MODIFIER                      = 0x2C36,
-    SMSG_SET_FORCED_REACTIONS                         = 0x275C,
+    SMSG_SET_FORCED_REACTIONS                         = 0x2764,
     SMSG_SET_ITEM_PURCHASE_DATA                       = 0x25B0,
-    SMSG_SET_LOOT_METHOD_FAILED                       = 0x2816,
+    SMSG_SET_LOOT_METHOD_FAILED                       = 0x281E,
     SMSG_SET_MAX_WEEKLY_QUANTITY                      = 0x25B7,
-    SMSG_SET_MELEE_ANIM_KIT                           = 0x2774,
-    SMSG_SET_MOVEMENT_ANIM_KIT                        = 0x2773,
+    SMSG_SET_MELEE_ANIM_KIT                           = 0x277C,
+    SMSG_SET_MOVEMENT_ANIM_KIT                        = 0x277B,
     SMSG_SET_PCT_SPELL_MODIFIER                       = 0x2C37,
-    SMSG_SET_PET_SPECIALIZATION                       = 0x2641,
-    SMSG_SET_PLAYER_DECLINED_NAMES_RESULT             = 0x2707,
+    SMSG_SET_PET_SPECIALIZATION                       = 0x2643,
+    SMSG_SET_PLAYER_DECLINED_NAMES_RESULT             = 0x2710,
     SMSG_SET_PLAY_HOVER_ANIM                          = 0x25CC,
-    SMSG_SET_PROFICIENCY                              = 0x2776,
+    SMSG_SET_PROFICIENCY                              = 0x277E,
     SMSG_SET_SPELL_CHARGES                            = 0x2C29,
-    SMSG_SET_TASK_COMPLETE                            = 0x27D2,
-    SMSG_SET_TIME_ZONE_INFORMATION                    = 0x269F,
-    SMSG_SET_VEHICLE_REC_ID                           = 0x272F,
-    SMSG_SHOW_ADVENTURE_MAP                           = 0x2835,
-    SMSG_SHOW_BANK                                    = 0x26A8,
-    SMSG_SHOW_MAILBOX                                 = 0x27ED,
-    SMSG_SHOW_NEUTRAL_PLAYER_FACTION_SELECT_UI        = 0x25F0,
-    SMSG_SHOW_TAXI_NODES                              = 0x26F6,
-    SMSG_SHOW_TRADE_SKILL_RESPONSE                    = 0x27B2,
-    SMSG_SOCKET_GEMS                                  = 0x2768,
-    SMSG_SOCKET_GEMS_FAILURE                          = 0x2769,
-    SMSG_SORT_BAGS_RESULT                             = 0x2824,
-    SMSG_SOR_START_EXPERIENCE_INCOMPLETE              = 0x25F2,
-    SMSG_SPECIALIZATION_CHANGED                       = 0x25EC,
-    SMSG_SPECIAL_MOUNT_ANIM                           = 0x26C8,
-    SMSG_SPEC_INVOLUNTARILY_CHANGED                   = 0x2757,
+    SMSG_SET_TASK_COMPLETE                            = 0x27DE,
+    SMSG_SET_TIME_ZONE_INFORMATION                    = 0x26A4,
+    SMSG_SET_VEHICLE_REC_ID                           = 0x2738,
+    SMSG_SHOW_ADVENTURE_MAP                           = 0x283D,
+    SMSG_SHOW_BANK                                    = 0x26AD,
+    SMSG_SHOW_MAILBOX                                 = 0x27F5,
+    SMSG_SHOW_NEUTRAL_PLAYER_FACTION_SELECT_UI        = 0x25F1,
+    SMSG_SHOW_TAXI_NODES                              = 0x26FE,
+    SMSG_SHOW_TRADE_SKILL_RESPONSE                    = 0x27BE,
+    SMSG_SOCKET_GEMS                                  = 0x2770,
+    SMSG_SOCKET_GEMS_FAILURE                          = 0x2771,
+    SMSG_SORT_BAGS_RESULT                             = 0x282C,
+    SMSG_SOR_START_EXPERIENCE_INCOMPLETE              = 0x25F3,
+    SMSG_SPECIALIZATION_CHANGED                       = 0x25ED,
+    SMSG_SPECIAL_MOUNT_ANIM                           = 0x26CD,
+    SMSG_SPEC_INVOLUNTARILY_CHANGED                   = 0x2760,
     SMSG_SPELL_ABSORB_LOG                             = 0x2C1F,
     SMSG_SPELL_CATEGORY_COOLDOWN                      = 0x2C17,
     SMSG_SPELL_CHANNEL_START                          = 0x2C34,
@@ -1636,73 +1663,73 @@ enum OpcodeServer : uint16
     SMSG_SPELL_PERIODIC_AURA_LOG                      = 0x2C1B,
     SMSG_SPELL_PREPARE                                = 0x2C38,
     SMSG_SPELL_START                                  = 0x2C3A,
-    SMSG_SPIRIT_HEALER_CONFIRM                        = 0x2754,
-    SMSG_STAND_STATE_UPDATE                           = 0x275B,
-    SMSG_START_ELAPSED_TIMER                          = 0x261A,
-    SMSG_START_ELAPSED_TIMERS                         = 0x261C,
-    SMSG_START_LOOT_ROLL                              = 0x2631,
-    SMSG_START_MIRROR_TIMER                           = 0x274E,
+    SMSG_SPIRIT_HEALER_CONFIRM                        = 0x275D,
+    SMSG_STAND_STATE_UPDATE                           = 0x2763,
+    SMSG_START_ELAPSED_TIMER                          = 0x261B,
+    SMSG_START_ELAPSED_TIMERS                         = 0x261D,
+    SMSG_START_LOOT_ROLL                              = 0x2633,
+    SMSG_START_MIRROR_TIMER                           = 0x2757,
     SMSG_START_TIMER                                  = 0x25BB,
-    SMSG_STOP_ELAPSED_TIMER                           = 0x261B,
-    SMSG_STOP_MIRROR_TIMER                            = 0x2750,
-    SMSG_STOP_SPEAKERBOT_SOUND                        = 0x27AE,
+    SMSG_STOP_ELAPSED_TIMER                           = 0x261C,
+    SMSG_STOP_MIRROR_TIMER                            = 0x2759,
+    SMSG_STOP_SPEAKERBOT_SOUND                        = 0x27BA,
     SMSG_STREAMING_MOVIES                             = 0x25BA,
-    SMSG_SUMMON_CANCEL                                = 0x26D8,
+    SMSG_SUMMON_CANCEL                                = 0x26E0,
     SMSG_SUMMON_RAID_MEMBER_VALIDATE_FAILED           = 0x258E,
-    SMSG_SUMMON_REQUEST                               = 0x2760,
+    SMSG_SUMMON_REQUEST                               = 0x2768,
     SMSG_SUPERCEDED_SPELLS                            = 0x2C4C,
     SMSG_SUSPEND_COMMS                                = 0x304A,
     SMSG_SUSPEND_TOKEN                                = 0x25BD,
-    SMSG_TALENTS_INVOLUNTARILY_RESET                  = 0x2756,
-    SMSG_TAXI_NODE_STATUS                             = 0x26A5,
-    SMSG_TEXT_EMOTE                                   = 0x26A3,
-    SMSG_THREAT_CLEAR                                 = 0x270F,
-    SMSG_THREAT_REMOVE                                = 0x270E,
-    SMSG_THREAT_UPDATE                                = 0x270D,
+    SMSG_TALENTS_INVOLUNTARILY_RESET                  = 0x275F,
+    SMSG_TAXI_NODE_STATUS                             = 0x26AA,
+    SMSG_TEXT_EMOTE                                   = 0x26A8,
+    SMSG_THREAT_CLEAR                                 = 0x2718,
+    SMSG_THREAT_REMOVE                                = 0x2717,
+    SMSG_THREAT_UPDATE                                = 0x2716,
     SMSG_TIME_ADJUSTMENT                              = 0x2DA1,
     SMSG_TIME_SYNC_REQUEST                            = 0x2DA0,
-    SMSG_TITLE_EARNED                                 = 0x270A,
-    SMSG_TITLE_LOST                                   = 0x270B,
-    SMSG_TOTEM_CREATED                                = 0x26F2,
-    SMSG_TOTEM_MOVED                                  = 0x26F3,
+    SMSG_TITLE_EARNED                                 = 0x2713,
+    SMSG_TITLE_LOST                                   = 0x2714,
+    SMSG_TOTEM_CREATED                                = 0x26FA,
+    SMSG_TOTEM_MOVED                                  = 0x26FB,
     SMSG_TRADE_STATUS                                 = 0x2581,
     SMSG_TRADE_UPDATED                                = 0x2580,
-    SMSG_TRAINER_BUY_FAILED                           = 0x2715,
-    SMSG_TRAINER_LIST                                 = 0x2714,
-    SMSG_TRANSFER_ABORTED                             = 0x2740,
+    SMSG_TRAINER_BUY_FAILED                           = 0x271E,
+    SMSG_TRAINER_LIST                                 = 0x271D,
+    SMSG_TRANSFER_ABORTED                             = 0x2749,
     SMSG_TRANSFER_PENDING                             = 0x25E5,
     SMSG_TRANSMOG_COLLECTION_UPDATE                   = 0x25C6,
     SMSG_TRANSMOG_SET_COLLECTION_UPDATE               = 0x25C7,
-    SMSG_TRIGGER_CINEMATIC                            = 0x280E,
-    SMSG_TRIGGER_MOVIE                                = 0x26F4,
-    SMSG_TURN_IN_PETITION_RESULT                      = 0x2791,
-    SMSG_TUTORIAL_FLAGS                               = 0x2800,
-    SMSG_TUTORIAL_HIGHLIGHT_SPELL                     = 0x2840,
-    SMSG_TUTORIAL_UNHIGHLIGHT_SPELL                   = 0x283F,
+    SMSG_TRIGGER_CINEMATIC                            = 0x2816,
+    SMSG_TRIGGER_MOVIE                                = 0x26FC,
+    SMSG_TURN_IN_PETITION_RESULT                      = 0x279A,
+    SMSG_TUTORIAL_FLAGS                               = 0x2808,
+    SMSG_TUTORIAL_HIGHLIGHT_SPELL                     = 0x284A,
+    SMSG_TUTORIAL_UNHIGHLIGHT_SPELL                   = 0x2849,
     SMSG_TWITTER_STATUS                               = 0x2FFD,
-    SMSG_UI_TIME                                      = 0x2753,
-    SMSG_UNDELETE_CHARACTER_RESPONSE                  = 0x2811,
-    SMSG_UNDELETE_COOLDOWN_STATUS_RESPONSE            = 0x2812,
+    SMSG_UI_TIME                                      = 0x275C,
+    SMSG_UNDELETE_CHARACTER_RESPONSE                  = 0x2819,
+    SMSG_UNDELETE_COOLDOWN_STATUS_RESPONSE            = 0x281A,
     SMSG_UNLEARNED_SPELLS                             = 0x2C4E,
-    SMSG_UPDATE_ACCOUNT_DATA                          = 0x2748,
-    SMSG_UPDATE_ACTION_BUTTONS                        = 0x25F5,
-    SMSG_UPDATE_CELESTIAL_BODY                        = 0x285E,
-    SMSG_UPDATE_CHARACTER_FLAGS                       = 0x2806,
-    SMSG_UPDATE_EXPANSION_LEVEL                       = 0x2663,
-    SMSG_UPDATE_GAME_TIME_STATE                       = 0x2865,
-    SMSG_UPDATE_INSTANCE_OWNERSHIP                    = 0x26D0,
-    SMSG_UPDATE_LAST_INSTANCE                         = 0x26B1,
-    SMSG_UPDATE_OBJECT                                = 0x280F,
-    SMSG_UPDATE_TALENT_DATA                           = 0x25EB,
-    SMSG_UPDATE_TASK_PROGRESS                         = 0x27D0,
+    SMSG_UPDATE_ACCOUNT_DATA                          = 0x2751,
+    SMSG_UPDATE_ACTION_BUTTONS                        = 0x25F6,
+    SMSG_UPDATE_CELESTIAL_BODY                        = 0x286E,
+    SMSG_UPDATE_CHARACTER_FLAGS                       = 0x280E,
+    SMSG_UPDATE_EXPANSION_LEVEL                       = 0x2665,
+    SMSG_UPDATE_GAME_TIME_STATE                       = 0x2875,
+    SMSG_UPDATE_INSTANCE_OWNERSHIP                    = 0x26D7,
+    SMSG_UPDATE_LAST_INSTANCE                         = 0x26B6,
+    SMSG_UPDATE_OBJECT                                = 0x2817,
+    SMSG_UPDATE_TALENT_DATA                           = 0x25EC,
+    SMSG_UPDATE_TASK_PROGRESS                         = 0x27DC,
     SMSG_UPDATE_WEEKLY_SPELL_USAGE                    = 0x2C19,
-    SMSG_UPDATE_WORLD_STATE                           = 0x278C,
+    SMSG_UPDATE_WORLD_STATE                           = 0x2794,
     SMSG_USERLIST_ADD                                 = 0x2BB9,
     SMSG_USERLIST_REMOVE                              = 0x2BBA,
     SMSG_USERLIST_UPDATE                              = 0x2BBB,
-    SMSG_USE_EQUIPMENT_SET_RESULT                     = 0x2792,
+    SMSG_USE_EQUIPMENT_SET_RESULT                     = 0x279B,
     SMSG_VENDOR_INVENTORY                             = 0x25CA,
-    SMSG_VIGNETTE_UPDATE                              = 0x27B0,
+    SMSG_VIGNETTE_UPDATE                              = 0x27BC,
     SMSG_VOID_ITEM_SWAP_RESPONSE                      = 0x25DF,
     SMSG_VOID_STORAGE_CONTENTS                        = 0x25DC,
     SMSG_VOID_STORAGE_FAILED                          = 0x25DB,
@@ -1711,30 +1738,31 @@ enum OpcodeServer : uint16
     SMSG_WAIT_QUEUE_FINISH                            = 0x256E,
     SMSG_WAIT_QUEUE_UPDATE                            = 0x256D,
     SMSG_WARDEN_DATA                                  = 0x2576,
+    SMSG_WARFRONT_COMPLETED                           = 0x27AD,
     SMSG_WARGAME_REQUEST_SUCCESSFULLY_SENT_TO_OPPONENT = 0x25B4,
-    SMSG_WEATHER                                      = 0x26CF,
+    SMSG_WEATHER                                      = 0x26D4,
     SMSG_WEEKLY_SPELL_USAGE                           = 0x2C18,
     SMSG_WHO                                          = 0x2BAE,
-    SMSG_WHO_IS                                       = 0x26CE,
-    SMSG_WORLD_QUEST_UPDATE                           = 0x2847,
+    SMSG_WHO_IS                                       = 0x26D3,
+    SMSG_WORLD_QUEST_UPDATE                           = 0x2851,
     SMSG_WORLD_SERVER_INFO                            = 0x25C2,
-    SMSG_WORLD_TEXT                                   = 0x282E,
-    SMSG_WOW_TOKEN_AUCTION_SOLD                       = 0x281C,
-    SMSG_WOW_TOKEN_BUY_REQUEST_CONFIRMATION           = 0x281E,
-    SMSG_WOW_TOKEN_BUY_RESULT_CONFIRMATION            = 0x281F,
-    SMSG_WOW_TOKEN_CAN_REDEEM_FOR_BALANCE_RESULT      = 0x2856,
-    SMSG_WOW_TOKEN_CAN_VETERAN_BUY_RESULT             = 0x281D,
-    SMSG_WOW_TOKEN_DISTRIBUTION_GLUE_UPDATE           = 0x2817,
-    SMSG_WOW_TOKEN_DISTRIBUTION_UPDATE                = 0x2818,
-    SMSG_WOW_TOKEN_MARKET_PRICE_RESPONSE              = 0x2819,
-    SMSG_WOW_TOKEN_REDEEM_GAME_TIME_UPDATED           = 0x2820,
-    SMSG_WOW_TOKEN_REDEEM_REQUEST_CONFIRMATION        = 0x2821,
-    SMSG_WOW_TOKEN_REDEEM_RESULT                      = 0x2822,
-    SMSG_WOW_TOKEN_SELL_REQUEST_CONFIRMATION          = 0x281A,
-    SMSG_WOW_TOKEN_SELL_RESULT_CONFIRMATION           = 0x281B,
-    SMSG_WOW_TOKEN_UPDATE_AUCTIONABLE_LIST_RESPONSE   = 0x2823,
+    SMSG_WORLD_TEXT                                   = 0x2836,
+    SMSG_WOW_TOKEN_AUCTION_SOLD                       = 0x2824,
+    SMSG_WOW_TOKEN_BUY_REQUEST_CONFIRMATION           = 0x2826,
+    SMSG_WOW_TOKEN_BUY_RESULT_CONFIRMATION            = 0x2827,
+    SMSG_WOW_TOKEN_CAN_REDEEM_FOR_BALANCE_RESULT      = 0x2861,
+    SMSG_WOW_TOKEN_CAN_VETERAN_BUY_RESULT             = 0x2825,
+    SMSG_WOW_TOKEN_DISTRIBUTION_GLUE_UPDATE           = 0x281F,
+    SMSG_WOW_TOKEN_DISTRIBUTION_UPDATE                = 0x2820,
+    SMSG_WOW_TOKEN_MARKET_PRICE_RESPONSE              = 0x2821,
+    SMSG_WOW_TOKEN_REDEEM_GAME_TIME_UPDATED           = 0x2828,
+    SMSG_WOW_TOKEN_REDEEM_REQUEST_CONFIRMATION        = 0x2829,
+    SMSG_WOW_TOKEN_REDEEM_RESULT                      = 0x282A,
+    SMSG_WOW_TOKEN_SELL_REQUEST_CONFIRMATION          = 0x2822,
+    SMSG_WOW_TOKEN_SELL_RESULT_CONFIRMATION           = 0x2823,
+    SMSG_WOW_TOKEN_UPDATE_AUCTIONABLE_LIST_RESPONSE   = 0x282B,
     SMSG_XP_GAIN_ABORTED                              = 0x25E0,
-    SMSG_XP_GAIN_ENABLED                              = 0x27F0,
+    SMSG_XP_GAIN_ENABLED                              = 0x27F8,
     SMSG_ZONE_UNDER_ATTACK                            = 0x2BB5,
 
     // Opcodes that are not generated automatically
diff --git a/src/server/game/Server/WorldSession.cpp b/src/server/game/Server/WorldSession.cpp
index acadaf0d64a..b7994e19bf6 100644
--- a/src/server/game/Server/WorldSession.cpp
+++ b/src/server/game/Server/WorldSession.cpp
@@ -572,9 +572,9 @@ void WorldSession::LogoutPlayer(bool save)
             for (int j = BUYBACK_SLOT_START; j < BUYBACK_SLOT_END; ++j)
             {
                 eslot = j - BUYBACK_SLOT_START;
-                _player->SetGuidValue(PLAYER_FIELD_INV_SLOT_HEAD + (j * 4), ObjectGuid::Empty);
-                _player->SetUInt32Value(PLAYER_FIELD_BUYBACK_PRICE_1 + eslot, 0);
-                _player->SetUInt32Value(PLAYER_FIELD_BUYBACK_TIMESTAMP_1 + eslot, 0);
+                _player->SetGuidValue(ACTIVE_PLAYER_FIELD_INV_SLOT_HEAD + (j * 4), ObjectGuid::Empty);
+                _player->SetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_PRICE + eslot, 0);
+                _player->SetUInt32Value(ACTIVE_PLAYER_FIELD_BUYBACK_TIMESTAMP + eslot, 0);
             }
             _player->SaveToDB();
         }
@@ -1228,11 +1228,8 @@ uint32 WorldSession::DosProtection::GetMaxPacketCounterAllowed(uint16 opcode) co
         case CMSG_QUEST_GIVER_STATUS_MULTIPLE_QUERY:    //   0               2.5
         case CMSG_BEGIN_TRADE:                          //   0               2.5
         case CMSG_INITIATE_TRADE:                       //   0               3
-        case CMSG_CHAT_ADDON_MESSAGE_GUILD:             //   0               3.5
-        case CMSG_CHAT_ADDON_MESSAGE_OFFICER:           //   0               3.5
-        case CMSG_CHAT_ADDON_MESSAGE_PARTY:             //   0               3.5
-        case CMSG_CHAT_ADDON_MESSAGE_RAID:              //   0               3.5
-        case CMSG_CHAT_ADDON_MESSAGE_WHISPER:           //   0               3.5
+        case CMSG_CHAT_ADDON_MESSAGE:                   //   0               3.5
+        case CMSG_CHAT_ADDON_MESSAGE_TARGETED:          //   0               3.5
         case CMSG_CHAT_MESSAGE_AFK:                     //   0               3.5
         case CMSG_CHAT_MESSAGE_CHANNEL:                 //   0               3.5
         case CMSG_CHAT_MESSAGE_DND:                     //   0               3.5
diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h
index bba6b5ce039..ecf3dcf5819 100644
--- a/src/server/game/Server/WorldSession.h
+++ b/src/server/game/Server/WorldSession.h
@@ -178,7 +178,7 @@ namespace WorldPackets
         class CalendarGetCalendar;
         class CalendarGetEvent;
         class CalendarGetNumPending;
-        class CalendarGuildFilter;
+        class CalendarCommunityFilter;
         class CalendarRemoveEvent;
         class CalendarRemoveInvite;
         class CalendarUpdateEvent;
@@ -243,8 +243,7 @@ namespace WorldPackets
         class ChatMessageWhisper;
         class ChatMessageChannel;
         class ChatAddonMessage;
-        class ChatAddonMessageWhisper;
-        class ChatAddonMessageChannel;
+        class ChatAddonMessageTargeted;
         class ChatMessageAFK;
         class ChatMessageDND;
         class ChatMessageEmote;
@@ -466,7 +465,6 @@ namespace WorldPackets
         class MountSpecial;
         class SetTaxiBenchmarkMode;
         class MountSetFavorite;
-        class PvpPrestigeRankUp;
         class CloseInteraction;
     }
 
@@ -1129,7 +1127,7 @@ class TC_GAME_API WorldSession
         void HandleUndeleteCooldownStatusCallback(PreparedQueryResult result);
         void HandleCharUndeleteOpcode(WorldPackets::Character::UndeleteCharacter& undeleteInfo);
 
-        void SendCharCreate(ResponseCodes result);
+        void SendCharCreate(ResponseCodes result, ObjectGuid const& guid = ObjectGuid::Empty);
         void SendCharDelete(ResponseCodes result);
         void SendCharRename(ResponseCodes result, WorldPackets::Character::CharacterRenameInfo const* renameInfo);
         void SendCharCustomize(ResponseCodes result, WorldPackets::Character::CharCustomizeInfo const* customizeInfo);
@@ -1454,8 +1452,7 @@ class TC_GAME_API WorldSession
         void HandleChatMessageChannelOpcode(WorldPackets::Chat::ChatMessageChannel& chatMessageChannel);
         void HandleChatMessage(ChatMsg type, uint32 lang, std::string msg, std::string target = "");
         void HandleChatAddonMessageOpcode(WorldPackets::Chat::ChatAddonMessage& chatAddonMessage);
-        void HandleChatAddonMessageWhisperOpcode(WorldPackets::Chat::ChatAddonMessageWhisper& chatAddonMessageWhisper);
-        void HandleChatAddonMessageChannelOpcode(WorldPackets::Chat::ChatAddonMessageChannel& chatAddonMessageChannel);
+        void HandleChatAddonMessageTargetedOpcode(WorldPackets::Chat::ChatAddonMessageTargeted& chatAddonMessageTargeted);
         void HandleChatAddonMessage(ChatMsg type, std::string prefix, std::string text, std::string target = "");
         void HandleChatMessageAFKOpcode(WorldPackets::Chat::ChatMessageAFK& chatMessageAFK);
         void HandleChatMessageDNDOpcode(WorldPackets::Chat::ChatMessageDND& chatMessageDND);
@@ -1608,7 +1605,7 @@ class TC_GAME_API WorldSession
         // Calendar
         void HandleCalendarGetCalendar(WorldPackets::Calendar::CalendarGetCalendar& calendarGetCalendar);
         void HandleCalendarGetEvent(WorldPackets::Calendar::CalendarGetEvent& calendarGetEvent);
-        void HandleCalendarGuildFilter(WorldPackets::Calendar::CalendarGuildFilter& calendarGuildFilter);
+        void HandleCalendarCommunityFilter(WorldPackets::Calendar::CalendarCommunityFilter& calendarCommunityFilter);
         void HandleCalendarAddEvent(WorldPackets::Calendar::CalendarAddEvent& calendarAddEvent);
         void HandleCalendarUpdateEvent(WorldPackets::Calendar::CalendarUpdateEvent& calendarUpdateEvent);
         void HandleCalendarRemoveEvent(WorldPackets::Calendar::CalendarRemoveEvent& calendarRemoveEvent);
@@ -1717,9 +1714,6 @@ class TC_GAME_API WorldSession
         // Scenario
         void HandleQueryScenarioPOI(WorldPackets::Scenario::QueryScenarioPOI& queryScenarioPOI);
 
-        // Honor
-        void HandlePvpPrestigeRankUp(WorldPackets::Misc::PvpPrestigeRankUp& /*pvpPrestigeRankUp*/);
-
         union ConnectToKey
         {
             struct
diff --git a/src/server/game/Server/WorldSocket.cpp b/src/server/game/Server/WorldSocket.cpp
index 974fb7879dc..dd4a75865ac 100644
--- a/src/server/game/Server/WorldSocket.cpp
+++ b/src/server/game/Server/WorldSocket.cpp
@@ -70,8 +70,7 @@ uint8 const WorldSocket::AuthCheckSeed[16] = { 0xC5, 0xC6, 0x98, 0x95, 0x76, 0x3
 uint8 const WorldSocket::SessionKeySeed[16] = { 0x58, 0xCB, 0xCF, 0x40, 0xFE, 0x2E, 0xCE, 0xA6, 0x5A, 0x90, 0xB8, 0x01, 0x68, 0x6C, 0x28, 0x0B };
 uint8 const WorldSocket::ContinuedSessionSeed[16] = { 0x16, 0xAD, 0x0C, 0xD4, 0x46, 0xF9, 0x4F, 0xB2, 0xEF, 0x7D, 0xEA, 0x2A, 0x17, 0x66, 0x4D, 0x2F };
 
-uint8 const ClientTypeSeed_Win[16] = { 0x79, 0x7E, 0xCC, 0x19, 0x66, 0x2D, 0xCB, 0xD5, 0x09, 0x0A, 0x44, 0x81, 0x17, 0x3F, 0x1D, 0x26 };
-uint8 const ClientTypeSeed_Wn64[16] = { 0x6E, 0x21, 0x2D, 0xEF, 0x6A, 0x01, 0x24, 0xA3, 0xD9, 0xAD, 0x07, 0xF5, 0xE3, 0x22, 0xF7, 0xAE };
+uint8 const ClientTypeSeed_Wn64[16] = { 0xDD, 0x62, 0x65, 0x17, 0xCC, 0x6D, 0x31, 0x93, 0x2B, 0x47, 0x99, 0x34, 0xCC, 0xDC, 0x0A, 0xBF };
 uint8 const ClientTypeSeed_Mc64[16] = { 0x34, 0x1C, 0xFE, 0xFE, 0x3D, 0x72, 0xAC, 0xA9, 0xA4, 0x40, 0x7D, 0xC5, 0x35, 0xDE, 0xD6, 0x6A };
 
 WorldSocket::WorldSocket(tcp::socket&& socket) : Socket(std::move(socket)),
@@ -670,9 +669,7 @@ void WorldSocket::HandleAuthSessionCallback(std::shared_ptr<WorldPackets::Auth::
 
     SHA256Hash digestKeyHash;
     digestKeyHash.UpdateData(account.Game.KeyData.data(), account.Game.KeyData.size());
-    if (account.Game.OS == "Win")
-        digestKeyHash.UpdateData(ClientTypeSeed_Win, 16);
-    else if (account.Game.OS == "Wn64")
+    if (account.Game.OS == "Wn64")
         digestKeyHash.UpdateData(ClientTypeSeed_Wn64, 16);
     else if (account.Game.OS == "Mc64")
         digestKeyHash.UpdateData(ClientTypeSeed_Mc64, 16);
diff --git a/src/server/game/Services/WorldserverService.h b/src/server/game/Services/WorldserverService.h
index 04c5aa0fcaf..4ff6d23ec16 100644
--- a/src/server/game/Services/WorldserverService.h
+++ b/src/server/game/Services/WorldserverService.h
@@ -22,12 +22,15 @@
 #include "account_service.pb.h"
 #include "authentication_service.pb.h"
 #include "challenge_service.pb.h"
-#include "channel_service.pb.h"
+#include "club_membership_listener.pb.h"
+#include "club_membership_service.pb.h"
 #include "connection_service.pb.h"
 #include "friends_service.pb.h"
 #include "game_utilities_service.pb.h"
+#include "presence_listener.pb.h"
 #include "presence_service.pb.h"
 #include "report_service.pb.h"
+#include "api/client/v2/report_service.pb.h"
 #include "resource_service.pb.h"
 #include "user_manager_service.pb.h"
 
diff --git a/src/server/game/Services/WorldserverServiceDispatcher.cpp b/src/server/game/Services/WorldserverServiceDispatcher.cpp
index 41848acfbc1..49e760176dc 100644
--- a/src/server/game/Services/WorldserverServiceDispatcher.cpp
+++ b/src/server/game/Services/WorldserverServiceDispatcher.cpp
@@ -22,13 +22,13 @@ Battlenet::WorldserverServiceDispatcher::WorldserverServiceDispatcher()
 {
     AddService<WorldserverService<account::v1::AccountService>>();
     AddService<WorldserverService<authentication::v1::AuthenticationService>>();
-    AddService<WorldserverService<challenge::v1::ChallengeService>>();
-    AddService<WorldserverService<channel::v1::ChannelService>>();
+    AddService<WorldserverService<club::v1::membership::ClubMembershipService>>();
     AddService<WorldserverService<connection::v1::ConnectionService>>();
     AddService<WorldserverService<friends::v1::FriendsService>>();
     AddService<GameUtilitiesService>();
     AddService<WorldserverService<presence::v1::PresenceService>>();
     AddService<WorldserverService<report::v1::ReportService>>();
+    AddService<WorldserverService<report::v2::ReportService>>();
     AddService<WorldserverService<resources::v1::ResourcesService>>();
     AddService<WorldserverService<user_manager::v1::UserManagerService>>();
 }
diff --git a/src/server/game/Services/WorldserverServiceDispatcher.h b/src/server/game/Services/WorldserverServiceDispatcher.h
index 9cdb2c27639..3aec2011fbe 100644
--- a/src/server/game/Services/WorldserverServiceDispatcher.h
+++ b/src/server/game/Services/WorldserverServiceDispatcher.h
@@ -25,12 +25,15 @@
 #include "account_service.pb.h"
 #include "authentication_service.pb.h"
 #include "challenge_service.pb.h"
-#include "channel_service.pb.h"
+#include "club_membership_listener.pb.h"
+#include "club_membership_service.pb.h"
 #include "connection_service.pb.h"
 #include "friends_service.pb.h"
 #include "game_utilities_service.pb.h"
+#include "presence_listener.pb.h"
 #include "presence_service.pb.h"
 #include "report_service.pb.h"
+#include "api/client/v2/report_service.pb.h"
 #include "resource_service.pb.h"
 #include "user_manager_service.pb.h"
 
diff --git a/src/server/game/Spells/Auras/SpellAuraDefines.h b/src/server/game/Spells/Auras/SpellAuraDefines.h
index c988199638e..75860abe402 100644
--- a/src/server/game/Spells/Auras/SpellAuraDefines.h
+++ b/src/server/game/Spells/Auras/SpellAuraDefines.h
@@ -562,7 +562,9 @@ enum AuraType : uint32
     SPELL_AURA_489                                          = 489,
     SPELL_AURA_490                                          = 490,
     SPELL_AURA_491                                          = 491,
-    TOTAL_AURAS                                             = 492
+    SPELL_AURA_492                                          = 492,
+    SPELL_AURA_493                                          = 493, // 1 spell, 267116 - Animal Companion (modifies Call Pet)
+    TOTAL_AURAS
 };
 
 enum AuraObjectType
diff --git a/src/server/game/Spells/Auras/SpellAuraEffects.cpp b/src/server/game/Spells/Auras/SpellAuraEffects.cpp
index b639fe12d75..3ed8cc430de 100644
--- a/src/server/game/Spells/Auras/SpellAuraEffects.cpp
+++ b/src/server/game/Spells/Auras/SpellAuraEffects.cpp
@@ -563,7 +563,7 @@ pAuraEffectHandler AuraEffectHandler[TOTAL_AURAS]=
 AuraEffect::AuraEffect(Aura* base, uint32 effIndex, int32 *baseAmount, Unit* caster) :
 m_base(base), m_spellInfo(base->GetSpellInfo()),
 _effectInfo(base->GetSpellEffectInfo(effIndex)),
-m_baseAmount(baseAmount ? *baseAmount : base->GetSpellEffectInfo(effIndex)->BasePoints),
+m_baseAmount(baseAmount ? *baseAmount : _effectInfo->CalcBaseValue(caster, base->GetType() == UNIT_AURA_TYPE ? base->GetOwner()->ToUnit() : nullptr, base->GetCastItemLevel())),
 m_damage(0), m_critChance(0.0f), m_donePct(1.0f),
 m_spellmod(NULL), m_periodicTimer(0), m_tickNumber(0), m_effIndex(effIndex),
 m_canBeRecalculated(true), m_isPeriodic(false)
@@ -609,7 +609,7 @@ int32 AuraEffect::CalculateAmount(Unit* caster)
     if (!m_spellInfo->HasAttribute(SPELL_ATTR8_MASTERY_SPECIALIZATION) || G3D::fuzzyEq(GetSpellEffectInfo()->BonusCoefficient, 0.0f))
         amount = GetSpellEffectInfo()->CalcValue(caster, &m_baseAmount, GetBase()->GetOwner()->ToUnit(), nullptr, GetBase()->GetCastItemLevel());
     else if (caster && caster->GetTypeId() == TYPEID_PLAYER)
-        amount = int32(caster->GetFloatValue(PLAYER_MASTERY) * GetSpellEffectInfo()->BonusCoefficient);
+        amount = int32(caster->GetFloatValue(ACTIVE_PLAYER_FIELD_MASTERY) * GetSpellEffectInfo()->BonusCoefficient);
 
     // check item enchant aura cast
     if (!amount && caster)
@@ -1483,7 +1483,7 @@ void AuraEffect::HandleModInvisibility(AuraApplication const* aurApp, uint8 mode
     {
         // apply glow vision
         if (target->GetTypeId() == TYPEID_PLAYER)
-            target->SetByteFlag(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW);
+            target->SetByteFlag(ACTIVE_PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW);
 
         target->m_invisibility.AddFlag(type);
         target->m_invisibility.AddValue(type, GetAmount());
@@ -1495,7 +1495,7 @@ void AuraEffect::HandleModInvisibility(AuraApplication const* aurApp, uint8 mode
             // if not have different invisibility auras.
             // remove glow vision
             if (target->GetTypeId() == TYPEID_PLAYER)
-                target->RemoveByteFlag(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW);
+                target->RemoveByteFlag(ACTIVE_PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW);
 
             target->m_invisibility.DelFlag(type);
         }
@@ -1567,7 +1567,7 @@ void AuraEffect::HandleModStealth(AuraApplication const* aurApp, uint8 mode, boo
 
         target->SetStandFlags(UNIT_STAND_FLAGS_CREEP);
         if (target->GetTypeId() == TYPEID_PLAYER)
-            target->SetByteFlag(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_STEALTH);
+            target->SetByteFlag(ACTIVE_PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_STEALTH);
     }
     else
     {
@@ -1579,7 +1579,7 @@ void AuraEffect::HandleModStealth(AuraApplication const* aurApp, uint8 mode, boo
 
             target->RemoveStandFlags(UNIT_STAND_FLAGS_CREEP);
             if (target->GetTypeId() == TYPEID_PLAYER)
-                target->RemoveByteFlag(PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_STEALTH);
+                target->RemoveByteFlag(ACTIVE_PLAYER_FIELD_BYTES2, PLAYER_FIELD_BYTES_2_OFFSET_AURA_VISION, PLAYER_FIELD_BYTE2_STEALTH);
         }
     }
 
@@ -2011,7 +2011,7 @@ void AuraEffect::HandleAuraTransform(AuraApplication const* aurApp, uint8 mode,
                     uint32 model_id = 0;
 
                     // choose a model, based on trigger flag
-                    if (uint32 modelid = sObjectMgr->ChooseDisplayId(ci))
+                    if (uint32 modelid = ObjectMgr::ChooseDisplayId(ci)->CreatureDisplayID)
                         model_id = modelid;
 
                     target->SetDisplayId(model_id);
@@ -2052,10 +2052,10 @@ void AuraEffect::HandleAuraTransform(AuraApplication const* aurApp, uint8 mode,
                 uint32 cr_id = target->GetAuraEffectsByType(SPELL_AURA_MOUNTED).front()->GetMiscValue();
                 if (CreatureTemplate const* ci = sObjectMgr->GetCreatureTemplate(cr_id))
                 {
-                    uint32 displayID = ObjectMgr::ChooseDisplayId(ci);
-                    sObjectMgr->GetCreatureModelRandomGender(&displayID);
+                    CreatureModel model = *ObjectMgr::ChooseDisplayId(ci);
+                    sObjectMgr->GetCreatureModelRandomGender(&model, ci);
 
-                    target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, displayID);
+                    target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, model.CreatureDisplayID);
                 }
             }
         }
@@ -2400,9 +2400,9 @@ void AuraEffect::HandleAuraTrackCreatures(AuraApplication const* aurApp, uint8 m
         return;
 
     if (apply)
-        target->SetFlag(PLAYER_TRACK_CREATURES, uint32(1) << (GetMiscValue() - 1));
+        target->SetFlag(ACTIVE_PLAYER_FIELD_TRACK_CREATURES, uint32(1) << (GetMiscValue() - 1));
     else
-        target->RemoveFlag(PLAYER_TRACK_CREATURES, uint32(1) << (GetMiscValue() - 1));
+        target->RemoveFlag(ACTIVE_PLAYER_FIELD_TRACK_CREATURES, uint32(1) << (GetMiscValue() - 1));
 }
 
 void AuraEffect::HandleAuraTrackResources(AuraApplication const* aurApp, uint8 mode, bool apply) const
@@ -2416,9 +2416,9 @@ void AuraEffect::HandleAuraTrackResources(AuraApplication const* aurApp, uint8 m
         return;
 
     if (apply)
-        target->SetFlag(PLAYER_TRACK_RESOURCES, uint32(1) << (GetMiscValue() - 1));
+        target->SetFlag(ACTIVE_PLAYER_FIELD_TRACK_RESOURCES, uint32(1) << (GetMiscValue() - 1));
     else
-        target->RemoveFlag(PLAYER_TRACK_RESOURCES, uint32(1) << (GetMiscValue() - 1));
+        target->RemoveFlag(ACTIVE_PLAYER_FIELD_TRACK_RESOURCES, uint32(1) << (GetMiscValue() - 1));
 }
 
 void AuraEffect::HandleAuraTrackStealthed(AuraApplication const* aurApp, uint8 mode, bool apply) const
@@ -2437,7 +2437,7 @@ void AuraEffect::HandleAuraTrackStealthed(AuraApplication const* aurApp, uint8 m
         if (target->HasAuraType(GetAuraType()))
             return;
     }
-    target->ApplyModFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_TRACK_STEALTHED, apply);
+    target->ApplyModFlag(ACTIVE_PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_TRACK_STEALTHED, apply);
 }
 
 void AuraEffect::HandleAuraModStalked(AuraApplication const* aurApp, uint8 mode, bool apply) const
@@ -2553,8 +2553,9 @@ void AuraEffect::HandleAuraMounted(AuraApplication const* aurApp, uint8 mode, bo
 
             if (!displayId)
             {
-                displayId = ObjectMgr::ChooseDisplayId(creatureInfo);
-                sObjectMgr->GetCreatureModelRandomGender(&displayId);
+                CreatureModel model = *ObjectMgr::ChooseDisplayId(creatureInfo);
+                sObjectMgr->GetCreatureModelRandomGender(&model, creatureInfo);
+                displayId = model.CreatureDisplayID;
             }
 
             //some spell has one aura of mount and one of vehicle
@@ -3202,14 +3203,8 @@ void AuraEffect::HandleAuraModResistance(AuraApplication const* aurApp, uint8 mo
     Unit* target = aurApp->GetTarget();
 
     for (int8 x = SPELL_SCHOOL_NORMAL; x < MAX_SPELL_SCHOOL; x++)
-    {
         if (GetMiscValue() & int32(1<<x))
-        {
             target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + x), TOTAL_VALUE, float(GetAmount()), apply);
-            if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
-                target->ApplyResistanceBuffModsMod(SpellSchools(x), GetAmount() > 0, (float)GetAmount(), apply);
-        }
-    }
 }
 
 void AuraEffect::HandleAuraModBaseResistancePCT(AuraApplication const* aurApp, uint8 mode, bool apply) const
@@ -3251,20 +3246,9 @@ void AuraEffect::HandleModResistancePercent(AuraApplication const* aurApp, uint8
         if (GetMiscValue() & int32(1<<i))
         {
             if (spellGroupVal)
-            {
                 target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + i), TOTAL_PCT, (float)spellGroupVal, !apply);
-                if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
-                {
-                    target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), true, (float)spellGroupVal, !apply);
-                    target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), false, (float)spellGroupVal, !apply);
-                }
-            }
+
             target->HandleStatModifier(UnitMods(UNIT_MOD_RESISTANCE_START + i), TOTAL_PCT, float(GetAmount()), apply);
-            if (target->GetTypeId() == TYPEID_PLAYER || target->IsPet())
-            {
-                target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), true, (float)GetAmount(), apply);
-                target->ApplyResistanceBuffModsPercentMod(SpellSchools(i), false, (float)GetAmount(), apply);
-            }
         }
     }
 }
@@ -3302,11 +3286,11 @@ void AuraEffect::HandleModTargetResistance(AuraApplication const* aurApp, uint8
 
     // show armor penetration
     if (target->GetTypeId() == TYPEID_PLAYER && (GetMiscValue() & SPELL_SCHOOL_MASK_NORMAL))
-        target->ApplyModInt32Value(PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE, GetAmount(), apply);
+        target->ApplyModInt32Value(ACTIVE_PLAYER_FIELD_MOD_TARGET_PHYSICAL_RESISTANCE, GetAmount(), apply);
 
     // show as spell penetration only full spell penetration bonuses (all resistances except armor and holy
     if (target->GetTypeId() == TYPEID_PLAYER && (GetMiscValue() & SPELL_SCHOOL_MASK_SPELL) == SPELL_SCHOOL_MASK_SPELL)
-        target->ApplyModInt32Value(PLAYER_FIELD_MOD_TARGET_RESISTANCE, GetAmount(), apply);
+        target->ApplyModInt32Value(ACTIVE_PLAYER_FIELD_MOD_TARGET_RESISTANCE, GetAmount(), apply);
 }
 
 /********************************/
@@ -3582,7 +3566,7 @@ void AuraEffect::HandleOverrideSpellPowerByAttackPower(AuraApplication const* au
     if (!target)
         return;
 
-    target->ApplyModSignedFloatValue(PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT, float(m_amount), apply);
+    target->ApplyModSignedFloatValue(ACTIVE_PLAYER_FIELD_OVERRIDE_SPELL_POWER_BY_AP_PCT, float(m_amount), apply);
     target->UpdateSpellDamageAndHealingBonus();
 }
 
@@ -3595,7 +3579,7 @@ void AuraEffect::HandleOverrideAttackPowerBySpellPower(AuraApplication const* au
     if (!target)
         return;
 
-    target->ApplyModSignedFloatValue(PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT, float(m_amount), apply);
+    target->ApplyModSignedFloatValue(ACTIVE_PLAYER_FIELD_OVERRIDE_AP_BY_SPELL_POWER_PERCENT, float(m_amount), apply);
     target->UpdateAttackPowerAndDamage();
     target->UpdateAttackPowerAndDamage(true);
 }
@@ -3607,7 +3591,7 @@ void AuraEffect::HandleModVersatilityByPct(AuraApplication const* aurApp, uint8
 
     if (Player* target = aurApp->GetTarget()->ToPlayer())
     {
-        target->SetStatFloatValue(PLAYER_VERSATILITY_BONUS, target->GetTotalAuraModifier(SPELL_AURA_MOD_VERSATILITY));
+        target->SetStatFloatValue(ACTIVE_PLAYER_FIELD_VERSATILITY_BONUS, target->GetTotalAuraModifier(SPELL_AURA_MOD_VERSATILITY));
         target->UpdateHealingDonePercentMod();
         target->UpdateVersatilityDamageDone();
     }
@@ -4210,7 +4194,7 @@ void AuraEffect::HandleModDamageDone(AuraApplication const* aurApp, uint8 mode,
     // This information for client side use only
     if (target->GetTypeId() == TYPEID_PLAYER)
     {
-        uint16 baseField = GetAmount() >= 0 ? PLAYER_FIELD_MOD_DAMAGE_DONE_POS : PLAYER_FIELD_MOD_DAMAGE_DONE_NEG;
+        uint16 baseField = GetAmount() >= 0 ? ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS : ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG;
         for (uint16 i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
             if (GetMiscValue() & (1 << i))
                 target->ApplyModInt32Value(baseField + i, GetAmount(), apply);
@@ -4251,9 +4235,9 @@ void AuraEffect::HandleModDamagePercentDone(AuraApplication const* aurApp, uint8
             if (GetMiscValue() & (1 << i))
             {
                 if (spellGroupVal)
-                    target->ApplyPercentModFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i, float(spellGroupVal), !apply);
+                    target->ApplyPercentModFloatValue(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i, float(spellGroupVal), !apply);
 
-                target->ApplyPercentModFloatValue(PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i, float(GetAmount()), apply);
+                target->ApplyPercentModFloatValue(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_PCT + i, float(GetAmount()), apply);
             }
         }
     }
@@ -4341,10 +4325,10 @@ void AuraEffect::HandleNoReagentUseAura(AuraApplication const* aurApp, uint8 mod
         if (SpellEffectInfo const* effect = (*i)->GetSpellEffectInfo())
             mask |= effect->SpellClassMask;
 
-    target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1  , mask[0]);
-    target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1+1, mask[1]);
-    target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1+2, mask[2]);
-    target->SetUInt32Value(PLAYER_NO_REAGENT_COST_1+3, mask[3]);
+    target->SetUInt32Value(ACTIVE_PLAYER_FIELD_NO_REAGENT_COST  , mask[0]);
+    target->SetUInt32Value(ACTIVE_PLAYER_FIELD_NO_REAGENT_COST+1, mask[1]);
+    target->SetUInt32Value(ACTIVE_PLAYER_FIELD_NO_REAGENT_COST+2, mask[2]);
+    target->SetUInt32Value(ACTIVE_PLAYER_FIELD_NO_REAGENT_COST+3, mask[3]);
 }
 
 void AuraEffect::HandleAuraRetainComboPoints(AuraApplication const* aurApp, uint8 mode, bool apply) const
@@ -4953,7 +4937,7 @@ void AuraEffect::HandleAuraOverrideSpells(AuraApplication const* aurApp, uint8 m
 
     if (apply)
     {
-        target->SetUInt16Value(PLAYER_FIELD_BYTES3, PLAYER_BYTES_3_OVERRIDE_SPELLS_UINT16_OFFSET, overrideId);
+        target->SetUInt16Value(ACTIVE_PLAYER_FIELD_BYTES3, PLAYER_BYTES_3_OVERRIDE_SPELLS_UINT16_OFFSET, overrideId);
         if (OverrideSpellDataEntry const* overrideSpells = sOverrideSpellDataStore.LookupEntry(overrideId))
             for (uint8 i = 0; i < MAX_OVERRIDE_SPELL; ++i)
                 if (uint32 spellId = overrideSpells->Spells[i])
@@ -4961,7 +4945,7 @@ void AuraEffect::HandleAuraOverrideSpells(AuraApplication const* aurApp, uint8 m
     }
     else
     {
-        target->SetUInt16Value(PLAYER_FIELD_BYTES3, PLAYER_BYTES_3_OVERRIDE_SPELLS_UINT16_OFFSET, 0);
+        target->SetUInt16Value(ACTIVE_PLAYER_FIELD_BYTES3, PLAYER_BYTES_3_OVERRIDE_SPELLS_UINT16_OFFSET, 0);
         if (OverrideSpellDataEntry const* overrideSpells = sOverrideSpellDataStore.LookupEntry(overrideId))
             for (uint8 i = 0; i < MAX_OVERRIDE_SPELL; ++i)
                 if (uint32 spellId = overrideSpells->Spells[i])
@@ -5005,9 +4989,9 @@ void AuraEffect::HandlePreventResurrection(AuraApplication const* aurApp, uint8
         return;
 
     if (apply)
-        aurApp->GetTarget()->RemoveFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER);
+        aurApp->GetTarget()->RemoveFlag(ACTIVE_PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER);
     else if (!aurApp->GetTarget()->GetMap()->Instanceable())
-        aurApp->GetTarget()->SetFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER);
+        aurApp->GetTarget()->SetFlag(ACTIVE_PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_RELEASE_TIMER);
 }
 
 void AuraEffect::HandleMastery(AuraApplication const* aurApp, uint8 mode, bool /*apply*/) const
@@ -5584,7 +5568,7 @@ void AuraEffect::HandlePeriodicDamageAurasTick(Unit* target, Unit* caster) const
     if (overkill < 0)
         overkill = 0;
 
-    SpellPeriodicAuraLogInfo pInfo(this, damage, overkill, absorb, resist, 0.0f, crit);
+    SpellPeriodicAuraLogInfo pInfo(this, damage, dmg, overkill, absorb, resist, 0.0f, crit);
 
     caster->DealDamage(target, damage, &cleanDamage, DOT, GetSpellInfo()->GetSchoolMask(), GetSpellInfo(), true);
 
@@ -5674,6 +5658,7 @@ void AuraEffect::HandlePeriodicHealthLeechAuraTick(Unit* target, Unit* caster) c
     // SendSpellNonMeleeDamageLog expects non-absorbed/non-resisted damage
     SpellNonMeleeDamage log(caster, target, GetId(), GetBase()->GetSpellXSpellVisualId(), GetSpellInfo()->GetSchoolMask(), GetBase()->GetCastGUID());
     log.damage = damage;
+    log.originalDamage = dmg;
     log.absorb = absorb;
     log.resist = resist;
     log.periodicLog = true;
@@ -5822,7 +5807,7 @@ void AuraEffect::HandlePeriodicHealAurasTick(Unit* target, Unit* caster) const
     caster->CalcHealAbsorb(healInfo);
     caster->DealHeal(healInfo);
 
-    SpellPeriodicAuraLogInfo pInfo(this, heal, heal - healInfo.GetEffectiveHeal(), healInfo.GetAbsorb(), 0, 0.0f, crit);
+    SpellPeriodicAuraLogInfo pInfo(this, heal, damage, heal - healInfo.GetEffectiveHeal(), healInfo.GetAbsorb(), 0, 0.0f, crit);
     target->SendPeriodicAuraLog(&pInfo);
 
     target->getHostileRefManager().threatAssist(caster, float(healInfo.GetEffectiveHeal()) * 0.5f, GetSpellInfo());
@@ -5866,7 +5851,7 @@ void AuraEffect::HandlePeriodicManaLeechAuraTick(Unit* target, Unit* caster) con
 
     float gainMultiplier = GetSpellEffectInfo()->CalcValueMultiplier(caster);
 
-    SpellPeriodicAuraLogInfo pInfo(this, drainedAmount, 0, 0, 0, gainMultiplier, false);
+    SpellPeriodicAuraLogInfo pInfo(this, drainedAmount, drainAmount, 0, 0, 0, gainMultiplier, false);
 
     int32 gainAmount = int32(drainedAmount * gainMultiplier);
     int32 gainedAmount = 0;
@@ -5920,7 +5905,7 @@ void AuraEffect::HandleObsModPowerAuraTick(Unit* target, Unit* caster) const
     TC_LOG_DEBUG("spells.periodic", "PeriodicTick: %s energize %s for %u dmg inflicted by %u",
         GetCasterGUID().ToString().c_str(), target->GetGUID().ToString().c_str(), amount, GetId());
 
-    SpellPeriodicAuraLogInfo pInfo(this, amount, 0, 0, 0, 0.0f, false);
+    SpellPeriodicAuraLogInfo pInfo(this, amount, amount, 0, 0, 0, 0.0f, false);
     int32 gain = target->ModifyPower(powerType, amount);
 
     if (caster)
@@ -5948,7 +5933,7 @@ void AuraEffect::HandlePeriodicEnergizeAuraTick(Unit* target, Unit* caster) cons
     // ignore negative values (can be result apply spellmods to aura damage
     int32 amount = std::max(m_amount, 0);
 
-    SpellPeriodicAuraLogInfo pInfo(this, amount, 0, 0, 0, 0.0f, false);
+    SpellPeriodicAuraLogInfo pInfo(this, amount, amount, 0, 0, 0, 0.0f, false);
 
     TC_LOG_DEBUG("spells.periodic", "PeriodicTick: %s energize %s for %u dmg inflicted by %u",
         GetCasterGUID().ToString().c_str(), target->GetGUID().ToString().c_str(), amount, GetId());
@@ -6156,9 +6141,9 @@ void AuraEffect::HandleAllowUsingGameobjectsWhileMounted(AuraApplication const*
         return;
 
     if (apply)
-        aurApp->GetTarget()->SetFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_CAN_USE_OBJECTS_MOUNTED);
+        aurApp->GetTarget()->SetFlag(ACTIVE_PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_CAN_USE_OBJECTS_MOUNTED);
     else if (!aurApp->GetTarget()->HasAuraType(SPELL_AURA_ALLOW_USING_GAMEOBJECTS_WHILE_MOUNTED))
-        aurApp->GetTarget()->RemoveFlag(PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_CAN_USE_OBJECTS_MOUNTED);
+        aurApp->GetTarget()->RemoveFlag(ACTIVE_PLAYER_FIELD_LOCAL_FLAGS, PLAYER_LOCAL_FLAG_CAN_USE_OBJECTS_MOUNTED);
 }
 
 void AuraEffect::HandlePlayScene(AuraApplication const* aurApp, uint8 mode, bool apply) const
diff --git a/src/server/game/Spells/Spell.cpp b/src/server/game/Spells/Spell.cpp
index 8cc2a1b7f6d..d9b428c0598 100644
--- a/src/server/game/Spells/Spell.cpp
+++ b/src/server/game/Spells/Spell.cpp
@@ -491,7 +491,7 @@ void SpellCastTargets::OutDebug() const
     TC_LOG_DEBUG("spells", "pitch: %f", m_pitch);
 }
 
-SpellValue::SpellValue(Difficulty diff, SpellInfo const* proto)
+SpellValue::SpellValue(Difficulty diff, SpellInfo const* proto, Unit const* caster)
 {
     // todo 6.x
     SpellEffectInfoVector effects = proto->GetEffectsForDifficulty(diff);
@@ -499,8 +499,9 @@ SpellValue::SpellValue(Difficulty diff, SpellInfo const* proto)
     memset(EffectBasePoints, 0, sizeof(EffectBasePoints));
     for (SpellEffectInfo const* effect : effects)
         if (effect)
-            EffectBasePoints[effect->EffectIndex] = effect->BasePoints;
+            EffectBasePoints[effect->EffectIndex] = effect->CalcBaseValue(caster, nullptr, -1);
 
+    CustomBasePointsMask = 0;
     MaxAffectedTargets = proto->MaxAffectedTargets;
     RadiusMod = 1.0f;
     AuraStackAmount = 1;
@@ -521,7 +522,7 @@ protected:
 
 Spell::Spell(Unit* caster, SpellInfo const* info, TriggerCastFlags triggerFlags, ObjectGuid originalCasterGUID, bool skipCheck) :
 m_spellInfo(info), m_caster((info->HasAttribute(SPELL_ATTR6_CAST_BY_CHARMER) && caster->GetCharmerOrOwner()) ? caster->GetCharmerOrOwner() : caster),
-m_spellValue(new SpellValue(caster->GetMap()->GetDifficultyID(), m_spellInfo))
+m_spellValue(new SpellValue(caster->GetMap()->GetDifficultyID(), m_spellInfo, caster))
 {
     _effects = info->GetEffectsForDifficulty(caster->GetMap()->GetDifficultyID());
 
@@ -537,7 +538,6 @@ m_spellValue(new SpellValue(caster->GetMap()->GetDifficultyID(), m_spellInfo))
     m_delayAtDamageCount = 0;
 
     m_applyMultiplierMask = 0;
-    m_auraScaleMask = 0;
     memset(m_damageMultipliers, 0, sizeof(m_damageMultipliers));
 
     // Get data for type of attack
@@ -791,31 +791,6 @@ void Spell::SelectSpellTargets()
                 }
             }
         }
-        else if (m_auraScaleMask)
-        {
-            bool checkLvl = !m_UniqueTargetInfo.empty();
-            for (std::vector<TargetInfo>::iterator ihit = m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end();)
-            {
-                // remove targets which did not pass min level check
-                if (m_auraScaleMask && ihit->effectMask == m_auraScaleMask)
-                {
-                    // Do not check for selfcast
-                    if (!ihit->scaleAura && ihit->targetGUID != m_caster->GetGUID())
-                    {
-                        ihit = m_UniqueTargetInfo.erase(ihit);
-                        continue;
-                    }
-                }
-
-                ++ihit;
-            }
-
-            if (checkLvl && m_UniqueTargetInfo.empty())
-            {
-                SendCastResult(SPELL_FAILED_LOWLEVEL);
-                finish(false);
-            }
-        }
     }
 
     if (m_targets.HasDst())
@@ -1489,6 +1464,9 @@ void Spell::SelectImplicitCasterObjectTargets(SpellEffIndex effIndex, SpellImpli
             if (m_caster->GetTypeId() == TYPEID_UNIT && m_caster->IsVehicle())
                 target = m_caster->GetVehicleKit()->GetPassenger(targetType.GetTarget() - TARGET_UNIT_PASSENGER_0);
             break;
+        case TARGET_UNIT_OWN_CRITTER:
+            target = ObjectAccessor::GetCreatureOrPetOrVehicle(*m_caster, m_caster->GetCritterGUID());
+            break;
         default:
             break;
     }
@@ -2128,13 +2106,6 @@ void Spell::AddUnitTarget(Unit* target, uint32 effectMask, bool checkIfValid /*=
         if (targetGUID == ihit->targetGUID)             // Found in list
         {
             ihit->effectMask |= effectMask;             // Immune effects removed from mask
-            ihit->scaleAura = false;
-            if (m_auraScaleMask && ihit->effectMask == m_auraScaleMask && m_caster != target)
-            {
-                SpellInfo const* auraSpell = m_spellInfo->GetFirstRankSpell();
-                if (uint32(target->GetLevelForTarget(m_caster) + 10) >= auraSpell->SpellLevel)
-                    ihit->scaleAura = true;
-            }
             return;
         }
     }
@@ -2149,13 +2120,6 @@ void Spell::AddUnitTarget(Unit* target, uint32 effectMask, bool checkIfValid /*=
     targetInfo.alive      = target->IsAlive();
     targetInfo.damage     = 0;
     targetInfo.crit       = false;
-    targetInfo.scaleAura  = false;
-    if (m_auraScaleMask && targetInfo.effectMask == m_auraScaleMask && m_caster != target)
-    {
-        SpellInfo const* auraSpell = m_spellInfo->GetFirstRankSpell();
-        if (uint32(target->GetLevelForTarget(m_caster) + 10) >= auraSpell->SpellLevel)
-            targetInfo.scaleAura = true;
-    }
 
     // Calculate hit result
     if (m_originalCaster)
@@ -2398,7 +2362,7 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)
         if (unit->IsPvP() && m_caster->GetTypeId() == TYPEID_PLAYER)
             enablePvP = true; // Decide on PvP flagging now, but act on it later.
 
-        SpellMissInfo missInfo2 = DoSpellHitOnUnit(spellHitTarget, mask, target->scaleAura);
+        SpellMissInfo missInfo2 = DoSpellHitOnUnit(spellHitTarget, mask);
 
         if (missInfo2 != SPELL_MISS_NONE)
         {
@@ -2591,7 +2555,7 @@ void Spell::DoAllEffectOnTarget(TargetInfo* target)
     }
 }
 
-SpellMissInfo Spell::DoSpellHitOnUnit(Unit* unit, uint32 effectMask, bool scaleAura)
+SpellMissInfo Spell::DoSpellHitOnUnit(Unit* unit, uint32 effectMask)
 {
     if (!unit || !effectMask)
         return SPELL_MISS_EVADE;
@@ -2676,34 +2640,19 @@ SpellMissInfo Spell::DoSpellHitOnUnit(Unit* unit, uint32 effectMask, bool scaleA
 
     if (aura_effmask)
     {
-        // Select rank for aura with level requirements only in specific cases
-        // Unit has to be target only of aura effect, both caster and target have to be players, target has to be other than unit target
-        SpellInfo const* aurSpellInfo = m_spellInfo;
-        int32 basePoints[MAX_SPELL_EFFECTS];
-        if (scaleAura)
-        {
-            aurSpellInfo = m_spellInfo->GetAuraRankForLevel(unitTarget->getLevel());
-            ASSERT(aurSpellInfo);
-            for (SpellEffectInfo const* effect : aurSpellInfo->GetEffectsForDifficulty(0))
-            {
-                basePoints[effect->EffectIndex] = effect->BasePoints;
-                if (SpellEffectInfo const* myEffect = GetEffect(effect->EffectIndex))
-                {
-                    if (myEffect->Effect != effect->Effect)
-                    {
-                        aurSpellInfo = m_spellInfo;
-                        break;
-                    }
-                }
-            }
-        }
-
         if (m_originalCaster)
         {
+            int32 basePoints[MAX_SPELL_EFFECTS];
+            for (SpellEffectInfo const* auraSpellEffect : GetEffects())
+                if (auraSpellEffect)
+                    basePoints[auraSpellEffect->EffectIndex] = (m_spellValue->CustomBasePointsMask & (1 << auraSpellEffect->EffectIndex)) ?
+                        m_spellValue->EffectBasePoints[auraSpellEffect->EffectIndex] :
+                        auraSpellEffect->CalcBaseValue(m_originalCaster, unit, m_castItemLevel);
+
             bool refresh = false;
             bool const resetPeriodicTimer = !(_triggeredCastFlags & TRIGGERED_DONT_RESET_PERIODIC_TIMER);
-            m_spellAura = Aura::TryRefreshStackOrCreate(aurSpellInfo, m_castId, effectMask, unit,
-                m_originalCaster, (aurSpellInfo == m_spellInfo) ? m_spellValue->EffectBasePoints : basePoints,
+            m_spellAura = Aura::TryRefreshStackOrCreate(m_spellInfo, m_castId, effectMask, unit,
+                m_originalCaster, basePoints,
                 m_CastItem, ObjectGuid::Empty, &refresh, resetPeriodicTimer, ObjectGuid::Empty, m_castItemLevel);
             if (m_spellAura)
             {
@@ -2718,7 +2667,7 @@ SpellMissInfo Spell::DoSpellHitOnUnit(Unit* unit, uint32 effectMask, bool scaleA
 
                 // Now Reduce spell duration using data received at spell hit
                 int32 duration = m_spellAura->GetMaxDuration();
-                float diminishMod = unit->ApplyDiminishingToDuration(aurSpellInfo, duration, m_originalCaster, diminishLevel);
+                float diminishMod = unit->ApplyDiminishingToDuration(m_spellInfo, duration, m_originalCaster, diminishLevel);
 
                 // unit is immune to aura if it was diminished to 0 duration
                 if (diminishMod == 0.0f)
@@ -2739,13 +2688,13 @@ SpellMissInfo Spell::DoSpellHitOnUnit(Unit* unit, uint32 effectMask, bool scaleA
                     if (AuraApplication* aurApp = m_spellAura->GetApplicationOfTarget(m_originalCaster->GetGUID()))
                         positive = aurApp->IsPositive();
 
-                    duration = m_originalCaster->ModSpellDuration(aurSpellInfo, unit, duration, positive, effectMask);
+                    duration = m_originalCaster->ModSpellDuration(m_spellInfo, unit, duration, positive, effectMask);
 
                     if (duration > 0)
                     {
                         // Haste modifies duration of channeled spells
                         if (m_spellInfo->IsChanneled())
-                            m_originalCaster->ModSpellDurationTime(aurSpellInfo, duration, this);
+                            m_originalCaster->ModSpellDurationTime(m_spellInfo, duration, this);
                         else if (m_spellInfo->HasAttribute(SPELL_ATTR5_HASTE_AFFECT_DURATION))
                         {
                             int32 origDuration = duration;
@@ -2953,27 +2902,6 @@ void Spell::prepare(SpellCastTargets const* targets, AuraEffect const* triggered
 
     InitExplicitTargets(*targets);
 
-    // Fill aura scaling information
-    if (m_caster->IsControlledByPlayer() && !m_spellInfo->IsPassive() && m_spellInfo->SpellLevel && !m_spellInfo->IsChanneled() && !(_triggeredCastFlags & TRIGGERED_IGNORE_AURA_SCALING))
-    {
-        for (SpellEffectInfo const* effect : GetEffects())
-        {
-            if (effect && effect->Effect == SPELL_EFFECT_APPLY_AURA)
-            {
-                // Change aura with ranks only if basepoints are taken from spellInfo and aura is positive
-                if (m_spellInfo->IsPositiveEffect(effect->EffectIndex))
-                {
-                    m_auraScaleMask |= (1 << effect->EffectIndex);
-                    if (m_spellValue->EffectBasePoints[effect->EffectIndex] != effect->BasePoints)
-                    {
-                        m_auraScaleMask = 0;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
     m_spellState = SPELL_STATE_PREPARING;
 
     if (triggeredByAura)
@@ -6045,7 +5973,8 @@ SpellCastResult Spell::CheckArenaAndRatedBattlegroundCastRules()
 
 int32 Spell::CalculateDamage(uint8 i, Unit const* target, float* var /*= nullptr*/) const
 {
-    return m_caster->CalculateSpellDamage(target, m_spellInfo, i, &m_spellValue->EffectBasePoints[i], var, m_castItemLevel);
+    bool needRecalculateBasePoints = !(m_spellValue->CustomBasePointsMask & (1 << i));
+    return m_caster->CalculateSpellDamage(target, m_spellInfo, i, needRecalculateBasePoints ? nullptr : &m_spellValue->EffectBasePoints[i], var, m_castItemLevel);
 }
 
 bool Spell::CanAutoCast(Unit* target)
@@ -7295,7 +7224,7 @@ SpellCastResult Spell::CanOpenLock(uint32 effIndex, uint32 lockId, SkillType& sk
 
                 skillId = SkillByLockType(LockType(lockInfo->Index[j]));
 
-                if (skillId != SKILL_NONE || lockInfo->Index[j] == LOCKTYPE_PICKLOCK)
+                if (skillId != SKILL_NONE || lockInfo->Index[j] == LOCKTYPE_LOCKPICKING)
                 {
                     reqSkillValue = lockInfo->Skill[j];
 
@@ -7303,7 +7232,7 @@ SpellCastResult Spell::CanOpenLock(uint32 effIndex, uint32 lockId, SkillType& sk
                     skillValue = 0;
                     if (!m_CastItem && m_caster->GetTypeId() == TYPEID_PLAYER)
                         skillValue = m_caster->ToPlayer()->GetSkillValue(skillId);
-                    else if (lockInfo->Index[j] == LOCKTYPE_PICKLOCK)
+                    else if (lockInfo->Index[j] == LOCKTYPE_LOCKPICKING)
                         skillValue = m_caster->getLevel() * 5;
 
                     // skill bonus provided by casting spell (mostly item spells)
@@ -7330,8 +7259,8 @@ void Spell::SetSpellValue(SpellValueMod mod, int32 value)
 {
     if (mod < SPELLVALUE_BASE_POINT_END)
     {
-        if (SpellEffectInfo const* effect = GetEffect(mod))
-            m_spellValue->EffectBasePoints[mod] = effect->CalcBaseValue(value);
+        m_spellValue->EffectBasePoints[mod] = value;
+        m_spellValue->CustomBasePointsMask |= 1 << mod;
         return;
     }
 
diff --git a/src/server/game/Spells/Spell.h b/src/server/game/Spells/Spell.h
index 45b012a82e6..c0a9dff527b 100644
--- a/src/server/game/Spells/Spell.h
+++ b/src/server/game/Spells/Spell.h
@@ -296,8 +296,9 @@ class TC_GAME_API SpellCastTargets
 
 struct SpellValue
 {
-    explicit  SpellValue(Difficulty diff, SpellInfo const* proto);
+    explicit  SpellValue(Difficulty diff, SpellInfo const* proto, Unit const* caster);
     int32     EffectBasePoints[MAX_SPELL_EFFECTS];
+    uint32    CustomBasePointsMask;
     uint32    MaxAffectedTargets;
     float     RadiusMod;
     uint8     AuraStackAmount;
@@ -788,7 +789,6 @@ class TC_GAME_API Spell
             bool   processed;
             bool   alive;
             bool   crit;
-            bool   scaleAura;
         };
         std::vector<TargetInfo> m_UniqueTargetInfo;
         uint32 m_channelTargetEffectMask;                        // Mask req. alive targets
@@ -817,7 +817,7 @@ class TC_GAME_API Spell
         void AddDestTarget(SpellDestination const& dest, uint32 effIndex);
 
         void DoAllEffectOnTarget(TargetInfo* target);
-        SpellMissInfo DoSpellHitOnUnit(Unit* unit, uint32 effectMask, bool scaleAura);
+        SpellMissInfo DoSpellHitOnUnit(Unit* unit, uint32 effectMask);
         void DoTriggersOnSpellHit(Unit* unit, uint32 effMask);
         void DoAllEffectOnTarget(GOTargetInfo* target);
         void DoAllEffectOnTarget(ItemTargetInfo* target);
@@ -884,7 +884,6 @@ class TC_GAME_API Spell
         SpellInfo const* m_triggeredByAuraSpell;
 
         bool m_skipCheck;
-        uint32 m_auraScaleMask;
         std::unique_ptr<PathGenerator> m_preGeneratedPath;
 
         std::vector<SpellLogEffectPowerDrainParams> _powerDrainTargets[MAX_SPELL_EFFECTS];
diff --git a/src/server/game/Spells/SpellEffects.cpp b/src/server/game/Spells/SpellEffects.cpp
index b6f009b971e..34743342da6 100644
--- a/src/server/game/Spells/SpellEffects.cpp
+++ b/src/server/game/Spells/SpellEffects.cpp
@@ -410,7 +410,8 @@ void Spell::EffectEnvironmentalDMG(SpellEffIndex /*effIndex*/)
         m_caster->CalcAbsorbResist(damageInfo);
 
         SpellNonMeleeDamage log(m_caster, unitTarget, m_spellInfo->Id, m_SpellVisual, m_spellInfo->GetSchoolMask(), m_castId);
-        log.damage = damage;
+        log.damage = damageInfo.GetDamage();
+        log.originalDamage = damage;
         log.absorb = damageInfo.GetAbsorb();
         log.resist = damageInfo.GetResist();
 
@@ -2365,7 +2366,7 @@ void Spell::EffectLearnSkill(SpellEffIndex /*effIndex*/)
     if (unitTarget->GetTypeId() != TYPEID_PLAYER)
         return;
 
-    if (damage < 0)
+    if (damage < 1)
         return;
 
     uint32 skillid = effectInfo->MiscValue;
@@ -2378,7 +2379,7 @@ void Spell::EffectLearnSkill(SpellEffIndex /*effIndex*/)
         return;
 
     uint16 skillval = unitTarget->ToPlayer()->GetPureSkillValue(skillid);
-    unitTarget->ToPlayer()->SetSkill(skillid, effectInfo->CalcValue(), std::max<uint16>(skillval, 1), tier->Value[damage - 1]);
+    unitTarget->ToPlayer()->SetSkill(skillid, damage, std::max<uint16>(skillval, 1), tier->Value[damage - 1]);
 }
 
 void Spell::EffectPlayMovie(SpellEffIndex /*effIndex*/)
@@ -4182,12 +4183,41 @@ void Spell::EffectSkinning(SpellEffIndex /*effIndex*/)
     creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
     creature->SetFlag(OBJECT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
 
-    int32 reqValue = targetLevel < 10 ? 0 : targetLevel < 20 ? (targetLevel-10)*10 : targetLevel*5;
+    if (skill == SKILL_SKINNING)
+    {
+        int32 reqValue;
+        if (targetLevel <= 10)
+            reqValue = 1;
+        else if (targetLevel < 20)
+            reqValue = (targetLevel - 10) * 10;
+        else if (targetLevel <= 73)
+            reqValue = targetLevel * 5;
+        else if (targetLevel < 80)
+            reqValue = targetLevel * 10 - 365;
+        else if (targetLevel <= 84)
+            reqValue = targetLevel * 5 + 35;
+        else if (targetLevel <= 87)
+            reqValue = targetLevel * 15 - 805;
+        else if (targetLevel <= 92)
+            reqValue = (targetLevel - 62) * 20;
+        else if (targetLevel <= 104)
+            reqValue = targetLevel * 5 + 175;
+        else if (targetLevel <= 107)
+            reqValue = targetLevel * 15 - 905;
+        else if (targetLevel <= 112)
+            reqValue = (targetLevel - 72) * 20;
+        else if (targetLevel <= 122)
+            reqValue = (targetLevel - 32) * 10;
+        else
+            reqValue = 900;
 
-    int32 skillValue = m_caster->ToPlayer()->GetPureSkillValue(skill);
+        // TODO: Specialize skillid for each expansion
+        // new db field?
+        // tied to one of existing expansion fields in creature_template?
 
-    // Double chances for elites
-    m_caster->ToPlayer()->UpdateGatherSkill(skill, skillValue, reqValue, creature->isElite() ? 2 : 1);
+        // Double chances for elites
+        m_caster->ToPlayer()->UpdateGatherSkill(skill, damage, reqValue, creature->isElite() ? 2 : 1);
+    }
 }
 
 void Spell::EffectCharge(SpellEffIndex /*effIndex*/)
diff --git a/src/server/game/Spells/SpellInfo.cpp b/src/server/game/Spells/SpellInfo.cpp
index d1dfa32f7cb..d1ae93cd318 100644
--- a/src/server/game/Spells/SpellInfo.cpp
+++ b/src/server/game/Spells/SpellInfo.cpp
@@ -368,6 +368,7 @@ SpellImplicitTargetInfo::StaticData  SpellImplicitTargetInfo::_data[TOTAL_SPELL_
     {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE,   TARGET_SELECT_CATEGORY_NYI,     TARGET_CHECK_DEFAULT,  TARGET_DIR_NONE},        // 147
     {TARGET_OBJECT_TYPE_NONE, TARGET_REFERENCE_TYPE_NONE,   TARGET_SELECT_CATEGORY_NYI,     TARGET_CHECK_DEFAULT,  TARGET_DIR_NONE},        // 148
     {TARGET_OBJECT_TYPE_DEST, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT,  TARGET_DIR_RANDOM},      // 149
+    {TARGET_OBJECT_TYPE_UNIT, TARGET_REFERENCE_TYPE_CASTER, TARGET_SELECT_CATEGORY_DEFAULT, TARGET_CHECK_DEFAULT,  TARGET_DIR_NONE},        // 150
 };
 
 SpellEffectInfo::SpellEffectInfo(SpellInfo const* spellInfo, uint8 effIndex, SpellEffectEntry const* _effect)
@@ -377,7 +378,6 @@ SpellEffectInfo::SpellEffectInfo(SpellInfo const* spellInfo, uint8 effIndex, Spe
     Effect = _effect ? _effect->Effect : 0;
     ApplyAuraName = _effect ? _effect->EffectAura : 0;
     ApplyAuraPeriod = _effect ? _effect->EffectAuraPeriod : 0;
-    DieSides = _effect ? _effect->EffectDieSides : 0;
     RealPointsPerLevel = _effect ? _effect->EffectRealPointsPerLevel : 0.0f;
     BasePoints = _effect ? _effect->EffectBasePoints : 0;
     PointsPerResource = _effect ? _effect->EffectPointsPerResource : 0.0f;
@@ -461,12 +461,59 @@ bool SpellEffectInfo::IsUnitOwnedAuraEffect() const
 int32 SpellEffectInfo::CalcValue(Unit const* caster /*= nullptr*/, int32 const* bp /*= nullptr*/, Unit const* target /*= nullptr*/, float* variance /*= nullptr*/, int32 itemLevel /*= -1*/) const
 {
     float basePointsPerLevel = RealPointsPerLevel;
-    int32 basePoints = bp ? *bp : BasePoints;
+    // TODO: this needs to be a float, not rounded
+    int32 basePoints = CalcBaseValue(caster, target, itemLevel);
+    float value = bp ? *bp : basePoints;
     float comboDamage = PointsPerResource;
 
+    if (Scaling.Variance)
+    {
+        float delta = fabs(Scaling.Variance * 0.5f);
+        float valueVariance = frand(-delta, delta);
+        value += basePoints * valueVariance;
+
+        if (variance)
+            *variance = valueVariance;
+    }
+
     // base amount modification based on spell lvl vs caster lvl
     if (Scaling.Coefficient != 0.0f)
     {
+        if (Scaling.ResourceCoefficient)
+            comboDamage = Scaling.ResourceCoefficient * value;
+    }
+    else
+    {
+        if (GetScalingExpectedStat() == ExpectedStatType::None)
+        {
+            int32 level = caster ? int32(caster->getLevel()) : 0;
+            if (level > int32(_spellInfo->MaxLevel) && _spellInfo->MaxLevel > 0)
+                level = int32(_spellInfo->MaxLevel);
+            level -= int32(_spellInfo->BaseLevel);
+            if (level < 0)
+                level = 0;
+            value += level * basePointsPerLevel;
+        }
+    }
+
+    // random damage
+    if (caster)
+    {
+        // bonus amount from combo points
+        if (caster->m_playerMovingMe && comboDamage)
+            if (uint32 comboPoints = caster->m_playerMovingMe->GetComboPoints())
+                value += comboDamage * comboPoints;
+
+        value = caster->ApplyEffectModifiers(_spellInfo, EffectIndex, value);
+    }
+
+    return int32(round(value));
+}
+
+int32 SpellEffectInfo::CalcBaseValue(Unit const* caster, Unit const* target, int32 itemLevel) const
+{
+    if (Scaling.Coefficient != 0.0f)
+    {
         uint32 level = _spellInfo->SpellLevel;
         if (target && _spellInfo->IsPositiveEffect(EffectIndex) && (Effect == SPELL_EFFECT_APPLY_AURA))
             level = target->getLevel();
@@ -488,148 +535,56 @@ int32 SpellEffectInfo::CalcValue(Unit const* caster /*= nullptr*/, int32 const*
             if (!_spellInfo->Scaling.Class)
                 return 0;
 
-            if (!_spellInfo->Scaling.ScalesFromItemLevel)
+            uint32 effectiveItemLevel = itemLevel != -1 ? uint32(itemLevel) : 1u;
+            if (_spellInfo->Scaling.ScalesFromItemLevel || _spellInfo->HasAttribute(SPELL_ATTR11_SCALES_WITH_ITEM_LEVEL))
             {
-                if (!_spellInfo->HasAttribute(SPELL_ATTR11_SCALES_WITH_ITEM_LEVEL))
-                    value = GetSpellScalingColumnForClass(sSpellScalingGameTable.GetRow(level), _spellInfo->Scaling.Class);
-                else
+                if (_spellInfo->Scaling.ScalesFromItemLevel)
+                    effectiveItemLevel = _spellInfo->Scaling.ScalesFromItemLevel;
+
+                if (_spellInfo->Scaling.Class == -8)
                 {
-                    uint32 effectiveItemLevel = itemLevel != -1 ? uint32(itemLevel) : 1u;
-                    value = GetRandomPropertyPoints(effectiveItemLevel, ITEM_QUALITY_RARE, INVTYPE_CHEST, 0);
-                    if (IsAura() && ApplyAuraName == SPELL_AURA_MOD_RATING)
-                        if (GtCombatRatingsMultByILvl const* ratingMult = sCombatRatingsMultByILvlGameTable.GetRow(effectiveItemLevel))
-                            value *= ratingMult->ArmorMultiplier;
+                    RandPropPointsEntry const* randPropPoints = sRandPropPointsStore.LookupEntry(effectiveItemLevel);
+                    if (!randPropPoints)
+                        randPropPoints = sRandPropPointsStore.AssertEntry(sRandPropPointsStore.GetNumRows() - 1);
+
+                    value = randPropPoints->DamageReplaceStat;
                 }
+                else
+                    value = GetRandomPropertyPoints(effectiveItemLevel, ITEM_QUALITY_RARE, INVTYPE_CHEST, 0);
             }
             else
-                value = GetRandomPropertyPoints(_spellInfo->Scaling.ScalesFromItemLevel, ITEM_QUALITY_RARE, INVTYPE_CHEST, 0);
+                value = GetSpellScalingColumnForClass(sSpellScalingGameTable.GetRow(level), _spellInfo->Scaling.Class);
+
+            if (_spellInfo->Scaling.Class == -7)
+            {
+                // todo: get inventorytype here
+                if (GtCombatRatingsMultByILvl const* ratingMult = sCombatRatingsMultByILvlGameTable.GetRow(effectiveItemLevel))
+                    value *= ratingMult->ArmorMultiplier;
+            }
         }
 
         value *= Scaling.Coefficient;
         if (value != 0.0f && value < 1.0f)
             value = 1.0f;
 
-        if (Scaling.Variance)
-        {
-            float delta = fabs(Scaling.Variance * 0.5f);
-            float valueVariance = frand(-delta, delta);
-            value += value * valueVariance;
-
-            if (variance)
-                *variance = valueVariance;
-        }
-
-        basePoints = int32(round(value));
-
-        if (Scaling.ResourceCoefficient)
-            comboDamage = Scaling.ResourceCoefficient * value;
+        return int32(round(value));
     }
     else
     {
-        if (caster)
-        {
-            int32 level = int32(caster->getLevel());
-            if (level > int32(_spellInfo->MaxLevel) && _spellInfo->MaxLevel > 0)
-                level = int32(_spellInfo->MaxLevel);
-            else if (level < int32(_spellInfo->BaseLevel))
-                level = int32(_spellInfo->BaseLevel);
-            level -= int32(_spellInfo->SpellLevel);
-            basePoints += int32(level * basePointsPerLevel);
-        }
-
-        // roll in a range <1;EffectDieSides> as of patch 3.3.3
-        int32 randomPoints = int32(DieSides);
-        switch (randomPoints)
+        float value = BasePoints;
+        ExpectedStatType stat = GetScalingExpectedStat();
+        if (stat != ExpectedStatType::None)
         {
-            case 0: break;
-            case 1: basePoints += 1; break;                     // range 1..1
-            default:
-            {
-                // range can have positive (1..rand) and negative (rand..1) values, so order its for irand
-                int32 randvalue = (randomPoints >= 1)
-                    ? irand(1, randomPoints)
-                    : irand(randomPoints, 1);
+            if (_spellInfo->HasAttribute(SPELL_ATTR0_LEVEL_DAMAGE_CALCULATION))
+                stat = ExpectedStatType::CreatureAutoAttackDps;
 
-                basePoints += randvalue;
-                break;
-            }
+            // TODO - add expansion and content tuning id args?
+            int32 level = caster ? int32(caster->getLevel()) : 1;
+            value = sDB2Manager.EvaluateExpectedStat(stat, level, -2, 0, CLASS_NONE) * BasePoints / 100.0f;
         }
-    }
 
-    float value = float(basePoints);
-
-    // random damage
-    if (caster)
-    {
-        // bonus amount from combo points
-        if (caster->m_playerMovingMe && comboDamage)
-            if (uint32 comboPoints = caster->m_playerMovingMe->GetComboPoints())
-                value += comboDamage * comboPoints;
-
-        value = caster->ApplyEffectModifiers(_spellInfo, EffectIndex, value);
-
-        // amount multiplication based on caster's level
-        if (!caster->IsControlledByPlayer() &&
-            _spellInfo->SpellLevel && _spellInfo->SpellLevel != caster->getLevel() &&
-            !basePointsPerLevel && (_spellInfo->HasAttribute(SPELL_ATTR0_LEVEL_DAMAGE_CALCULATION)))
-        {
-            bool canEffectScale = false;
-            switch (Effect)
-            {
-                case SPELL_EFFECT_SCHOOL_DAMAGE:
-                case SPELL_EFFECT_DUMMY:
-                case SPELL_EFFECT_POWER_DRAIN:
-                case SPELL_EFFECT_HEALTH_LEECH:
-                case SPELL_EFFECT_HEAL:
-                case SPELL_EFFECT_WEAPON_DAMAGE:
-                case SPELL_EFFECT_POWER_BURN:
-                case SPELL_EFFECT_SCRIPT_EFFECT:
-                case SPELL_EFFECT_NORMALIZED_WEAPON_DMG:
-                case SPELL_EFFECT_FORCE_CAST_WITH_VALUE:
-                case SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE:
-                case SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE:
-                    canEffectScale = true;
-                    break;
-                default:
-                    break;
-            }
-
-            switch (ApplyAuraName)
-            {
-                case SPELL_AURA_PERIODIC_DAMAGE:
-                case SPELL_AURA_DUMMY:
-                case SPELL_AURA_PERIODIC_HEAL:
-                case SPELL_AURA_DAMAGE_SHIELD:
-                case SPELL_AURA_PROC_TRIGGER_DAMAGE:
-                case SPELL_AURA_PERIODIC_LEECH:
-                case SPELL_AURA_PERIODIC_MANA_LEECH:
-                case SPELL_AURA_SCHOOL_ABSORB:
-                case SPELL_AURA_PERIODIC_TRIGGER_SPELL_WITH_VALUE:
-                    canEffectScale = true;
-                    break;
-                default:
-                    break;
-            }
-
-            if (canEffectScale)
-            {
-                GtNpcManaCostScalerEntry const* spellScaler = sNpcManaCostScalerGameTable.GetRow(_spellInfo->SpellLevel);
-                GtNpcManaCostScalerEntry const* casterScaler = sNpcManaCostScalerGameTable.GetRow(caster->getLevel());
-                if (spellScaler && casterScaler)
-                    value *= casterScaler->Scaler / spellScaler->Scaler;
-            }
-        }
+        return int32(round(value));
     }
-
-    return int32(value);
-}
-
-int32 SpellEffectInfo::CalcBaseValue(int32 value) const
-{
-    if (DieSides == 0)
-        return value;
-    else
-        return value - 1;
 }
 
 float SpellEffectInfo::CalcValueMultiplier(Unit* caster, Spell* spell) const
@@ -723,6 +678,94 @@ SpellTargetObjectTypes SpellEffectInfo::GetUsedTargetObjectType() const
     return _data[Effect].UsedTargetObjectType;
 }
 
+ExpectedStatType SpellEffectInfo::GetScalingExpectedStat() const
+{
+    switch (Effect)
+    {
+        case SPELL_EFFECT_SCHOOL_DAMAGE:
+        case SPELL_EFFECT_ENVIRONMENTAL_DAMAGE:
+        case SPELL_EFFECT_HEALTH_LEECH:
+        case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
+        case SPELL_EFFECT_WEAPON_DAMAGE:
+            return ExpectedStatType::CreatureSpellDamage;
+        case SPELL_EFFECT_HEAL:
+        case SPELL_EFFECT_HEAL_MECHANICAL:
+            return ExpectedStatType::PlayerHealth;
+        case SPELL_EFFECT_ENERGIZE:
+        case SPELL_EFFECT_POWER_BURN:
+            if (!MiscValue)
+                return ExpectedStatType::PlayerMana;
+            return ExpectedStatType::None;
+        case SPELL_EFFECT_POWER_DRAIN:
+            return ExpectedStatType::PlayerMana;
+        case SPELL_EFFECT_APPLY_AURA:
+        case SPELL_EFFECT_PERSISTENT_AREA_AURA:
+        case SPELL_EFFECT_APPLY_AREA_AURA_PARTY:
+        case SPELL_EFFECT_APPLY_AREA_AURA_RAID:
+        case SPELL_EFFECT_APPLY_AREA_AURA_PET:
+        case SPELL_EFFECT_APPLY_AREA_AURA_FRIEND:
+        case SPELL_EFFECT_APPLY_AREA_AURA_ENEMY:
+        case SPELL_EFFECT_APPLY_AREA_AURA_OWNER:
+        case SPELL_EFFECT_APPLY_AURA_ON_PET:
+        case SPELL_EFFECT_202:
+            switch (ApplyAuraName)
+            {
+                case SPELL_AURA_PERIODIC_DAMAGE:
+                case SPELL_AURA_MOD_DAMAGE_DONE:
+                case SPELL_AURA_DAMAGE_SHIELD:
+                case SPELL_AURA_PROC_TRIGGER_DAMAGE:
+                case SPELL_AURA_PERIODIC_LEECH:
+                case SPELL_AURA_MOD_DAMAGE_DONE_CREATURE:
+                case SPELL_AURA_PERIODIC_HEALTH_FUNNEL:
+                case SPELL_AURA_MOD_MELEE_ATTACK_POWER_VERSUS:
+                case SPELL_AURA_MOD_RANGED_ATTACK_POWER_VERSUS:
+                case SPELL_AURA_MOD_FLAT_SPELL_DAMAGE_VERSUS:
+                    return ExpectedStatType::CreatureSpellDamage;
+                case SPELL_AURA_PERIODIC_HEAL:
+                case SPELL_AURA_MOD_DAMAGE_TAKEN:
+                case SPELL_AURA_MOD_INCREASE_HEALTH:
+                case SPELL_AURA_SCHOOL_ABSORB:
+                case SPELL_AURA_MOD_REGEN:
+                case SPELL_AURA_MANA_SHIELD:
+                case SPELL_AURA_MOD_HEALING:
+                case SPELL_AURA_MOD_HEALING_DONE:
+                case SPELL_AURA_MOD_HEALTH_REGEN_IN_COMBAT:
+                case SPELL_AURA_MOD_MAX_HEALTH:
+                case SPELL_AURA_MOD_INCREASE_HEALTH_2:
+                case SPELL_AURA_SCHOOL_HEAL_ABSORB:
+                    return ExpectedStatType::PlayerHealth;
+                case SPELL_AURA_PERIODIC_MANA_LEECH:
+                    return ExpectedStatType::PlayerMana;
+                case SPELL_AURA_MOD_STAT:
+                case SPELL_AURA_MOD_ATTACK_POWER:
+                case SPELL_AURA_MOD_RANGED_ATTACK_POWER:
+                    return ExpectedStatType::PlayerPrimaryStat;
+                case SPELL_AURA_MOD_RATING:
+                    return ExpectedStatType::PlayerSecondaryStat;
+                case SPELL_AURA_MOD_RESISTANCE:
+                case SPELL_AURA_MOD_BASE_RESISTANCE:
+                case SPELL_AURA_MOD_TARGET_RESISTANCE:
+                case SPELL_AURA_MOD_BONUS_ARMOR:
+                    return ExpectedStatType::ArmorConstant;
+                case SPELL_AURA_PERIODIC_ENERGIZE:
+                case SPELL_AURA_MOD_INCREASE_ENERGY:
+                case SPELL_AURA_MOD_POWER_COST_SCHOOL:
+                case SPELL_AURA_MOD_POWER_REGEN:
+                case SPELL_AURA_POWER_BURN:
+                case SPELL_AURA_MOD_MAX_POWER:
+                    if (!MiscValue)
+                        return ExpectedStatType::PlayerMana;
+                    return ExpectedStatType::None;
+                default:
+                    break;
+            }
+        default:
+            break;
+    }
+
+    return ExpectedStatType::None;
+}
+
 SpellEffectInfo::StaticData SpellEffectInfo::_data[TOTAL_SPELL_EFFECTS] =
 {
     // implicit target type           used target object type
@@ -982,6 +1025,12 @@ SpellEffectInfo::StaticData SpellEffectInfo::_data[TOTAL_SPELL_EFFECTS] =
     {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 253 SPELL_EFFECT_GIVE_HONOR
     {EFFECT_IMPLICIT_TARGET_NONE,     TARGET_OBJECT_TYPE_NONE}, // 254 SPELL_EFFECT_254
     {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_UNIT}, // 255 SPELL_EFFECT_LEARN_TRANSMOG_SET
+    {EFFECT_IMPLICIT_TARGET_NONE,     TARGET_OBJECT_TYPE_NONE}, // 256 SPELL_EFFECT_256
+    {EFFECT_IMPLICIT_TARGET_NONE,     TARGET_OBJECT_TYPE_NONE}, // 257 SPELL_EFFECT_257
+    {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 258 SPELL_EFFECT_MODIFY_KEYSTONE
+    {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 259 SPELL_EFFECT_RESPEC_AZERITE_EMPOWERED_ITEM
+    {EFFECT_IMPLICIT_TARGET_NONE,     TARGET_OBJECT_TYPE_NONE}, // 260 SPELL_EFFECT_SUMMON_STABLED_PET
+    {EFFECT_IMPLICIT_TARGET_EXPLICIT, TARGET_OBJECT_TYPE_ITEM}, // 261 SPELL_EFFECT_SCRAP_ITEM
 };
 
 SpellInfo::SpellInfo(SpellInfoLoadHelper const& data, SpellEffectEntryMap const& effectsMap, SpellVisualMap&& visuals)
@@ -1042,7 +1091,7 @@ SpellInfo::SpellInfo(SpellInfoLoadHelper const& data, SpellEffectEntryMap const&
     // SpellAuraOptionsEntry
     SpellAuraOptionsEntry const* _options = data.AuraOptions;
     SpellProcsPerMinuteEntry const* _ppm = _options ? sSpellProcsPerMinuteStore.LookupEntry(_options->SpellProcsPerMinuteID) : nullptr;
-    ProcFlags = _options ? _options->ProcTypeMask : 0;
+    ProcFlags = _options ? _options->ProcTypeMask[0] : 0;
     ProcChance = _options ? _options->ProcChance : 0;
     ProcCharges = _options ? _options->ProcCharges : 0;
     ProcCooldown = _options ? _options->ProcCategoryRecovery : 0;
@@ -1832,10 +1881,31 @@ SpellCastResult SpellInfo::CheckLocation(uint32 map_id, uint32 zone_id, uint32 a
     // continent limitation (virtual continent)
     if (HasAttribute(SPELL_ATTR4_CAST_ONLY_IN_OUTLAND))
     {
-        uint32 v_map = sDB2Manager.GetVirtualMapForMapAndZone(map_id, zone_id);
-        MapEntry const* mapEntry = sMapStore.LookupEntry(v_map);
-        if (!mapEntry || mapEntry->ExpansionID < 1 || !mapEntry->IsContinent())
+        uint32 mountFlags = 0;
+        if (player && player->HasAuraType(SPELL_AURA_MOUNT_RESTRICTIONS))
+        {
+            for (AuraEffect const* auraEffect : player->GetAuraEffectsByType(SPELL_AURA_MOUNT_RESTRICTIONS))
+                mountFlags |= auraEffect->GetMiscValue();
+        }
+        else if (AreaTableEntry const* areaTable = sAreaTableStore.LookupEntry(area_id))
+            mountFlags = areaTable->MountFlags;
+
+        if (!(mountFlags & AREA_MOUNT_FLAG_FLYING_ALLOWED))
             return SPELL_FAILED_INCORRECT_AREA;
+
+        if (player)
+        {
+            uint32 mapToCheck = map_id;
+            if (MapEntry const* mapEntry = sMapStore.LookupEntry(map_id))
+                mapToCheck = mapEntry->CosmeticParentMapID;
+
+            if ((mapToCheck == 1116 || mapToCheck == 1464) && !player->HasSpell(191645)) // Draenor Pathfinder
+                return SPELL_FAILED_INCORRECT_AREA;
+            else if (mapToCheck == 1220 && !player->HasSpell(233368)) // Broken Isles Pathfinder
+                return SPELL_FAILED_INCORRECT_AREA;
+            else if ((mapToCheck == 1642 || mapToCheck == 1643) && !player->HasSpell(278833)) // Battle for Azeroth Pathfinder
+                return SPELL_FAILED_INCORRECT_AREA;
+        }
     }
 
     // raid instance limitation
@@ -3851,9 +3921,9 @@ inline float CalcPPMCritMod(SpellProcsPerMinuteModEntry const* mod, Unit* caster
     if (caster->GetTypeId() != TYPEID_PLAYER)
         return 0.0f;
 
-    float crit = caster->GetFloatValue(PLAYER_CRIT_PERCENTAGE);
-    float rangedCrit = caster->GetFloatValue(PLAYER_RANGED_CRIT_PERCENTAGE);
-    float spellCrit = caster->GetFloatValue(PLAYER_SPELL_CRIT_PERCENTAGE1);
+    float crit = caster->GetFloatValue(ACTIVE_PLAYER_FIELD_CRIT_PERCENTAGE);
+    float rangedCrit = caster->GetFloatValue(ACTIVE_PLAYER_FIELD_RANGED_CRIT_PERCENTAGE);
+    float spellCrit = caster->GetFloatValue(ACTIVE_PLAYER_FIELD_SPELL_CRIT_PERCENTAGE1);
 
     switch (mod->Param)
     {
diff --git a/src/server/game/Spells/SpellInfo.h b/src/server/game/Spells/SpellInfo.h
index 2eb285b48ae..65aef5dca41 100644
--- a/src/server/game/Spells/SpellInfo.h
+++ b/src/server/game/Spells/SpellInfo.h
@@ -323,7 +323,6 @@ public:
     uint32    Effect;
     uint32    ApplyAuraName;
     uint32    ApplyAuraPeriod;
-    int32     DieSides;
     float     RealPointsPerLevel;
     int32     BasePoints;
     float     PointsPerResource;
@@ -352,7 +351,7 @@ public:
         float ResourceCoefficient;
     } Scaling;
 
-    SpellEffectInfo() : _spellInfo(NULL), EffectIndex(0), Effect(0), ApplyAuraName(0), ApplyAuraPeriod(0), DieSides(0),
+    SpellEffectInfo() : _spellInfo(NULL), EffectIndex(0), Effect(0), ApplyAuraName(0), ApplyAuraPeriod(0),
                         RealPointsPerLevel(0), BasePoints(0), PointsPerResource(0), Amplitude(0), ChainAmplitude(0),
                         BonusCoefficient(0), MiscValue(0), MiscValueB(0), Mechanic(MECHANIC_NONE), PositionFacing(0),
                         RadiusEntry(NULL), ChainTargets(0), ItemType(0), TriggerSpell(0), BonusCoefficientFromAP(0.0f), ImplicitTargetConditions(NULL) { }
@@ -369,7 +368,7 @@ public:
     bool IsUnitOwnedAuraEffect() const;
 
     int32 CalcValue(Unit const* caster = nullptr, int32 const* basePoints = nullptr, Unit const* target = nullptr, float* variance = nullptr, int32 itemLevel = -1) const;
-    int32 CalcBaseValue(int32 value) const;
+    int32 CalcBaseValue(Unit const* caster, Unit const* target, int32 itemLevel) const;
     float CalcValueMultiplier(Unit* caster, Spell* spell = NULL) const;
     float CalcDamageMultiplier(Unit* caster, Spell* spell = NULL) const;
 
@@ -382,6 +381,7 @@ public:
 
     SpellEffectImplicitTargetTypes GetImplicitTargetType() const;
     SpellTargetObjectTypes GetUsedTargetObjectType() const;
+    ExpectedStatType GetScalingExpectedStat() const;
 
     ImmunityInfo const* GetImmunityInfo() const { return &_immunityInfo; }
 
diff --git a/src/server/game/Spells/SpellMgr.cpp b/src/server/game/Spells/SpellMgr.cpp
index 2532069e6c2..2bb498cf9af 100644
--- a/src/server/game/Spells/SpellMgr.cpp
+++ b/src/server/game/Spells/SpellMgr.cpp
@@ -2068,7 +2068,7 @@ void SpellMgr::LoadSpellAreas()
         spellArea.questEndStatus      = fields[4].GetUInt32();
         spellArea.questEnd            = fields[5].GetUInt32();
         spellArea.auraSpell           = fields[6].GetInt32();
-        spellArea.raceMask            = fields[7].GetUInt32();
+        spellArea.raceMask            = fields[7].GetUInt64();
         spellArea.gender              = Gender(fields[8].GetUInt8());
         spellArea.flags               = fields[9].GetUInt8();
 
@@ -2189,7 +2189,7 @@ void SpellMgr::LoadSpellAreas()
 
         if (spellArea.raceMask && (spellArea.raceMask & RACEMASK_ALL_PLAYABLE) == 0)
         {
-            TC_LOG_ERROR("sql.sql", "The spell %u listed in `spell_area` has wrong race mask (%u) requirement.", spell, spellArea.raceMask);
+            TC_LOG_ERROR("sql.sql", "The spell %u listed in `spell_area` has wrong race mask (" UI64FMTD ") requirement.", spell, spellArea.raceMask);
             continue;
         }
 
@@ -2236,7 +2236,7 @@ void SpellMgr::LoadSpellInfoStore()
     uint32 oldMSTime = getMSTime();
 
     UnloadSpellInfoStore();
-    mSpellInfoMap.resize(sSpellStore.GetNumRows(), NULL);
+    mSpellInfoMap.resize(sSpellNameStore.GetNumRows(), NULL);
     std::unordered_map<uint32, SpellInfoLoadHelper> loadData;
 
     std::unordered_map<int32, SpellEffectEntryMap> effectsBySpell;
@@ -2313,11 +2313,11 @@ void SpellMgr::LoadSpellInfoStore()
     for (SpellXSpellVisualEntry const* visual : sSpellXSpellVisualStore)
         visualsBySpell[visual->SpellID][visual->DifficultyID].push_back(visual);
 
-    for (uint32 i = 0; i < sSpellStore.GetNumRows(); ++i)
+    for (uint32 i = 0; i < sSpellNameStore.GetNumRows(); ++i)
     {
-        if (SpellEntry const* spellEntry = sSpellStore.LookupEntry(i))
+        if (SpellNameEntry const* spellNameEntry = sSpellNameStore.LookupEntry(i))
         {
-            loadData[i].Entry = spellEntry;
+            loadData[i].Entry = spellNameEntry;
             mSpellInfoMap[i] = new SpellInfo(loadData[i], effectsBySpell[i], std::move(visualsBySpell[i]));
         }
     }
diff --git a/src/server/game/Spells/SpellMgr.h b/src/server/game/Spells/SpellMgr.h
index 1034f6b4333..690edb8f508 100644
--- a/src/server/game/Spells/SpellMgr.h
+++ b/src/server/game/Spells/SpellMgr.h
@@ -37,7 +37,6 @@ class Player;
 class Unit;
 class ProcEventInfo;
 struct SkillLineAbilityEntry;
-struct SpellEntry;
 struct SpellAuraOptionsEntry;
 struct SpellAuraRestrictionsEntry;
 struct SpellCastingRequirementsEntry;
@@ -48,6 +47,7 @@ struct SpellEquippedItemsEntry;
 struct SpellInterruptsEntry;
 struct SpellLevelsEntry;
 struct SpellMiscEntry;
+struct SpellNameEntry;
 struct SpellReagentsEntry;
 struct SpellScalingEntry;
 struct SpellShapeshiftEntry;
@@ -464,7 +464,7 @@ struct TC_GAME_API SpellArea
     uint32 questStart;                                      // quest start (quest must be active or rewarded for spell apply)
     uint32 questEnd;                                        // quest end (quest must not be rewarded for spell apply)
     int32  auraSpell;                                       // spell aura must be applied for spell apply)if possitive) and it must not be applied in other case
-    uint32 raceMask;                                        // can be applied only to races
+    uint64 raceMask;                                        // can be applied only to races
     Gender gender;                                          // can be applied only to gender
     uint32 questStartStatus;                                // QuestStatus that quest_start must have in order to keep the spell
     uint32 questEndStatus;                                  // QuestStatus that the quest_end must have in order to keep the spell (if the quest_end's status is different than this, the spell will be dropped)
@@ -561,7 +561,7 @@ bool IsWeaponSkill(uint32 skill);
 
 inline bool IsProfessionSkill(uint32 skill)
 {
-    return  IsPrimaryProfessionSkill(skill) || skill == SKILL_FISHING || skill == SKILL_COOKING || skill == SKILL_FIRST_AID;
+    return  IsPrimaryProfessionSkill(skill) || skill == SKILL_FISHING || skill == SKILL_COOKING;
 }
 
 inline bool IsProfessionOrRidingSkill(uint32 skill)
@@ -575,7 +575,7 @@ TC_GAME_API extern PetFamilySpellsStore                         sPetFamilySpells
 
 struct SpellInfoLoadHelper
 {
-    SpellEntry const* Entry = nullptr;
+    SpellNameEntry const* Entry = nullptr;
 
     SpellAuraOptionsEntry const* AuraOptions = nullptr;
     SpellAuraRestrictionsEntry const* AuraRestrictions = nullptr;
diff --git a/src/server/game/World/World.cpp b/src/server/game/World/World.cpp
index 4484e3c1f87..cde18f19ffe 100644
--- a/src/server/game/World/World.cpp
+++ b/src/server/game/World/World.cpp
@@ -145,6 +145,7 @@ World::World()
 
     memset(rate_values, 0, sizeof(rate_values));
     memset(m_int_configs, 0, sizeof(m_int_configs));
+    memset(m_int64_configs, 0, sizeof(m_int64_configs));
     memset(m_bool_configs, 0, sizeof(m_bool_configs));
     memset(m_float_configs, 0, sizeof(m_float_configs));
 }
@@ -805,7 +806,7 @@ void World::LoadConfigSettings(bool reload)
     m_int_configs[CONFIG_CHARTER_COST_ARENA_5v5] = sConfigMgr->GetIntDefault("ArenaTeam.CharterCost.5v5", 2000000);
 
     m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED] = sConfigMgr->GetIntDefault("CharacterCreating.Disabled", 0);
-    m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK] = sConfigMgr->GetIntDefault("CharacterCreating.Disabled.RaceMask", 0);
+    m_int64_configs[CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK] = sConfigMgr->GetInt64Default("CharacterCreating.Disabled.RaceMask", 0);
     m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED_CLASSMASK] = sConfigMgr->GetIntDefault("CharacterCreating.Disabled.ClassMask", 0);
 
     m_int_configs[CONFIG_CHARACTERS_PER_REALM] = sConfigMgr->GetIntDefault("CharactersPerRealm", MAX_CHARACTERS_PER_REALM);
@@ -956,13 +957,6 @@ void World::LoadConfigSettings(bool reload)
     }
     m_int_configs[CONFIG_CURRENCY_MAX_JUSTICE_POINTS] *= 100;     //precision mod
 
-    m_int_configs[CONFIG_CURRENCY_START_ARTIFACT_KNOWLEDGE] = sConfigMgr->GetIntDefault("Currency.StartArtifactKnowledge", 55);
-    if (int32(m_int_configs[CONFIG_CURRENCY_START_ARTIFACT_KNOWLEDGE]) < 0)
-    {
-        TC_LOG_ERROR("server.loading", "Currency.StartArtifactKnowledge (%i) must be >= 0, set to default 0.", m_int_configs[CONFIG_CURRENCY_START_ARTIFACT_KNOWLEDGE]);
-        m_int_configs[CONFIG_CURRENCY_START_ARTIFACT_KNOWLEDGE] = 0;
-    }
-
     m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL] = sConfigMgr->GetIntDefault("RecruitAFriend.MaxLevel", 85);
     if (m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL] > m_int_configs[CONFIG_MAX_PLAYER_LEVEL])
     {
@@ -1573,6 +1567,8 @@ void World::SetInitialWorldSettings()
     TC_LOG_INFO("server.loading", "Initialize data stores...");
     ///- Load DB2s
     sDB2Manager.LoadStores(m_dataPath, m_defaultDbcLocale);
+    TC_LOG_INFO("misc", "Loading hotfix blobs...");
+    sDB2Manager.LoadHotfixBlob();
     TC_LOG_INFO("misc", "Loading hotfix info...");
     sDB2Manager.LoadHotfixData();
     ///- Close hotfix database - it is only used during DB2 loading
diff --git a/src/server/game/World/World.h b/src/server/game/World/World.h
index 0959309b641..1d0d01f4b1f 100644
--- a/src/server/game/World/World.h
+++ b/src/server/game/World/World.h
@@ -238,7 +238,6 @@ enum WorldIntConfigs
     CONFIG_MIN_CHARTER_NAME,
     CONFIG_MIN_PET_NAME,
     CONFIG_CHARACTER_CREATING_DISABLED,
-    CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK,
     CONFIG_CHARACTER_CREATING_DISABLED_CLASSMASK,
     CONFIG_CHARACTERS_PER_ACCOUNT,
     CONFIG_CHARACTERS_PER_REALM,
@@ -254,7 +253,6 @@ enum WorldIntConfigs
     CONFIG_CURRENCY_START_APEXIS_CRYSTALS,
     CONFIG_CURRENCY_MAX_APEXIS_CRYSTALS,
     CONFIG_CURRENCY_START_JUSTICE_POINTS,
-    CONFIG_CURRENCY_START_ARTIFACT_KNOWLEDGE,
     CONFIG_CURRENCY_MAX_JUSTICE_POINTS,
     CONFIG_CURRENCY_RESET_HOUR,
     CONFIG_CURRENCY_RESET_DAY,
@@ -407,6 +405,12 @@ enum WorldIntConfigs
     INT_CONFIG_VALUE_COUNT
 };
 
+enum WorldInt64Configs
+{
+    CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK,
+    INT64_CONFIT_VALUE_COUNT
+};
+
 /// Server rates
 enum Rates
 {
@@ -744,6 +748,11 @@ class TC_GAME_API World
             return index < INT_CONFIG_VALUE_COUNT ? m_int_configs[index] : 0;
         }
 
+        uint64 GetUInt64Config(WorldInt64Configs index) const
+        {
+            return index < INT64_CONFIT_VALUE_COUNT ? m_int64_configs[index] : 0;
+        }
+
         void setWorldState(uint32 index, uint32 value);
         uint32 getWorldState(uint32 index) const;
         void LoadWorldStates();
@@ -858,6 +867,7 @@ class TC_GAME_API World
 
         float rate_values[MAX_RATES];
         uint32 m_int_configs[INT_CONFIG_VALUE_COUNT];
+        uint64 m_int64_configs[INT64_CONFIT_VALUE_COUNT];
         bool m_bool_configs[BOOL_CONFIG_VALUE_COUNT];
         float m_float_configs[FLOAT_CONFIG_VALUE_COUNT];
         typedef std::map<uint32, uint32> WorldStatesMap;
diff --git a/src/server/proto/CMakeLists.txt b/src/server/proto/CMakeLists.txt
index 2222ce6c71a..0866940283d 100644
--- a/src/server/proto/CMakeLists.txt
+++ b/src/server/proto/CMakeLists.txt
@@ -30,7 +30,9 @@ CollectIncludeDirectories(
   ${CMAKE_CURRENT_SOURCE_DIR}
   PUBLIC_INCLUDES
   # Exclude
-  ${CMAKE_CURRENT_SOURCE_DIR}/PrecompiledHeaders)
+  ${CMAKE_CURRENT_SOURCE_DIR}/PrecompiledHeaders
+  ${CMAKE_CURRENT_SOURCE_DIR}/Client/api
+  ${CMAKE_CURRENT_SOURCE_DIR}/Client/global_extensions)
 
 target_include_directories(proto
   PUBLIC
diff --git a/src/server/proto/Client/account_service.pb.cc b/src/server/proto/Client/account_service.pb.cc
index 3ce26ed5c28..7a144fa2403 100644
--- a/src/server/proto/Client/account_service.pb.cc
+++ b/src/server/proto/Client/account_service.pb.cc
@@ -27,30 +27,12 @@ namespace v1 {
 
 namespace {
 
-const ::google::protobuf::Descriptor* GetAccountRequest_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* ResolveAccountRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
-  GetAccountRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* GetAccountResponse_descriptor_ = NULL;
+  ResolveAccountRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ResolveAccountResponse_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
-  GetAccountResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* CreateGameAccountRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  CreateGameAccountRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* CreateGameAccountResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  CreateGameAccountResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* CacheExpireRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  CacheExpireRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* CredentialUpdateRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  CredentialUpdateRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* CredentialUpdateResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  CredentialUpdateResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AccountFlagUpdateRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AccountFlagUpdateRequest_reflection_ = NULL;
+  ResolveAccountResponse_reflection_ = NULL;
 const ::google::protobuf::Descriptor* GameAccountFlagUpdateRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   GameAccountFlagUpdateRequest_reflection_ = NULL;
@@ -63,18 +45,18 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* IsIgrAddressRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   IsIgrAddressRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AccountServiceRegion_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AccountServiceRegion_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AccountServiceConfig_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AccountServiceConfig_reflection_ = NULL;
 const ::google::protobuf::Descriptor* GetAccountStateRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   GetAccountStateRequest_reflection_ = NULL;
 const ::google::protobuf::Descriptor* GetAccountStateResponse_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   GetAccountStateResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetSignedAccountStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetSignedAccountStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetSignedAccountStateResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetSignedAccountStateResponse_reflection_ = NULL;
 const ::google::protobuf::Descriptor* GetGameAccountStateRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   GetGameAccountStateRequest_reflection_ = NULL;
@@ -105,9 +87,6 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* GetCAISInfoResponse_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   GetCAISInfoResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ForwardCacheExpireRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ForwardCacheExpireRequest_reflection_ = NULL;
 const ::google::protobuf::Descriptor* GetAuthorizedDataRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   GetAuthorizedDataRequest_reflection_ = NULL;
@@ -117,15 +96,6 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* UpdateParentalControlsAndCAISRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   UpdateParentalControlsAndCAISRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* QueueDeductRecordRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  QueueDeductRecordRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* GetGameAccountRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  GetGameAccountRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* GetGameAccountResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  GetGameAccountResponse_reflection_ = NULL;
 const ::google::protobuf::Descriptor* AccountStateNotification_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   AccountStateNotification_reflection_ = NULL;
@@ -150,156 +120,38 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
       "account_service.proto");
   GOOGLE_CHECK(file != NULL);
-  GetAccountRequest_descriptor_ = file->message_type(0);
-  static const int GetAccountRequest_offsets_[11] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, ref_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, reload_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_all_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_blob_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_email_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_battle_tag_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_full_name_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_links_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_parental_controls_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_cais_id_),
-  };
-  GetAccountRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      GetAccountRequest_descriptor_,
-      GetAccountRequest::default_instance_,
-      GetAccountRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GetAccountRequest));
-  GetAccountResponse_descriptor_ = file->message_type(1);
-  static const int GetAccountResponse_offsets_[8] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, blob_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, email_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, battle_tag_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, full_name_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, links_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, parental_control_info_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, cais_id_),
-  };
-  GetAccountResponse_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      GetAccountResponse_descriptor_,
-      GetAccountResponse::default_instance_,
-      GetAccountResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GetAccountResponse));
-  CreateGameAccountRequest_descriptor_ = file->message_type(2);
-  static const int CreateGameAccountRequest_offsets_[6] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, region_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, program_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, realm_permissions_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, account_region_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, platform_),
-  };
-  CreateGameAccountRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      CreateGameAccountRequest_descriptor_,
-      CreateGameAccountRequest::default_instance_,
-      CreateGameAccountRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(CreateGameAccountRequest));
-  CreateGameAccountResponse_descriptor_ = file->message_type(3);
-  static const int CreateGameAccountResponse_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountResponse, game_account_),
-  };
-  CreateGameAccountResponse_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      CreateGameAccountResponse_descriptor_,
-      CreateGameAccountResponse::default_instance_,
-      CreateGameAccountResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountResponse, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(CreateGameAccountResponse));
-  CacheExpireRequest_descriptor_ = file->message_type(4);
-  static const int CacheExpireRequest_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, game_account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, email_),
-  };
-  CacheExpireRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      CacheExpireRequest_descriptor_,
-      CacheExpireRequest::default_instance_,
-      CacheExpireRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(CacheExpireRequest));
-  CredentialUpdateRequest_descriptor_ = file->message_type(5);
-  static const int CredentialUpdateRequest_offsets_[4] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, old_credentials_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, new_credentials_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, region_),
-  };
-  CredentialUpdateRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      CredentialUpdateRequest_descriptor_,
-      CredentialUpdateRequest::default_instance_,
-      CredentialUpdateRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(CredentialUpdateRequest));
-  CredentialUpdateResponse_descriptor_ = file->message_type(6);
-  static const int CredentialUpdateResponse_offsets_[1] = {
+  ResolveAccountRequest_descriptor_ = file->message_type(0);
+  static const int ResolveAccountRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResolveAccountRequest, ref_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResolveAccountRequest, fetch_id_),
   };
-  CredentialUpdateResponse_reflection_ =
+  ResolveAccountRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
-      CredentialUpdateResponse_descriptor_,
-      CredentialUpdateResponse::default_instance_,
-      CredentialUpdateResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateResponse, _unknown_fields_),
+      ResolveAccountRequest_descriptor_,
+      ResolveAccountRequest::default_instance_,
+      ResolveAccountRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResolveAccountRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResolveAccountRequest, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(CredentialUpdateResponse));
-  AccountFlagUpdateRequest_descriptor_ = file->message_type(7);
-  static const int AccountFlagUpdateRequest_offsets_[4] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, region_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, flag_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, active_),
+      sizeof(ResolveAccountRequest));
+  ResolveAccountResponse_descriptor_ = file->message_type(1);
+  static const int ResolveAccountResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResolveAccountResponse, id_),
   };
-  AccountFlagUpdateRequest_reflection_ =
+  ResolveAccountResponse_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
-      AccountFlagUpdateRequest_descriptor_,
-      AccountFlagUpdateRequest::default_instance_,
-      AccountFlagUpdateRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, _unknown_fields_),
+      ResolveAccountResponse_descriptor_,
+      ResolveAccountResponse::default_instance_,
+      ResolveAccountResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResolveAccountResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ResolveAccountResponse, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AccountFlagUpdateRequest));
-  GameAccountFlagUpdateRequest_descriptor_ = file->message_type(8);
+      sizeof(ResolveAccountResponse));
+  GameAccountFlagUpdateRequest_descriptor_ = file->message_type(2);
   static const int GameAccountFlagUpdateRequest_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, game_account_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, flag_),
@@ -316,7 +168,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameAccountFlagUpdateRequest));
-  SubscriptionUpdateRequest_descriptor_ = file->message_type(9);
+  SubscriptionUpdateRequest_descriptor_ = file->message_type(3);
   static const int SubscriptionUpdateRequest_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateRequest, ref_),
   };
@@ -331,7 +183,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(SubscriptionUpdateRequest));
-  SubscriptionUpdateResponse_descriptor_ = file->message_type(10);
+  SubscriptionUpdateResponse_descriptor_ = file->message_type(4);
   static const int SubscriptionUpdateResponse_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateResponse, ref_),
   };
@@ -346,7 +198,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(SubscriptionUpdateResponse));
-  IsIgrAddressRequest_descriptor_ = file->message_type(11);
+  IsIgrAddressRequest_descriptor_ = file->message_type(5);
   static const int IsIgrAddressRequest_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, client_address_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, region_),
@@ -362,38 +214,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(IsIgrAddressRequest));
-  AccountServiceRegion_descriptor_ = file->message_type(12);
-  static const int AccountServiceRegion_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, shard_),
-  };
-  AccountServiceRegion_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      AccountServiceRegion_descriptor_,
-      AccountServiceRegion::default_instance_,
-      AccountServiceRegion_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AccountServiceRegion));
-  AccountServiceConfig_descriptor_ = file->message_type(13);
-  static const int AccountServiceConfig_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceConfig, region_),
-  };
-  AccountServiceConfig_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      AccountServiceConfig_descriptor_,
-      AccountServiceConfig::default_instance_,
-      AccountServiceConfig_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceConfig, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceConfig, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AccountServiceConfig));
-  GetAccountStateRequest_descriptor_ = file->message_type(14);
+  GetAccountStateRequest_descriptor_ = file->message_type(6);
   static const int GetAccountStateRequest_offsets_[5] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, entity_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, program_),
@@ -412,7 +233,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetAccountStateRequest));
-  GetAccountStateResponse_descriptor_ = file->message_type(15);
+  GetAccountStateResponse_descriptor_ = file->message_type(7);
   static const int GetAccountStateResponse_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, state_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, tags_),
@@ -428,7 +249,37 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetAccountStateResponse));
-  GetGameAccountStateRequest_descriptor_ = file->message_type(16);
+  GetSignedAccountStateRequest_descriptor_ = file->message_type(8);
+  static const int GetSignedAccountStateRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSignedAccountStateRequest, account_),
+  };
+  GetSignedAccountStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetSignedAccountStateRequest_descriptor_,
+      GetSignedAccountStateRequest::default_instance_,
+      GetSignedAccountStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSignedAccountStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSignedAccountStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetSignedAccountStateRequest));
+  GetSignedAccountStateResponse_descriptor_ = file->message_type(9);
+  static const int GetSignedAccountStateResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSignedAccountStateResponse, token_),
+  };
+  GetSignedAccountStateResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetSignedAccountStateResponse_descriptor_,
+      GetSignedAccountStateResponse::default_instance_,
+      GetSignedAccountStateResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSignedAccountStateResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSignedAccountStateResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetSignedAccountStateResponse));
+  GetGameAccountStateRequest_descriptor_ = file->message_type(10);
   static const int GetGameAccountStateRequest_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, account_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, game_account_id_),
@@ -446,7 +297,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetGameAccountStateRequest));
-  GetGameAccountStateResponse_descriptor_ = file->message_type(17);
+  GetGameAccountStateResponse_descriptor_ = file->message_type(11);
   static const int GetGameAccountStateResponse_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, state_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, tags_),
@@ -462,7 +313,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetGameAccountStateResponse));
-  GetLicensesRequest_descriptor_ = file->message_type(18);
+  GetLicensesRequest_descriptor_ = file->message_type(12);
   static const int GetLicensesRequest_offsets_[6] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, target_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, fetch_account_licenses_),
@@ -482,7 +333,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetLicensesRequest));
-  GetLicensesResponse_descriptor_ = file->message_type(19);
+  GetLicensesResponse_descriptor_ = file->message_type(13);
   static const int GetLicensesResponse_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesResponse, licenses_),
   };
@@ -497,7 +348,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetLicensesResponse));
-  GetGameSessionInfoRequest_descriptor_ = file->message_type(20);
+  GetGameSessionInfoRequest_descriptor_ = file->message_type(14);
   static const int GetGameSessionInfoRequest_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoRequest, entity_id_),
   };
@@ -512,7 +363,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetGameSessionInfoRequest));
-  GetGameSessionInfoResponse_descriptor_ = file->message_type(21);
+  GetGameSessionInfoResponse_descriptor_ = file->message_type(15);
   static const int GetGameSessionInfoResponse_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoResponse, session_info_),
   };
@@ -527,7 +378,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetGameSessionInfoResponse));
-  GetGameTimeRemainingInfoRequest_descriptor_ = file->message_type(22);
+  GetGameTimeRemainingInfoRequest_descriptor_ = file->message_type(16);
   static const int GetGameTimeRemainingInfoRequest_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, game_account_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, account_id_),
@@ -543,7 +394,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetGameTimeRemainingInfoRequest));
-  GetGameTimeRemainingInfoResponse_descriptor_ = file->message_type(23);
+  GetGameTimeRemainingInfoResponse_descriptor_ = file->message_type(17);
   static const int GetGameTimeRemainingInfoResponse_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoResponse, game_time_remaining_info_),
   };
@@ -558,7 +409,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetGameTimeRemainingInfoResponse));
-  GetCAISInfoRequest_descriptor_ = file->message_type(24);
+  GetCAISInfoRequest_descriptor_ = file->message_type(18);
   static const int GetCAISInfoRequest_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoRequest, entity_id_),
   };
@@ -573,7 +424,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetCAISInfoRequest));
-  GetCAISInfoResponse_descriptor_ = file->message_type(25);
+  GetCAISInfoResponse_descriptor_ = file->message_type(19);
   static const int GetCAISInfoResponse_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoResponse, cais_info_),
   };
@@ -588,22 +439,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetCAISInfoResponse));
-  ForwardCacheExpireRequest_descriptor_ = file->message_type(26);
-  static const int ForwardCacheExpireRequest_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ForwardCacheExpireRequest, entity_id_),
-  };
-  ForwardCacheExpireRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ForwardCacheExpireRequest_descriptor_,
-      ForwardCacheExpireRequest::default_instance_,
-      ForwardCacheExpireRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ForwardCacheExpireRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ForwardCacheExpireRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ForwardCacheExpireRequest));
-  GetAuthorizedDataRequest_descriptor_ = file->message_type(27);
+  GetAuthorizedDataRequest_descriptor_ = file->message_type(20);
   static const int GetAuthorizedDataRequest_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, entity_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, tag_),
@@ -620,7 +456,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetAuthorizedDataRequest));
-  GetAuthorizedDataResponse_descriptor_ = file->message_type(28);
+  GetAuthorizedDataResponse_descriptor_ = file->message_type(21);
   static const int GetAuthorizedDataResponse_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataResponse, data_),
   };
@@ -635,7 +471,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetAuthorizedDataResponse));
-  UpdateParentalControlsAndCAISRequest_descriptor_ = file->message_type(29);
+  UpdateParentalControlsAndCAISRequest_descriptor_ = file->message_type(22);
   static const int UpdateParentalControlsAndCAISRequest_offsets_[6] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateParentalControlsAndCAISRequest, account_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateParentalControlsAndCAISRequest, parental_control_info_),
@@ -655,53 +491,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(UpdateParentalControlsAndCAISRequest));
-  QueueDeductRecordRequest_descriptor_ = file->message_type(30);
-  static const int QueueDeductRecordRequest_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueueDeductRecordRequest, deduct_record_),
-  };
-  QueueDeductRecordRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      QueueDeductRecordRequest_descriptor_,
-      QueueDeductRecordRequest::default_instance_,
-      QueueDeductRecordRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueueDeductRecordRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueueDeductRecordRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(QueueDeductRecordRequest));
-  GetGameAccountRequest_descriptor_ = file->message_type(31);
-  static const int GetGameAccountRequest_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountRequest, game_account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountRequest, reload_),
-  };
-  GetGameAccountRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      GetGameAccountRequest_descriptor_,
-      GetGameAccountRequest::default_instance_,
-      GetGameAccountRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GetGameAccountRequest));
-  GetGameAccountResponse_descriptor_ = file->message_type(32);
-  static const int GetGameAccountResponse_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountResponse, blob_),
-  };
-  GetGameAccountResponse_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      GetGameAccountResponse_descriptor_,
-      GetGameAccountResponse::default_instance_,
-      GetGameAccountResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountResponse, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GetGameAccountResponse));
-  AccountStateNotification_descriptor_ = file->message_type(33);
+  AccountStateNotification_descriptor_ = file->message_type(23);
   static const int AccountStateNotification_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, account_state_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, subscriber_id_),
@@ -719,7 +509,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AccountStateNotification));
-  GameAccountStateNotification_descriptor_ = file->message_type(34);
+  GameAccountStateNotification_descriptor_ = file->message_type(24);
   static const int GameAccountStateNotification_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, game_account_state_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, subscriber_id_),
@@ -737,7 +527,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameAccountStateNotification));
-  GameAccountNotification_descriptor_ = file->message_type(35);
+  GameAccountNotification_descriptor_ = file->message_type(25);
   static const int GameAccountNotification_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, game_accounts_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, subscriber_id_),
@@ -754,7 +544,7 @@ void protobuf_AssignDesc_account_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameAccountNotification));
-  GameAccountSessionNotification_descriptor_ = file->message_type(36);
+  GameAccountSessionNotification_descriptor_ = file->message_type(26);
   static const int GameAccountSessionNotification_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, game_account_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, session_info_),
@@ -785,21 +575,9 @@ inline void protobuf_AssignDescriptorsOnce() {
 void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GetAccountRequest_descriptor_, &GetAccountRequest::default_instance());
+    ResolveAccountRequest_descriptor_, &ResolveAccountRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GetAccountResponse_descriptor_, &GetAccountResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    CreateGameAccountRequest_descriptor_, &CreateGameAccountRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    CreateGameAccountResponse_descriptor_, &CreateGameAccountResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    CacheExpireRequest_descriptor_, &CacheExpireRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    CredentialUpdateRequest_descriptor_, &CredentialUpdateRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    CredentialUpdateResponse_descriptor_, &CredentialUpdateResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AccountFlagUpdateRequest_descriptor_, &AccountFlagUpdateRequest::default_instance());
+    ResolveAccountResponse_descriptor_, &ResolveAccountResponse::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GameAccountFlagUpdateRequest_descriptor_, &GameAccountFlagUpdateRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
@@ -809,14 +587,14 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     IsIgrAddressRequest_descriptor_, &IsIgrAddressRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AccountServiceRegion_descriptor_, &AccountServiceRegion::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AccountServiceConfig_descriptor_, &AccountServiceConfig::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GetAccountStateRequest_descriptor_, &GetAccountStateRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GetAccountStateResponse_descriptor_, &GetAccountStateResponse::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetSignedAccountStateRequest_descriptor_, &GetSignedAccountStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetSignedAccountStateResponse_descriptor_, &GetSignedAccountStateResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GetGameAccountStateRequest_descriptor_, &GetGameAccountStateRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GetGameAccountStateResponse_descriptor_, &GetGameAccountStateResponse::default_instance());
@@ -837,20 +615,12 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GetCAISInfoResponse_descriptor_, &GetCAISInfoResponse::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ForwardCacheExpireRequest_descriptor_, &ForwardCacheExpireRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GetAuthorizedDataRequest_descriptor_, &GetAuthorizedDataRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GetAuthorizedDataResponse_descriptor_, &GetAuthorizedDataResponse::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     UpdateParentalControlsAndCAISRequest_descriptor_, &UpdateParentalControlsAndCAISRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    QueueDeductRecordRequest_descriptor_, &QueueDeductRecordRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GetGameAccountRequest_descriptor_, &GetGameAccountRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GetGameAccountResponse_descriptor_, &GetGameAccountResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     AccountStateNotification_descriptor_, &AccountStateNotification::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GameAccountStateNotification_descriptor_, &GameAccountStateNotification::default_instance());
@@ -863,22 +633,10 @@ void protobuf_RegisterTypes(const ::std::string&) {
 }  // namespace
 
 void protobuf_ShutdownFile_account_5fservice_2eproto() {
-  delete GetAccountRequest::default_instance_;
-  delete GetAccountRequest_reflection_;
-  delete GetAccountResponse::default_instance_;
-  delete GetAccountResponse_reflection_;
-  delete CreateGameAccountRequest::default_instance_;
-  delete CreateGameAccountRequest_reflection_;
-  delete CreateGameAccountResponse::default_instance_;
-  delete CreateGameAccountResponse_reflection_;
-  delete CacheExpireRequest::default_instance_;
-  delete CacheExpireRequest_reflection_;
-  delete CredentialUpdateRequest::default_instance_;
-  delete CredentialUpdateRequest_reflection_;
-  delete CredentialUpdateResponse::default_instance_;
-  delete CredentialUpdateResponse_reflection_;
-  delete AccountFlagUpdateRequest::default_instance_;
-  delete AccountFlagUpdateRequest_reflection_;
+  delete ResolveAccountRequest::default_instance_;
+  delete ResolveAccountRequest_reflection_;
+  delete ResolveAccountResponse::default_instance_;
+  delete ResolveAccountResponse_reflection_;
   delete GameAccountFlagUpdateRequest::default_instance_;
   delete GameAccountFlagUpdateRequest_reflection_;
   delete SubscriptionUpdateRequest::default_instance_;
@@ -887,14 +645,14 @@ void protobuf_ShutdownFile_account_5fservice_2eproto() {
   delete SubscriptionUpdateResponse_reflection_;
   delete IsIgrAddressRequest::default_instance_;
   delete IsIgrAddressRequest_reflection_;
-  delete AccountServiceRegion::default_instance_;
-  delete AccountServiceRegion_reflection_;
-  delete AccountServiceConfig::default_instance_;
-  delete AccountServiceConfig_reflection_;
   delete GetAccountStateRequest::default_instance_;
   delete GetAccountStateRequest_reflection_;
   delete GetAccountStateResponse::default_instance_;
   delete GetAccountStateResponse_reflection_;
+  delete GetSignedAccountStateRequest::default_instance_;
+  delete GetSignedAccountStateRequest_reflection_;
+  delete GetSignedAccountStateResponse::default_instance_;
+  delete GetSignedAccountStateResponse_reflection_;
   delete GetGameAccountStateRequest::default_instance_;
   delete GetGameAccountStateRequest_reflection_;
   delete GetGameAccountStateResponse::default_instance_;
@@ -915,20 +673,12 @@ void protobuf_ShutdownFile_account_5fservice_2eproto() {
   delete GetCAISInfoRequest_reflection_;
   delete GetCAISInfoResponse::default_instance_;
   delete GetCAISInfoResponse_reflection_;
-  delete ForwardCacheExpireRequest::default_instance_;
-  delete ForwardCacheExpireRequest_reflection_;
   delete GetAuthorizedDataRequest::default_instance_;
   delete GetAuthorizedDataRequest_reflection_;
   delete GetAuthorizedDataResponse::default_instance_;
   delete GetAuthorizedDataResponse_reflection_;
   delete UpdateParentalControlsAndCAISRequest::default_instance_;
   delete UpdateParentalControlsAndCAISRequest_reflection_;
-  delete QueueDeductRecordRequest::default_instance_;
-  delete QueueDeductRecordRequest_reflection_;
-  delete GetGameAccountRequest::default_instance_;
-  delete GetGameAccountRequest_reflection_;
-  delete GetGameAccountResponse::default_instance_;
-  delete GetGameAccountResponse_reflection_;
   delete AccountStateNotification::default_instance_;
   delete AccountStateNotification_reflection_;
   delete GameAccountStateNotification::default_instance_;
@@ -951,236 +701,161 @@ void protobuf_AddDesc_account_5fservice_2eproto() {
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\025account_service.proto\022\027bgs.protocol.ac"
     "count.v1\032\023account_types.proto\032\022entity_ty"
-    "pes.proto\032\017rpc_types.proto\"\357\002\n\021GetAccoun"
-    "tRequest\0226\n\003ref\030\001 \001(\0132).bgs.protocol.acc"
-    "ount.v1.AccountReference\022\025\n\006reload\030\002 \001(\010"
-    ":\005false\022\030\n\tfetch_all\030\n \001(\010:\005false\022\031\n\nfet"
-    "ch_blob\030\013 \001(\010:\005false\022\027\n\010fetch_id\030\014 \001(\010:\005"
-    "false\022\032\n\013fetch_email\030\r \001(\010:\005false\022\037\n\020fet"
-    "ch_battle_tag\030\016 \001(\010:\005false\022\036\n\017fetch_full"
-    "_name\030\017 \001(\010:\005false\022\032\n\013fetch_links\030\020 \001(\010:"
-    "\005false\022&\n\027fetch_parental_controls\030\021 \001(\010:"
-    "\005false\022\034\n\rfetch_cais_id\030\022 \001(\010:\005false\"\305\002\n"
-    "\022GetAccountResponse\0222\n\004blob\030\013 \001(\0132$.bgs."
-    "protocol.account.v1.AccountBlob\022.\n\002id\030\014 "
-    "\001(\0132\".bgs.protocol.account.v1.AccountId\022"
-    "\r\n\005email\030\r \003(\t\022\022\n\nbattle_tag\030\016 \001(\t\022\021\n\tfu"
-    "ll_name\030\017 \001(\t\0227\n\005links\030\020 \003(\0132(.bgs.proto"
-    "col.account.v1.GameAccountLink\022K\n\025parent"
-    "al_control_info\030\021 \001(\0132,.bgs.protocol.acc"
-    "ount.v1.ParentalControlInfo\022\017\n\007cais_id\030\022"
-    " \001(\t\"\270\001\n\030CreateGameAccountRequest\0223\n\007acc"
-    "ount\030\001 \001(\0132\".bgs.protocol.account.v1.Acc"
-    "ountId\022\016\n\006region\030\002 \001(\r\022\017\n\007program\030\003 \001(\007\022"
-    "\034\n\021realm_permissions\030\004 \001(\r:\0010\022\026\n\016account"
-    "_region\030\005 \001(\r\022\020\n\010platform\030\006 \001(\007\"]\n\031Creat"
-    "eGameAccountResponse\022@\n\014game_account\030\001 \001"
-    "(\0132*.bgs.protocol.account.v1.GameAccount"
-    "Handle\"\232\001\n\022CacheExpireRequest\0223\n\007account"
-    "\030\001 \003(\0132\".bgs.protocol.account.v1.Account"
-    "Id\022@\n\014game_account\030\002 \003(\0132*.bgs.protocol."
-    "account.v1.GameAccountHandle\022\r\n\005email\030\003 "
-    "\003(\t\"\350\001\n\027CredentialUpdateRequest\0223\n\007accou"
-    "nt\030\001 \002(\0132\".bgs.protocol.account.v1.Accou"
-    "ntId\022C\n\017old_credentials\030\002 \003(\0132*.bgs.prot"
-    "ocol.account.v1.AccountCredential\022C\n\017new"
-    "_credentials\030\003 \003(\0132*.bgs.protocol.accoun"
-    "t.v1.AccountCredential\022\016\n\006region\030\004 \001(\r\"\032"
-    "\n\030CredentialUpdateResponse\"}\n\030AccountFla"
-    "gUpdateRequest\0223\n\007account\030\001 \001(\0132\".bgs.pr"
-    "otocol.account.v1.AccountId\022\016\n\006region\030\002 "
-    "\001(\r\022\014\n\004flag\030\003 \001(\004\022\016\n\006active\030\004 \001(\010\"~\n\034Gam"
-    "eAccountFlagUpdateRequest\022@\n\014game_accoun"
-    "t\030\001 \001(\0132*.bgs.protocol.account.v1.GameAc"
-    "countHandle\022\014\n\004flag\030\002 \001(\004\022\016\n\006active\030\003 \001("
-    "\010\"V\n\031SubscriptionUpdateRequest\0229\n\003ref\030\002 "
-    "\003(\0132,.bgs.protocol.account.v1.Subscriber"
-    "Reference\"W\n\032SubscriptionUpdateResponse\022"
-    "9\n\003ref\030\001 \003(\0132,.bgs.protocol.account.v1.S"
-    "ubscriberReference\"=\n\023IsIgrAddressReques"
-    "t\022\026\n\016client_address\030\001 \001(\t\022\016\n\006region\030\002 \001("
-    "\r\"1\n\024AccountServiceRegion\022\n\n\002id\030\001 \002(\r\022\r\n"
-    "\005shard\030\002 \002(\t\"U\n\024AccountServiceConfig\022=\n\006"
-    "region\030\001 \003(\0132-.bgs.protocol.account.v1.A"
-    "ccountServiceRegion\"\334\001\n\026GetAccountStateR"
-    "equest\022)\n\tentity_id\030\001 \001(\0132\026.bgs.protocol"
-    ".EntityId\022\017\n\007program\030\002 \001(\r\022\016\n\006region\030\003 \001"
-    "(\r\022=\n\007options\030\n \001(\0132,.bgs.protocol.accou"
-    "nt.v1.AccountFieldOptions\0227\n\004tags\030\013 \001(\0132"
-    ").bgs.protocol.account.v1.AccountFieldTa"
-    "gs\"\210\001\n\027GetAccountStateResponse\0224\n\005state\030"
-    "\001 \001(\0132%.bgs.protocol.account.v1.AccountS"
-    "tate\0227\n\004tags\030\002 \001(\0132).bgs.protocol.accoun"
-    "t.v1.AccountFieldTags\"\375\001\n\032GetGameAccount"
-    "StateRequest\022.\n\naccount_id\030\001 \001(\0132\026.bgs.p"
-    "rotocol.EntityIdB\002\030\001\022/\n\017game_account_id\030"
-    "\002 \001(\0132\026.bgs.protocol.EntityId\022A\n\007options"
-    "\030\n \001(\01320.bgs.protocol.account.v1.GameAcc"
-    "ountFieldOptions\022;\n\004tags\030\013 \001(\0132-.bgs.pro"
-    "tocol.account.v1.GameAccountFieldTags\"\224\001"
-    "\n\033GetGameAccountStateResponse\0228\n\005state\030\001"
-    " \001(\0132).bgs.protocol.account.v1.GameAccou"
-    "ntState\022;\n\004tags\030\002 \001(\0132-.bgs.protocol.acc"
-    "ount.v1.GameAccountFieldTags\"\345\001\n\022GetLice"
-    "nsesRequest\022)\n\ttarget_id\030\001 \001(\0132\026.bgs.pro"
-    "tocol.EntityId\022\036\n\026fetch_account_licenses"
-    "\030\002 \001(\010\022#\n\033fetch_game_account_licenses\030\003 "
-    "\001(\010\022&\n\036fetch_dynamic_account_licenses\030\004 "
-    "\001(\010\022\017\n\007program\030\005 \001(\007\022&\n\027exclude_unknown_"
-    "program\030\006 \001(\010:\005false\"P\n\023GetLicensesRespo"
-    "nse\0229\n\010licenses\030\001 \003(\0132\'.bgs.protocol.acc"
-    "ount.v1.AccountLicense\"F\n\031GetGameSession"
-    "InfoRequest\022)\n\tentity_id\030\001 \001(\0132\026.bgs.pro"
-    "tocol.EntityId\"\\\n\032GetGameSessionInfoResp"
-    "onse\022>\n\014session_info\030\002 \001(\0132(.bgs.protoco"
-    "l.account.v1.GameSessionInfo\"~\n\037GetGameT"
-    "imeRemainingInfoRequest\022/\n\017game_account_"
-    "id\030\001 \001(\0132\026.bgs.protocol.EntityId\022*\n\nacco"
-    "unt_id\030\002 \001(\0132\026.bgs.protocol.EntityId\"t\n "
-    "GetGameTimeRemainingInfoResponse\022P\n\030game"
-    "_time_remaining_info\030\001 \001(\0132..bgs.protoco"
-    "l.account.v1.GameTimeRemainingInfo\"\?\n\022Ge"
-    "tCAISInfoRequest\022)\n\tentity_id\030\001 \001(\0132\026.bg"
-    "s.protocol.EntityId\"G\n\023GetCAISInfoRespon"
-    "se\0220\n\tcais_info\030\001 \001(\0132\035.bgs.protocol.acc"
-    "ount.v1.CAIS\"F\n\031ForwardCacheExpireReques"
+    "pes.proto\032\017rpc_types.proto\"i\n\025ResolveAcc"
+    "ountRequest\0226\n\003ref\030\001 \001(\0132).bgs.protocol."
+    "account.v1.AccountReference\022\020\n\010fetch_id\030"
+    "\014 \001(\010:\006\202\371+\002\010\001\"H\n\026ResolveAccountResponse\022"
+    ".\n\002id\030\014 \001(\0132\".bgs.protocol.account.v1.Ac"
+    "countId\"~\n\034GameAccountFlagUpdateRequest\022"
+    "@\n\014game_account\030\001 \001(\0132*.bgs.protocol.acc"
+    "ount.v1.GameAccountHandle\022\014\n\004flag\030\002 \001(\004\022"
+    "\016\n\006active\030\003 \001(\010\"V\n\031SubscriptionUpdateReq"
+    "uest\0229\n\003ref\030\002 \003(\0132,.bgs.protocol.account"
+    ".v1.SubscriberReference\"W\n\032SubscriptionU"
+    "pdateResponse\0229\n\003ref\030\001 \003(\0132,.bgs.protoco"
+    "l.account.v1.SubscriberReference\"=\n\023IsIg"
+    "rAddressRequest\022\026\n\016client_address\030\001 \001(\t\022"
+    "\016\n\006region\030\002 \001(\r\"\344\001\n\026GetAccountStateReque"
+    "st\0221\n\tentity_id\030\001 \001(\0132\026.bgs.protocol.Ent"
+    "ityIdB\006\202\371+\002\020\001\022\017\n\007program\030\002 \001(\r\022\016\n\006region"
+    "\030\003 \001(\r\022=\n\007options\030\n \001(\0132,.bgs.protocol.a"
+    "ccount.v1.AccountFieldOptions\0227\n\004tags\030\013 "
+    "\001(\0132).bgs.protocol.account.v1.AccountFie"
+    "ldTags\"\210\001\n\027GetAccountStateResponse\0224\n\005st"
+    "ate\030\001 \001(\0132%.bgs.protocol.account.v1.Acco"
+    "untState\0227\n\004tags\030\002 \001(\0132).bgs.protocol.ac"
+    "count.v1.AccountFieldTags\"S\n\034GetSignedAc"
+    "countStateRequest\0223\n\007account\030\001 \001(\0132\".bgs"
+    ".protocol.account.v1.AccountId\".\n\035GetSig"
+    "nedAccountStateResponse\022\r\n\005token\030\001 \001(\t\"\375"
+    "\001\n\032GetGameAccountStateRequest\022.\n\naccount"
+    "_id\030\001 \001(\0132\026.bgs.protocol.EntityIdB\002\030\001\022/\n"
+    "\017game_account_id\030\002 \001(\0132\026.bgs.protocol.En"
+    "tityId\022A\n\007options\030\n \001(\01320.bgs.protocol.a"
+    "ccount.v1.GameAccountFieldOptions\022;\n\004tag"
+    "s\030\013 \001(\0132-.bgs.protocol.account.v1.GameAc"
+    "countFieldTags\"\224\001\n\033GetGameAccountStateRe"
+    "sponse\0228\n\005state\030\001 \001(\0132).bgs.protocol.acc"
+    "ount.v1.GameAccountState\022;\n\004tags\030\002 \001(\0132-"
+    ".bgs.protocol.account.v1.GameAccountFiel"
+    "dTags\"\355\001\n\022GetLicensesRequest\0221\n\ttarget_i"
+    "d\030\001 \001(\0132\026.bgs.protocol.EntityIdB\006\202\371+\002\020\001\022"
+    "\036\n\026fetch_account_licenses\030\002 \001(\010\022#\n\033fetch"
+    "_game_account_licenses\030\003 \001(\010\022&\n\036fetch_dy"
+    "namic_account_licenses\030\004 \001(\010\022\017\n\007program\030"
+    "\005 \001(\007\022&\n\027exclude_unknown_program\030\006 \001(\010:\005"
+    "false\"P\n\023GetLicensesResponse\0229\n\010licenses"
+    "\030\001 \003(\0132\'.bgs.protocol.account.v1.Account"
+    "License\"F\n\031GetGameSessionInfoRequest\022)\n\t"
+    "entity_id\030\001 \001(\0132\026.bgs.protocol.EntityId\""
+    "\\\n\032GetGameSessionInfoResponse\022>\n\014session"
+    "_info\030\002 \001(\0132(.bgs.protocol.account.v1.Ga"
+    "meSessionInfo\"~\n\037GetGameTimeRemainingInf"
+    "oRequest\022/\n\017game_account_id\030\001 \001(\0132\026.bgs."
+    "protocol.EntityId\022*\n\naccount_id\030\002 \001(\0132\026."
+    "bgs.protocol.EntityId\"t\n GetGameTimeRema"
+    "iningInfoResponse\022P\n\030game_time_remaining"
+    "_info\030\001 \001(\0132..bgs.protocol.account.v1.Ga"
+    "meTimeRemainingInfo\"\?\n\022GetCAISInfoReques"
     "t\022)\n\tentity_id\030\001 \001(\0132\026.bgs.protocol.Enti"
-    "tyId\"n\n\030GetAuthorizedDataRequest\022)\n\tenti"
-    "ty_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\013\n\003t"
-    "ag\030\002 \003(\t\022\032\n\022privileged_network\030\003 \001(\010\"R\n\031"
-    "GetAuthorizedDataResponse\0225\n\004data\030\001 \003(\0132"
-    "\'.bgs.protocol.account.v1.AuthorizedData"
-    "\"\373\001\n$UpdateParentalControlsAndCAISReques"
-    "t\0223\n\007account\030\001 \001(\0132\".bgs.protocol.accoun"
-    "t.v1.AccountId\022K\n\025parental_control_info\030"
-    "\002 \001(\0132,.bgs.protocol.account.v1.Parental"
-    "ControlInfo\022\017\n\007cais_id\030\003 \001(\t\022\032\n\022session_"
-    "start_time\030\004 \001(\004\022\022\n\nstart_time\030\005 \001(\004\022\020\n\010"
-    "end_time\030\006 \001(\004\"X\n\030QueueDeductRecordReque"
-    "st\022<\n\rdeduct_record\030\001 \001(\0132%.bgs.protocol"
-    ".account.v1.DeductRecord\"p\n\025GetGameAccou"
-    "ntRequest\022@\n\014game_account\030\001 \001(\0132*.bgs.pr"
-    "otocol.account.v1.GameAccountHandle\022\025\n\006r"
-    "eload\030\002 \001(\010:\005false\"P\n\026GetGameAccountResp"
-    "onse\0226\n\004blob\030\001 \001(\0132(.bgs.protocol.accoun"
-    "t.v1.GameAccountBlob\"\320\001\n\030AccountStateNot"
-    "ification\022<\n\raccount_state\030\001 \001(\0132%.bgs.p"
-    "rotocol.account.v1.AccountState\022\025\n\rsubsc"
-    "riber_id\030\002 \001(\004\022\?\n\014account_tags\030\003 \001(\0132).b"
-    "gs.protocol.account.v1.AccountFieldTags\022"
-    "\036\n\026subscription_completed\030\004 \001(\010\"\346\001\n\034Game"
-    "AccountStateNotification\022E\n\022game_account"
-    "_state\030\001 \001(\0132).bgs.protocol.account.v1.G"
-    "ameAccountState\022\025\n\rsubscriber_id\030\002 \001(\004\022H"
-    "\n\021game_account_tags\030\003 \001(\0132-.bgs.protocol"
-    ".account.v1.GameAccountFieldTags\022\036\n\026subs"
-    "cription_completed\030\004 \001(\010\"\262\001\n\027GameAccount"
-    "Notification\022\?\n\rgame_accounts\030\001 \003(\0132(.bg"
-    "s.protocol.account.v1.GameAccountList\022\025\n"
-    "\rsubscriber_id\030\002 \001(\004\022\?\n\014account_tags\030\003 \001"
-    "(\0132).bgs.protocol.account.v1.AccountFiel"
-    "dTags\"\250\001\n\036GameAccountSessionNotification"
-    "\022@\n\014game_account\030\001 \001(\0132*.bgs.protocol.ac"
-    "count.v1.GameAccountHandle\022D\n\014session_in"
-    "fo\030\002 \001(\0132..bgs.protocol.account.v1.GameS"
-    "essionUpdateInfo2\312\024\n\016AccountService\022p\n\022G"
-    "etGameAccountBlob\022*.bgs.protocol.account"
-    ".v1.GameAccountHandle\032(.bgs.protocol.acc"
-    "ount.v1.GameAccountBlob\"\004\200\265\030\014\022k\n\nGetAcco"
-    "unt\022*.bgs.protocol.account.v1.GetAccount"
-    "Request\032+.bgs.protocol.account.v1.GetAcc"
-    "ountResponse\"\004\200\265\030\r\022x\n\021CreateGameAccount\022"
-    "1.bgs.protocol.account.v1.CreateGameAcco"
-    "untRequest\032*.bgs.protocol.account.v1.Gam"
-    "eAccountHandle\"\004\200\265\030\016\022X\n\014IsIgrAddress\022,.b"
-    "gs.protocol.account.v1.IsIgrAddressReque"
-    "st\032\024.bgs.protocol.NoData\"\004\200\265\030\017\022[\n\013CacheE"
-    "xpire\022+.bgs.protocol.account.v1.CacheExp"
-    "ireRequest\032\031.bgs.protocol.NO_RESPONSE\"\004\200"
-    "\265\030\024\022\200\001\n\020CredentialUpdate\0220.bgs.protocol."
-    "account.v1.CredentialUpdateRequest\0321.bgs"
-    ".protocol.account.v1.CredentialUpdateRes"
-    "ponse\"\007\210\002\001\200\265\030\025\022z\n\tSubscribe\0222.bgs.protoc"
-    "ol.account.v1.SubscriptionUpdateRequest\032"
-    "3.bgs.protocol.account.v1.SubscriptionUp"
-    "dateResponse\"\004\200\265\030\031\022]\n\013Unsubscribe\0222.bgs."
+    "tyId\"G\n\023GetCAISInfoResponse\0220\n\tcais_info"
+    "\030\001 \001(\0132\035.bgs.protocol.account.v1.CAIS\"n\n"
+    "\030GetAuthorizedDataRequest\022)\n\tentity_id\030\001"
+    " \001(\0132\026.bgs.protocol.EntityId\022\013\n\003tag\030\002 \003("
+    "\t\022\032\n\022privileged_network\030\003 \001(\010\"R\n\031GetAuth"
+    "orizedDataResponse\0225\n\004data\030\001 \003(\0132\'.bgs.p"
+    "rotocol.account.v1.AuthorizedData\"\373\001\n$Up"
+    "dateParentalControlsAndCAISRequest\0223\n\007ac"
+    "count\030\001 \001(\0132\".bgs.protocol.account.v1.Ac"
+    "countId\022K\n\025parental_control_info\030\002 \001(\0132,"
+    ".bgs.protocol.account.v1.ParentalControl"
+    "Info\022\017\n\007cais_id\030\003 \001(\t\022\032\n\022session_start_t"
+    "ime\030\004 \001(\004\022\022\n\nstart_time\030\005 \001(\004\022\020\n\010end_tim"
+    "e\030\006 \001(\004\"\324\001\n\030AccountStateNotification\022<\n\r"
+    "account_state\030\001 \001(\0132%.bgs.protocol.accou"
+    "nt.v1.AccountState\022\031\n\rsubscriber_id\030\002 \001("
+    "\004B\002\030\001\022\?\n\014account_tags\030\003 \001(\0132).bgs.protoc"
+    "ol.account.v1.AccountFieldTags\022\036\n\026subscr"
+    "iption_completed\030\004 \001(\010\"\352\001\n\034GameAccountSt"
+    "ateNotification\022E\n\022game_account_state\030\001 "
+    "\001(\0132).bgs.protocol.account.v1.GameAccoun"
+    "tState\022\031\n\rsubscriber_id\030\002 \001(\004B\002\030\001\022H\n\021gam"
+    "e_account_tags\030\003 \001(\0132-.bgs.protocol.acco"
+    "unt.v1.GameAccountFieldTags\022\036\n\026subscript"
+    "ion_completed\030\004 \001(\010\"\262\001\n\027GameAccountNotif"
+    "ication\022\?\n\rgame_accounts\030\001 \003(\0132(.bgs.pro"
+    "tocol.account.v1.GameAccountList\022\025\n\rsubs"
+    "criber_id\030\002 \001(\004\022\?\n\014account_tags\030\003 \001(\0132)."
+    "bgs.protocol.account.v1.AccountFieldTags"
+    "\"\250\001\n\036GameAccountSessionNotification\022@\n\014g"
+    "ame_account\030\001 \001(\0132*.bgs.protocol.account"
+    ".v1.GameAccountHandle\022D\n\014session_info\030\002 "
+    "\001(\0132..bgs.protocol.account.v1.GameSessio"
+    "nUpdateInfo2\240\014\n\016AccountService\022y\n\016Resolv"
+    "eAccount\022..bgs.protocol.account.v1.Resol"
+    "veAccountRequest\032/.bgs.protocol.account."
+    "v1.ResolveAccountResponse\"\006\202\371+\002\010\r\022]\n\014IsI"
+    "grAddress\022,.bgs.protocol.account.v1.IsIg"
+    "rAddressRequest\032\024.bgs.protocol.NoData\"\t\210"
+    "\002\001\202\371+\002\010\017\022|\n\tSubscribe\0222.bgs.protocol.acc"
+    "ount.v1.SubscriptionUpdateRequest\0323.bgs."
     "protocol.account.v1.SubscriptionUpdateRe"
-    "quest\032\024.bgs.protocol.NoData\"\004\200\265\030\032\022z\n\017Get"
-    "AccountState\022/.bgs.protocol.account.v1.G"
-    "etAccountStateRequest\0320.bgs.protocol.acc"
-    "ount.v1.GetAccountStateResponse\"\004\200\265\030\036\022\206\001"
+    "sponse\"\006\202\371+\002\010\031\022_\n\013Unsubscribe\0222.bgs.prot"
+    "ocol.account.v1.SubscriptionUpdateReques"
+    "t\032\024.bgs.protocol.NoData\"\006\202\371+\002\010\032\022|\n\017GetAc"
+    "countState\022/.bgs.protocol.account.v1.Get"
+    "AccountStateRequest\0320.bgs.protocol.accou"
+    "nt.v1.GetAccountStateResponse\"\006\202\371+\002\010\036\022\210\001"
     "\n\023GetGameAccountState\0223.bgs.protocol.acc"
     "ount.v1.GetGameAccountStateRequest\0324.bgs"
     ".protocol.account.v1.GetGameAccountState"
-    "Response\"\004\200\265\030\037\022n\n\013GetLicenses\022+.bgs.prot"
-    "ocol.account.v1.GetLicensesRequest\032,.bgs"
-    ".protocol.account.v1.GetLicensesResponse"
-    "\"\004\200\265\030 \022\225\001\n\030GetGameTimeRemainingInfo\0228.bg"
-    "s.protocol.account.v1.GetGameTimeRemaini"
-    "ngInfoRequest\0329.bgs.protocol.account.v1."
-    "GetGameTimeRemainingInfoResponse\"\004\200\265\030!\022\203"
-    "\001\n\022GetGameSessionInfo\0222.bgs.protocol.acc"
-    "ount.v1.GetGameSessionInfoRequest\0323.bgs."
-    "protocol.account.v1.GetGameSessionInfoRe"
-    "sponse\"\004\200\265\030\"\022n\n\013GetCAISInfo\022+.bgs.protoc"
-    "ol.account.v1.GetCAISInfoRequest\032,.bgs.p"
-    "rotocol.account.v1.GetCAISInfoResponse\"\004"
-    "\200\265\030#\022d\n\022ForwardCacheExpire\0222.bgs.protoco"
-    "l.account.v1.ForwardCacheExpireRequest\032\024"
-    ".bgs.protocol.NoData\"\004\200\265\030$\022\200\001\n\021GetAuthor"
-    "izedData\0221.bgs.protocol.account.v1.GetAu"
-    "thorizedDataRequest\0322.bgs.protocol.accou"
-    "nt.v1.GetAuthorizedDataResponse\"\004\200\265\030%\022g\n"
-    "\021AccountFlagUpdate\0221.bgs.protocol.accoun"
-    "t.v1.AccountFlagUpdateRequest\032\031.bgs.prot"
-    "ocol.NO_RESPONSE\"\004\200\265\030&\022o\n\025GameAccountFla"
-    "gUpdate\0225.bgs.protocol.account.v1.GameAc"
-    "countFlagUpdateRequest\032\031.bgs.protocol.NO"
-    "_RESPONSE\"\004\200\265\030\'\022z\n\035UpdateParentalControl"
-    "sAndCAIS\022=.bgs.protocol.account.v1.Updat"
-    "eParentalControlsAndCAISRequest\032\024.bgs.pr"
-    "otocol.NoData\"\004\200\265\030(\022\201\001\n\022CreateGameAccoun"
-    "t2\0221.bgs.protocol.account.v1.CreateGameA"
-    "ccountRequest\0322.bgs.protocol.account.v1."
-    "CreateGameAccountResponse\"\004\200\265\030)\022w\n\016GetGa"
-    "meAccount\022..bgs.protocol.account.v1.GetG"
-    "ameAccountRequest\032/.bgs.protocol.account"
-    ".v1.GetGameAccountResponse\"\004\200\265\030*\022b\n\021Queu"
-    "eDeductRecord\0221.bgs.protocol.account.v1."
-    "QueueDeductRecordRequest\032\024.bgs.protocol."
-    "NoData\"\004\200\265\030+\032\'\312>$bnet.protocol.account.A"
-    "ccountService2\377\003\n\017AccountListener\022k\n\025OnA"
-    "ccountStateUpdated\0221.bgs.protocol.accoun"
-    "t.v1.AccountStateNotification\032\031.bgs.prot"
-    "ocol.NO_RESPONSE\"\004\200\265\030\001\022s\n\031OnGameAccountS"
-    "tateUpdated\0225.bgs.protocol.account.v1.Ga"
-    "meAccountStateNotification\032\031.bgs.protoco"
-    "l.NO_RESPONSE\"\004\200\265\030\002\022m\n\025OnGameAccountsUpd"
-    "ated\0220.bgs.protocol.account.v1.GameAccou"
-    "ntNotification\032\031.bgs.protocol.NO_RESPONS"
-    "E\"\007\210\002\001\200\265\030\003\022s\n\024OnGameSessionUpdated\0227.bgs"
-    ".protocol.account.v1.GameAccountSessionN"
-    "otification\032\031.bgs.protocol.NO_RESPONSE\"\007"
-    "\210\002\001\200\265\030\004\032&\312>#bnet.protocol.account.Accoun"
-    "tNotifyB\005H\001\200\001\000", 8534);
+    "Response\"\006\202\371+\002\010\037\022p\n\013GetLicenses\022+.bgs.pr"
+    "otocol.account.v1.GetLicensesRequest\032,.b"
+    "gs.protocol.account.v1.GetLicensesRespon"
+    "se\"\006\202\371+\002\010 \022\227\001\n\030GetGameTimeRemainingInfo\022"
+    "8.bgs.protocol.account.v1.GetGameTimeRem"
+    "ainingInfoRequest\0329.bgs.protocol.account"
+    ".v1.GetGameTimeRemainingInfoResponse\"\006\202\371"
+    "+\002\010!\022\205\001\n\022GetGameSessionInfo\0222.bgs.protoc"
+    "ol.account.v1.GetGameSessionInfoRequest\032"
+    "3.bgs.protocol.account.v1.GetGameSession"
+    "InfoResponse\"\006\202\371+\002\010\"\022p\n\013GetCAISInfo\022+.bg"
+    "s.protocol.account.v1.GetCAISInfoRequest"
+    "\032,.bgs.protocol.account.v1.GetCAISInfoRe"
+    "sponse\"\006\202\371+\002\010#\022\202\001\n\021GetAuthorizedData\0221.b"
+    "gs.protocol.account.v1.GetAuthorizedData"
+    "Request\0322.bgs.protocol.account.v1.GetAut"
+    "horizedDataResponse\"\006\202\371+\002\010%\022\216\001\n\025GetSigne"
+    "dAccountState\0225.bgs.protocol.account.v1."
+    "GetSignedAccountStateRequest\0326.bgs.proto"
+    "col.account.v1.GetSignedAccountStateResp"
+    "onse\"\006\202\371+\002\010,\0320\202\371+&\n$bnet.protocol.accoun"
+    "t.AccountService\212\371+\002\020\0012\220\004\n\017AccountListen"
+    "er\022m\n\025OnAccountStateUpdated\0221.bgs.protoc"
+    "ol.account.v1.AccountStateNotification\032\031"
+    ".bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010\001\022u\n\031OnG"
+    "ameAccountStateUpdated\0225.bgs.protocol.ac"
+    "count.v1.GameAccountStateNotification\032\031."
+    "bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010\002\022o\n\025OnGa"
+    "meAccountsUpdated\0220.bgs.protocol.account"
+    ".v1.GameAccountNotification\032\031.bgs.protoc"
+    "ol.NO_RESPONSE\"\t\210\002\001\202\371+\002\010\003\022u\n\024OnGameSessi"
+    "onUpdated\0227.bgs.protocol.account.v1.Game"
+    "AccountSessionNotification\032\031.bgs.protoco"
+    "l.NO_RESPONSE\"\t\210\002\001\202\371+\002\010\004\032/\202\371+%\n#bnet.pro"
+    "tocol.account.AccountNotify\212\371+\002\010\001B\005H\001\200\001\000", 5800);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "account_service.proto", &protobuf_RegisterTypes);
-  GetAccountRequest::default_instance_ = new GetAccountRequest();
-  GetAccountResponse::default_instance_ = new GetAccountResponse();
-  CreateGameAccountRequest::default_instance_ = new CreateGameAccountRequest();
-  CreateGameAccountResponse::default_instance_ = new CreateGameAccountResponse();
-  CacheExpireRequest::default_instance_ = new CacheExpireRequest();
-  CredentialUpdateRequest::default_instance_ = new CredentialUpdateRequest();
-  CredentialUpdateResponse::default_instance_ = new CredentialUpdateResponse();
-  AccountFlagUpdateRequest::default_instance_ = new AccountFlagUpdateRequest();
+  ResolveAccountRequest::default_instance_ = new ResolveAccountRequest();
+  ResolveAccountResponse::default_instance_ = new ResolveAccountResponse();
   GameAccountFlagUpdateRequest::default_instance_ = new GameAccountFlagUpdateRequest();
   SubscriptionUpdateRequest::default_instance_ = new SubscriptionUpdateRequest();
   SubscriptionUpdateResponse::default_instance_ = new SubscriptionUpdateResponse();
   IsIgrAddressRequest::default_instance_ = new IsIgrAddressRequest();
-  AccountServiceRegion::default_instance_ = new AccountServiceRegion();
-  AccountServiceConfig::default_instance_ = new AccountServiceConfig();
   GetAccountStateRequest::default_instance_ = new GetAccountStateRequest();
   GetAccountStateResponse::default_instance_ = new GetAccountStateResponse();
+  GetSignedAccountStateRequest::default_instance_ = new GetSignedAccountStateRequest();
+  GetSignedAccountStateResponse::default_instance_ = new GetSignedAccountStateResponse();
   GetGameAccountStateRequest::default_instance_ = new GetGameAccountStateRequest();
   GetGameAccountStateResponse::default_instance_ = new GetGameAccountStateResponse();
   GetLicensesRequest::default_instance_ = new GetLicensesRequest();
@@ -1191,33 +866,23 @@ void protobuf_AddDesc_account_5fservice_2eproto() {
   GetGameTimeRemainingInfoResponse::default_instance_ = new GetGameTimeRemainingInfoResponse();
   GetCAISInfoRequest::default_instance_ = new GetCAISInfoRequest();
   GetCAISInfoResponse::default_instance_ = new GetCAISInfoResponse();
-  ForwardCacheExpireRequest::default_instance_ = new ForwardCacheExpireRequest();
   GetAuthorizedDataRequest::default_instance_ = new GetAuthorizedDataRequest();
   GetAuthorizedDataResponse::default_instance_ = new GetAuthorizedDataResponse();
   UpdateParentalControlsAndCAISRequest::default_instance_ = new UpdateParentalControlsAndCAISRequest();
-  QueueDeductRecordRequest::default_instance_ = new QueueDeductRecordRequest();
-  GetGameAccountRequest::default_instance_ = new GetGameAccountRequest();
-  GetGameAccountResponse::default_instance_ = new GetGameAccountResponse();
   AccountStateNotification::default_instance_ = new AccountStateNotification();
   GameAccountStateNotification::default_instance_ = new GameAccountStateNotification();
   GameAccountNotification::default_instance_ = new GameAccountNotification();
   GameAccountSessionNotification::default_instance_ = new GameAccountSessionNotification();
-  GetAccountRequest::default_instance_->InitAsDefaultInstance();
-  GetAccountResponse::default_instance_->InitAsDefaultInstance();
-  CreateGameAccountRequest::default_instance_->InitAsDefaultInstance();
-  CreateGameAccountResponse::default_instance_->InitAsDefaultInstance();
-  CacheExpireRequest::default_instance_->InitAsDefaultInstance();
-  CredentialUpdateRequest::default_instance_->InitAsDefaultInstance();
-  CredentialUpdateResponse::default_instance_->InitAsDefaultInstance();
-  AccountFlagUpdateRequest::default_instance_->InitAsDefaultInstance();
+  ResolveAccountRequest::default_instance_->InitAsDefaultInstance();
+  ResolveAccountResponse::default_instance_->InitAsDefaultInstance();
   GameAccountFlagUpdateRequest::default_instance_->InitAsDefaultInstance();
   SubscriptionUpdateRequest::default_instance_->InitAsDefaultInstance();
   SubscriptionUpdateResponse::default_instance_->InitAsDefaultInstance();
   IsIgrAddressRequest::default_instance_->InitAsDefaultInstance();
-  AccountServiceRegion::default_instance_->InitAsDefaultInstance();
-  AccountServiceConfig::default_instance_->InitAsDefaultInstance();
   GetAccountStateRequest::default_instance_->InitAsDefaultInstance();
   GetAccountStateResponse::default_instance_->InitAsDefaultInstance();
+  GetSignedAccountStateRequest::default_instance_->InitAsDefaultInstance();
+  GetSignedAccountStateResponse::default_instance_->InitAsDefaultInstance();
   GetGameAccountStateRequest::default_instance_->InitAsDefaultInstance();
   GetGameAccountStateResponse::default_instance_->InitAsDefaultInstance();
   GetLicensesRequest::default_instance_->InitAsDefaultInstance();
@@ -1228,13 +893,9 @@ void protobuf_AddDesc_account_5fservice_2eproto() {
   GetGameTimeRemainingInfoResponse::default_instance_->InitAsDefaultInstance();
   GetCAISInfoRequest::default_instance_->InitAsDefaultInstance();
   GetCAISInfoResponse::default_instance_->InitAsDefaultInstance();
-  ForwardCacheExpireRequest::default_instance_->InitAsDefaultInstance();
   GetAuthorizedDataRequest::default_instance_->InitAsDefaultInstance();
   GetAuthorizedDataResponse::default_instance_->InitAsDefaultInstance();
   UpdateParentalControlsAndCAISRequest::default_instance_->InitAsDefaultInstance();
-  QueueDeductRecordRequest::default_instance_->InitAsDefaultInstance();
-  GetGameAccountRequest::default_instance_->InitAsDefaultInstance();
-  GetGameAccountResponse::default_instance_->InitAsDefaultInstance();
   AccountStateNotification::default_instance_->InitAsDefaultInstance();
   GameAccountStateNotification::default_instance_->InitAsDefaultInstance();
   GameAccountNotification::default_instance_->InitAsDefaultInstance();
@@ -1252,117 +913,84 @@ struct StaticDescriptorInitializer_account_5fservice_2eproto {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int GetAccountRequest::kRefFieldNumber;
-const int GetAccountRequest::kReloadFieldNumber;
-const int GetAccountRequest::kFetchAllFieldNumber;
-const int GetAccountRequest::kFetchBlobFieldNumber;
-const int GetAccountRequest::kFetchIdFieldNumber;
-const int GetAccountRequest::kFetchEmailFieldNumber;
-const int GetAccountRequest::kFetchBattleTagFieldNumber;
-const int GetAccountRequest::kFetchFullNameFieldNumber;
-const int GetAccountRequest::kFetchLinksFieldNumber;
-const int GetAccountRequest::kFetchParentalControlsFieldNumber;
-const int GetAccountRequest::kFetchCaisIdFieldNumber;
+const int ResolveAccountRequest::kRefFieldNumber;
+const int ResolveAccountRequest::kFetchIdFieldNumber;
 #endif  // !_MSC_VER
 
-GetAccountRequest::GetAccountRequest()
+ResolveAccountRequest::ResolveAccountRequest()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ResolveAccountRequest)
 }
 
-void GetAccountRequest::InitAsDefaultInstance() {
+void ResolveAccountRequest::InitAsDefaultInstance() {
   ref_ = const_cast< ::bgs::protocol::account::v1::AccountReference*>(&::bgs::protocol::account::v1::AccountReference::default_instance());
 }
 
-GetAccountRequest::GetAccountRequest(const GetAccountRequest& from)
+ResolveAccountRequest::ResolveAccountRequest(const ResolveAccountRequest& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ResolveAccountRequest)
 }
 
-void GetAccountRequest::SharedCtor() {
+void ResolveAccountRequest::SharedCtor() {
   _cached_size_ = 0;
   ref_ = NULL;
-  reload_ = false;
-  fetch_all_ = false;
-  fetch_blob_ = false;
   fetch_id_ = false;
-  fetch_email_ = false;
-  fetch_battle_tag_ = false;
-  fetch_full_name_ = false;
-  fetch_links_ = false;
-  fetch_parental_controls_ = false;
-  fetch_cais_id_ = false;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-GetAccountRequest::~GetAccountRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountRequest)
+ResolveAccountRequest::~ResolveAccountRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ResolveAccountRequest)
   SharedDtor();
 }
 
-void GetAccountRequest::SharedDtor() {
+void ResolveAccountRequest::SharedDtor() {
   if (this != default_instance_) {
     delete ref_;
   }
 }
 
-void GetAccountRequest::SetCachedSize(int size) const {
+void ResolveAccountRequest::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* GetAccountRequest::descriptor() {
+const ::google::protobuf::Descriptor* ResolveAccountRequest::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return GetAccountRequest_descriptor_;
+  return ResolveAccountRequest_descriptor_;
 }
 
-const GetAccountRequest& GetAccountRequest::default_instance() {
+const ResolveAccountRequest& ResolveAccountRequest::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
   return *default_instance_;
 }
 
-GetAccountRequest* GetAccountRequest::default_instance_ = NULL;
+ResolveAccountRequest* ResolveAccountRequest::default_instance_ = NULL;
 
-GetAccountRequest* GetAccountRequest::New() const {
-  return new GetAccountRequest;
+ResolveAccountRequest* ResolveAccountRequest::New() const {
+  return new ResolveAccountRequest;
 }
 
-void GetAccountRequest::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<GetAccountRequest*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 255) {
-    ZR_(reload_, fetch_full_name_);
+void ResolveAccountRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
     if (has_ref()) {
       if (ref_ != NULL) ref_->::bgs::protocol::account::v1::AccountReference::Clear();
     }
+    fetch_id_ = false;
   }
-  ZR_(fetch_links_, fetch_cais_id_);
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool GetAccountRequest::MergePartialFromCodedStream(
+bool ResolveAccountRequest::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ResolveAccountRequest)
   for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
@@ -1374,56 +1002,11 @@ bool GetAccountRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(16)) goto parse_reload;
-        break;
-      }
-
-      // optional bool reload = 2 [default = false];
-      case 2: {
-        if (tag == 16) {
-         parse_reload:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &reload_)));
-          set_has_reload();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(80)) goto parse_fetch_all;
-        break;
-      }
-
-      // optional bool fetch_all = 10 [default = false];
-      case 10: {
-        if (tag == 80) {
-         parse_fetch_all:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &fetch_all_)));
-          set_has_fetch_all();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(88)) goto parse_fetch_blob;
-        break;
-      }
-
-      // optional bool fetch_blob = 11 [default = false];
-      case 11: {
-        if (tag == 88) {
-         parse_fetch_blob:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &fetch_blob_)));
-          set_has_fetch_blob();
-        } else {
-          goto handle_unusual;
-        }
         if (input->ExpectTag(96)) goto parse_fetch_id;
         break;
       }
 
-      // optional bool fetch_id = 12 [default = false];
+      // optional bool fetch_id = 12;
       case 12: {
         if (tag == 96) {
          parse_fetch_id:
@@ -1434,96 +1017,6 @@ bool GetAccountRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(104)) goto parse_fetch_email;
-        break;
-      }
-
-      // optional bool fetch_email = 13 [default = false];
-      case 13: {
-        if (tag == 104) {
-         parse_fetch_email:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &fetch_email_)));
-          set_has_fetch_email();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(112)) goto parse_fetch_battle_tag;
-        break;
-      }
-
-      // optional bool fetch_battle_tag = 14 [default = false];
-      case 14: {
-        if (tag == 112) {
-         parse_fetch_battle_tag:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &fetch_battle_tag_)));
-          set_has_fetch_battle_tag();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(120)) goto parse_fetch_full_name;
-        break;
-      }
-
-      // optional bool fetch_full_name = 15 [default = false];
-      case 15: {
-        if (tag == 120) {
-         parse_fetch_full_name:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &fetch_full_name_)));
-          set_has_fetch_full_name();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(128)) goto parse_fetch_links;
-        break;
-      }
-
-      // optional bool fetch_links = 16 [default = false];
-      case 16: {
-        if (tag == 128) {
-         parse_fetch_links:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &fetch_links_)));
-          set_has_fetch_links();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(136)) goto parse_fetch_parental_controls;
-        break;
-      }
-
-      // optional bool fetch_parental_controls = 17 [default = false];
-      case 17: {
-        if (tag == 136) {
-         parse_fetch_parental_controls:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &fetch_parental_controls_)));
-          set_has_fetch_parental_controls();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(144)) goto parse_fetch_cais_id;
-        break;
-      }
-
-      // optional bool fetch_cais_id = 18 [default = false];
-      case 18: {
-        if (tag == 144) {
-         parse_fetch_cais_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &fetch_cais_id_)));
-          set_has_fetch_cais_id();
-        } else {
-          goto handle_unusual;
-        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -1542,83 +1035,38 @@ bool GetAccountRequest::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.ResolveAccountRequest)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ResolveAccountRequest)
   return false;
 #undef DO_
 }
 
-void GetAccountRequest::SerializeWithCachedSizes(
+void ResolveAccountRequest::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ResolveAccountRequest)
   // optional .bgs.protocol.account.v1.AccountReference ref = 1;
   if (has_ref()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       1, this->ref(), output);
   }
 
-  // optional bool reload = 2 [default = false];
-  if (has_reload()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->reload(), output);
-  }
-
-  // optional bool fetch_all = 10 [default = false];
-  if (has_fetch_all()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->fetch_all(), output);
-  }
-
-  // optional bool fetch_blob = 11 [default = false];
-  if (has_fetch_blob()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->fetch_blob(), output);
-  }
-
-  // optional bool fetch_id = 12 [default = false];
+  // optional bool fetch_id = 12;
   if (has_fetch_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->fetch_id(), output);
   }
 
-  // optional bool fetch_email = 13 [default = false];
-  if (has_fetch_email()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->fetch_email(), output);
-  }
-
-  // optional bool fetch_battle_tag = 14 [default = false];
-  if (has_fetch_battle_tag()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->fetch_battle_tag(), output);
-  }
-
-  // optional bool fetch_full_name = 15 [default = false];
-  if (has_fetch_full_name()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->fetch_full_name(), output);
-  }
-
-  // optional bool fetch_links = 16 [default = false];
-  if (has_fetch_links()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->fetch_links(), output);
-  }
-
-  // optional bool fetch_parental_controls = 17 [default = false];
-  if (has_fetch_parental_controls()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->fetch_parental_controls(), output);
-  }
-
-  // optional bool fetch_cais_id = 18 [default = false];
-  if (has_fetch_cais_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(18, this->fetch_cais_id(), output);
-  }
-
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ResolveAccountRequest)
 }
 
-::google::protobuf::uint8* GetAccountRequest::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* ResolveAccountRequest::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ResolveAccountRequest)
   // optional .bgs.protocol.account.v1.AccountReference ref = 1;
   if (has_ref()) {
     target = ::google::protobuf::internal::WireFormatLite::
@@ -1626,65 +1074,20 @@ void GetAccountRequest::SerializeWithCachedSizes(
         1, this->ref(), target);
   }
 
-  // optional bool reload = 2 [default = false];
-  if (has_reload()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->reload(), target);
-  }
-
-  // optional bool fetch_all = 10 [default = false];
-  if (has_fetch_all()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->fetch_all(), target);
-  }
-
-  // optional bool fetch_blob = 11 [default = false];
-  if (has_fetch_blob()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->fetch_blob(), target);
-  }
-
-  // optional bool fetch_id = 12 [default = false];
+  // optional bool fetch_id = 12;
   if (has_fetch_id()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->fetch_id(), target);
   }
 
-  // optional bool fetch_email = 13 [default = false];
-  if (has_fetch_email()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(13, this->fetch_email(), target);
-  }
-
-  // optional bool fetch_battle_tag = 14 [default = false];
-  if (has_fetch_battle_tag()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(14, this->fetch_battle_tag(), target);
-  }
-
-  // optional bool fetch_full_name = 15 [default = false];
-  if (has_fetch_full_name()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(15, this->fetch_full_name(), target);
-  }
-
-  // optional bool fetch_links = 16 [default = false];
-  if (has_fetch_links()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->fetch_links(), target);
-  }
-
-  // optional bool fetch_parental_controls = 17 [default = false];
-  if (has_fetch_parental_controls()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->fetch_parental_controls(), target);
-  }
-
-  // optional bool fetch_cais_id = 18 [default = false];
-  if (has_fetch_cais_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(18, this->fetch_cais_id(), target);
-  }
-
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ResolveAccountRequest)
   return target;
 }
 
-int GetAccountRequest::ByteSize() const {
+int ResolveAccountRequest::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
@@ -1695,58 +1098,11 @@ int GetAccountRequest::ByteSize() const {
           this->ref());
     }
 
-    // optional bool reload = 2 [default = false];
-    if (has_reload()) {
-      total_size += 1 + 1;
-    }
-
-    // optional bool fetch_all = 10 [default = false];
-    if (has_fetch_all()) {
-      total_size += 1 + 1;
-    }
-
-    // optional bool fetch_blob = 11 [default = false];
-    if (has_fetch_blob()) {
-      total_size += 1 + 1;
-    }
-
-    // optional bool fetch_id = 12 [default = false];
+    // optional bool fetch_id = 12;
     if (has_fetch_id()) {
       total_size += 1 + 1;
     }
 
-    // optional bool fetch_email = 13 [default = false];
-    if (has_fetch_email()) {
-      total_size += 1 + 1;
-    }
-
-    // optional bool fetch_battle_tag = 14 [default = false];
-    if (has_fetch_battle_tag()) {
-      total_size += 1 + 1;
-    }
-
-    // optional bool fetch_full_name = 15 [default = false];
-    if (has_fetch_full_name()) {
-      total_size += 1 + 1;
-    }
-
-  }
-  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
-    // optional bool fetch_links = 16 [default = false];
-    if (has_fetch_links()) {
-      total_size += 2 + 1;
-    }
-
-    // optional bool fetch_parental_controls = 17 [default = false];
-    if (has_fetch_parental_controls()) {
-      total_size += 2 + 1;
-    }
-
-    // optional bool fetch_cais_id = 18 [default = false];
-    if (has_fetch_cais_id()) {
-      total_size += 2 + 1;
-    }
-
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -1759,10 +1115,10 @@ int GetAccountRequest::ByteSize() const {
   return total_size;
 }
 
-void GetAccountRequest::MergeFrom(const ::google::protobuf::Message& from) {
+void ResolveAccountRequest::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const GetAccountRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GetAccountRequest*>(
+  const ResolveAccountRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ResolveAccountRequest*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -1771,61 +1127,32 @@ void GetAccountRequest::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void GetAccountRequest::MergeFrom(const GetAccountRequest& from) {
+void ResolveAccountRequest::MergeFrom(const ResolveAccountRequest& from) {
   GOOGLE_CHECK_NE(&from, this);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     if (from.has_ref()) {
       mutable_ref()->::bgs::protocol::account::v1::AccountReference::MergeFrom(from.ref());
     }
-    if (from.has_reload()) {
-      set_reload(from.reload());
-    }
-    if (from.has_fetch_all()) {
-      set_fetch_all(from.fetch_all());
-    }
-    if (from.has_fetch_blob()) {
-      set_fetch_blob(from.fetch_blob());
-    }
     if (from.has_fetch_id()) {
       set_fetch_id(from.fetch_id());
     }
-    if (from.has_fetch_email()) {
-      set_fetch_email(from.fetch_email());
-    }
-    if (from.has_fetch_battle_tag()) {
-      set_fetch_battle_tag(from.fetch_battle_tag());
-    }
-    if (from.has_fetch_full_name()) {
-      set_fetch_full_name(from.fetch_full_name());
-    }
-  }
-  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
-    if (from.has_fetch_links()) {
-      set_fetch_links(from.fetch_links());
-    }
-    if (from.has_fetch_parental_controls()) {
-      set_fetch_parental_controls(from.fetch_parental_controls());
-    }
-    if (from.has_fetch_cais_id()) {
-      set_fetch_cais_id(from.fetch_cais_id());
-    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void GetAccountRequest::CopyFrom(const ::google::protobuf::Message& from) {
+void ResolveAccountRequest::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void GetAccountRequest::CopyFrom(const GetAccountRequest& from) {
+void ResolveAccountRequest::CopyFrom(const ResolveAccountRequest& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool GetAccountRequest::IsInitialized() const {
+bool ResolveAccountRequest::IsInitialized() const {
 
   if (has_ref()) {
     if (!this->ref().IsInitialized()) return false;
@@ -1833,30 +1160,21 @@ bool GetAccountRequest::IsInitialized() const {
   return true;
 }
 
-void GetAccountRequest::Swap(GetAccountRequest* other) {
+void ResolveAccountRequest::Swap(ResolveAccountRequest* other) {
   if (other != this) {
     std::swap(ref_, other->ref_);
-    std::swap(reload_, other->reload_);
-    std::swap(fetch_all_, other->fetch_all_);
-    std::swap(fetch_blob_, other->fetch_blob_);
     std::swap(fetch_id_, other->fetch_id_);
-    std::swap(fetch_email_, other->fetch_email_);
-    std::swap(fetch_battle_tag_, other->fetch_battle_tag_);
-    std::swap(fetch_full_name_, other->fetch_full_name_);
-    std::swap(fetch_links_, other->fetch_links_);
-    std::swap(fetch_parental_controls_, other->fetch_parental_controls_);
-    std::swap(fetch_cais_id_, other->fetch_cais_id_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata GetAccountRequest::GetMetadata() const {
+::google::protobuf::Metadata ResolveAccountRequest::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GetAccountRequest_descriptor_;
-  metadata.reflection = GetAccountRequest_reflection_;
+  metadata.descriptor = ResolveAccountRequest_descriptor_;
+  metadata.reflection = ResolveAccountRequest_reflection_;
   return metadata;
 }
 
@@ -1864,251 +1182,90 @@ void GetAccountRequest::Swap(GetAccountRequest* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int GetAccountResponse::kBlobFieldNumber;
-const int GetAccountResponse::kIdFieldNumber;
-const int GetAccountResponse::kEmailFieldNumber;
-const int GetAccountResponse::kBattleTagFieldNumber;
-const int GetAccountResponse::kFullNameFieldNumber;
-const int GetAccountResponse::kLinksFieldNumber;
-const int GetAccountResponse::kParentalControlInfoFieldNumber;
-const int GetAccountResponse::kCaisIdFieldNumber;
+const int ResolveAccountResponse::kIdFieldNumber;
 #endif  // !_MSC_VER
 
-GetAccountResponse::GetAccountResponse()
+ResolveAccountResponse::ResolveAccountResponse()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountResponse)
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ResolveAccountResponse)
 }
 
-void GetAccountResponse::InitAsDefaultInstance() {
-  blob_ = const_cast< ::bgs::protocol::account::v1::AccountBlob*>(&::bgs::protocol::account::v1::AccountBlob::default_instance());
+void ResolveAccountResponse::InitAsDefaultInstance() {
   id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
-  parental_control_info_ = const_cast< ::bgs::protocol::account::v1::ParentalControlInfo*>(&::bgs::protocol::account::v1::ParentalControlInfo::default_instance());
 }
 
-GetAccountResponse::GetAccountResponse(const GetAccountResponse& from)
+ResolveAccountResponse::ResolveAccountResponse(const ResolveAccountResponse& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountResponse)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ResolveAccountResponse)
 }
 
-void GetAccountResponse::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
+void ResolveAccountResponse::SharedCtor() {
   _cached_size_ = 0;
-  blob_ = NULL;
   id_ = NULL;
-  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  parental_control_info_ = NULL;
-  cais_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-GetAccountResponse::~GetAccountResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountResponse)
+ResolveAccountResponse::~ResolveAccountResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ResolveAccountResponse)
   SharedDtor();
 }
 
-void GetAccountResponse::SharedDtor() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete full_name_;
-  }
-  if (cais_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete cais_id_;
-  }
+void ResolveAccountResponse::SharedDtor() {
   if (this != default_instance_) {
-    delete blob_;
     delete id_;
-    delete parental_control_info_;
   }
 }
 
-void GetAccountResponse::SetCachedSize(int size) const {
+void ResolveAccountResponse::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* GetAccountResponse::descriptor() {
+const ::google::protobuf::Descriptor* ResolveAccountResponse::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return GetAccountResponse_descriptor_;
+  return ResolveAccountResponse_descriptor_;
 }
 
-const GetAccountResponse& GetAccountResponse::default_instance() {
+const ResolveAccountResponse& ResolveAccountResponse::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
   return *default_instance_;
 }
 
-GetAccountResponse* GetAccountResponse::default_instance_ = NULL;
+ResolveAccountResponse* ResolveAccountResponse::default_instance_ = NULL;
 
-GetAccountResponse* GetAccountResponse::New() const {
-  return new GetAccountResponse;
+ResolveAccountResponse* ResolveAccountResponse::New() const {
+  return new ResolveAccountResponse;
 }
 
-void GetAccountResponse::Clear() {
-  if (_has_bits_[0 / 32] & 219) {
-    if (has_blob()) {
-      if (blob_ != NULL) blob_->::bgs::protocol::account::v1::AccountBlob::Clear();
-    }
-    if (has_id()) {
-      if (id_ != NULL) id_->::bgs::protocol::account::v1::AccountId::Clear();
-    }
-    if (has_battle_tag()) {
-      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        battle_tag_->clear();
-      }
-    }
-    if (has_full_name()) {
-      if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        full_name_->clear();
-      }
-    }
-    if (has_parental_control_info()) {
-      if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
-    }
-    if (has_cais_id()) {
-      if (cais_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        cais_id_->clear();
-      }
-    }
+void ResolveAccountResponse::Clear() {
+  if (has_id()) {
+    if (id_ != NULL) id_->::bgs::protocol::account::v1::AccountId::Clear();
   }
-  email_.Clear();
-  links_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool GetAccountResponse::MergePartialFromCodedStream(
+bool ResolveAccountResponse::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountResponse)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ResolveAccountResponse)
   for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.account.v1.AccountBlob blob = 11;
-      case 11: {
-        if (tag == 90) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_blob()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(98)) goto parse_id;
-        break;
-      }
-
       // optional .bgs.protocol.account.v1.AccountId id = 12;
       case 12: {
         if (tag == 98) {
-         parse_id:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, mutable_id()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(106)) goto parse_email;
-        break;
-      }
-
-      // repeated string email = 13;
-      case 13: {
-        if (tag == 106) {
-         parse_email:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->add_email()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->email(this->email_size() - 1).data(),
-            this->email(this->email_size() - 1).length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "email");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(106)) goto parse_email;
-        if (input->ExpectTag(114)) goto parse_battle_tag;
-        break;
-      }
-
-      // optional string battle_tag = 14;
-      case 14: {
-        if (tag == 114) {
-         parse_battle_tag:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_battle_tag()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->battle_tag().data(), this->battle_tag().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "battle_tag");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(122)) goto parse_full_name;
-        break;
-      }
-
-      // optional string full_name = 15;
-      case 15: {
-        if (tag == 122) {
-         parse_full_name:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_full_name()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->full_name().data(), this->full_name().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "full_name");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(130)) goto parse_links;
-        break;
-      }
-
-      // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
-      case 16: {
-        if (tag == 130) {
-         parse_links:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_links()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(130)) goto parse_links;
-        if (input->ExpectTag(138)) goto parse_parental_control_info;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
-      case 17: {
-        if (tag == 138) {
-         parse_parental_control_info:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_parental_control_info()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(146)) goto parse_cais_id;
-        break;
-      }
-
-      // optional string cais_id = 18;
-      case 18: {
-        if (tag == 146) {
-         parse_cais_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_cais_id()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->cais_id().data(), this->cais_id().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "cais_id");
-        } else {
-          goto handle_unusual;
-        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -2127,98 +1284,33 @@ bool GetAccountResponse::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetAccountResponse)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.ResolveAccountResponse)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountResponse)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ResolveAccountResponse)
   return false;
 #undef DO_
 }
 
-void GetAccountResponse::SerializeWithCachedSizes(
+void ResolveAccountResponse::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountResponse)
-  // optional .bgs.protocol.account.v1.AccountBlob blob = 11;
-  if (has_blob()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      11, this->blob(), output);
-  }
-
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ResolveAccountResponse)
   // optional .bgs.protocol.account.v1.AccountId id = 12;
   if (has_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       12, this->id(), output);
   }
 
-  // repeated string email = 13;
-  for (int i = 0; i < this->email_size(); i++) {
-  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-    this->email(i).data(), this->email(i).length(),
-    ::google::protobuf::internal::WireFormat::SERIALIZE,
-    "email");
-    ::google::protobuf::internal::WireFormatLite::WriteString(
-      13, this->email(i), output);
-  }
-
-  // optional string battle_tag = 14;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      14, this->battle_tag(), output);
-  }
-
-  // optional string full_name = 15;
-  if (has_full_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->full_name().data(), this->full_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "full_name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      15, this->full_name(), output);
-  }
-
-  // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
-  for (int i = 0; i < this->links_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      16, this->links(i), output);
-  }
-
-  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
-  if (has_parental_control_info()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      17, this->parental_control_info(), output);
-  }
-
-  // optional string cais_id = 18;
-  if (has_cais_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->cais_id().data(), this->cais_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "cais_id");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      18, this->cais_id(), output);
-  }
-
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountResponse)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ResolveAccountResponse)
 }
 
-::google::protobuf::uint8* GetAccountResponse::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* ResolveAccountResponse::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountResponse)
-  // optional .bgs.protocol.account.v1.AccountBlob blob = 11;
-  if (has_blob()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        11, this->blob(), target);
-  }
-
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ResolveAccountResponse)
   // optional .bgs.protocol.account.v1.AccountId id = 12;
   if (has_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
@@ -2226,82 +1318,18 @@ void GetAccountResponse::SerializeWithCachedSizes(
         12, this->id(), target);
   }
 
-  // repeated string email = 13;
-  for (int i = 0; i < this->email_size(); i++) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->email(i).data(), this->email(i).length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "email");
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteStringToArray(13, this->email(i), target);
-  }
-
-  // optional string battle_tag = 14;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        14, this->battle_tag(), target);
-  }
-
-  // optional string full_name = 15;
-  if (has_full_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->full_name().data(), this->full_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "full_name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        15, this->full_name(), target);
-  }
-
-  // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
-  for (int i = 0; i < this->links_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        16, this->links(i), target);
-  }
-
-  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
-  if (has_parental_control_info()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        17, this->parental_control_info(), target);
-  }
-
-  // optional string cais_id = 18;
-  if (has_cais_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->cais_id().data(), this->cais_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "cais_id");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        18, this->cais_id(), target);
-  }
-
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountResponse)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ResolveAccountResponse)
   return target;
 }
 
-int GetAccountResponse::ByteSize() const {
+int ResolveAccountResponse::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.account.v1.AccountBlob blob = 11;
-    if (has_blob()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->blob());
-    }
-
     // optional .bgs.protocol.account.v1.AccountId id = 12;
     if (has_id()) {
       total_size += 1 +
@@ -2309,50 +1337,7 @@ int GetAccountResponse::ByteSize() const {
           this->id());
     }
 
-    // optional string battle_tag = 14;
-    if (has_battle_tag()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->battle_tag());
-    }
-
-    // optional string full_name = 15;
-    if (has_full_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->full_name());
-    }
-
-    // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
-    if (has_parental_control_info()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->parental_control_info());
-    }
-
-    // optional string cais_id = 18;
-    if (has_cais_id()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->cais_id());
-    }
-
-  }
-  // repeated string email = 13;
-  total_size += 1 * this->email_size();
-  for (int i = 0; i < this->email_size(); i++) {
-    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
-      this->email(i));
-  }
-
-  // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
-  total_size += 2 * this->links_size();
-  for (int i = 0; i < this->links_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->links(i));
   }
-
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -2364,10 +1349,10 @@ int GetAccountResponse::ByteSize() const {
   return total_size;
 }
 
-void GetAccountResponse::MergeFrom(const ::google::protobuf::Message& from) {
+void ResolveAccountResponse::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const GetAccountResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GetAccountResponse*>(
+  const ResolveAccountResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ResolveAccountResponse*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -2376,1937 +1361,50 @@ void GetAccountResponse::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void GetAccountResponse::MergeFrom(const GetAccountResponse& from) {
+void ResolveAccountResponse::MergeFrom(const ResolveAccountResponse& from) {
   GOOGLE_CHECK_NE(&from, this);
-  email_.MergeFrom(from.email_);
-  links_.MergeFrom(from.links_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_blob()) {
-      mutable_blob()->::bgs::protocol::account::v1::AccountBlob::MergeFrom(from.blob());
-    }
     if (from.has_id()) {
       mutable_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.id());
     }
-    if (from.has_battle_tag()) {
-      set_battle_tag(from.battle_tag());
-    }
-    if (from.has_full_name()) {
-      set_full_name(from.full_name());
-    }
-    if (from.has_parental_control_info()) {
-      mutable_parental_control_info()->::bgs::protocol::account::v1::ParentalControlInfo::MergeFrom(from.parental_control_info());
-    }
-    if (from.has_cais_id()) {
-      set_cais_id(from.cais_id());
-    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void GetAccountResponse::CopyFrom(const ::google::protobuf::Message& from) {
+void ResolveAccountResponse::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void GetAccountResponse::CopyFrom(const GetAccountResponse& from) {
+void ResolveAccountResponse::CopyFrom(const ResolveAccountResponse& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool GetAccountResponse::IsInitialized() const {
+bool ResolveAccountResponse::IsInitialized() const {
 
-  if (has_blob()) {
-    if (!this->blob().IsInitialized()) return false;
-  }
   if (has_id()) {
     if (!this->id().IsInitialized()) return false;
   }
-  if (!::google::protobuf::internal::AllAreInitialized(this->links())) return false;
   return true;
 }
 
-void GetAccountResponse::Swap(GetAccountResponse* other) {
+void ResolveAccountResponse::Swap(ResolveAccountResponse* other) {
   if (other != this) {
-    std::swap(blob_, other->blob_);
     std::swap(id_, other->id_);
-    email_.Swap(&other->email_);
-    std::swap(battle_tag_, other->battle_tag_);
-    std::swap(full_name_, other->full_name_);
-    links_.Swap(&other->links_);
-    std::swap(parental_control_info_, other->parental_control_info_);
-    std::swap(cais_id_, other->cais_id_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata GetAccountResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GetAccountResponse_descriptor_;
-  metadata.reflection = GetAccountResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int CreateGameAccountRequest::kAccountFieldNumber;
-const int CreateGameAccountRequest::kRegionFieldNumber;
-const int CreateGameAccountRequest::kProgramFieldNumber;
-const int CreateGameAccountRequest::kRealmPermissionsFieldNumber;
-const int CreateGameAccountRequest::kAccountRegionFieldNumber;
-const int CreateGameAccountRequest::kPlatformFieldNumber;
-#endif  // !_MSC_VER
-
-CreateGameAccountRequest::CreateGameAccountRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CreateGameAccountRequest)
-}
-
-void CreateGameAccountRequest::InitAsDefaultInstance() {
-  account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
-}
-
-CreateGameAccountRequest::CreateGameAccountRequest(const CreateGameAccountRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CreateGameAccountRequest)
-}
-
-void CreateGameAccountRequest::SharedCtor() {
-  _cached_size_ = 0;
-  account_ = NULL;
-  region_ = 0u;
-  program_ = 0u;
-  realm_permissions_ = 0u;
-  account_region_ = 0u;
-  platform_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-CreateGameAccountRequest::~CreateGameAccountRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CreateGameAccountRequest)
-  SharedDtor();
-}
-
-void CreateGameAccountRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete account_;
-  }
-}
-
-void CreateGameAccountRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* CreateGameAccountRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return CreateGameAccountRequest_descriptor_;
-}
-
-const CreateGameAccountRequest& CreateGameAccountRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-CreateGameAccountRequest* CreateGameAccountRequest::default_instance_ = NULL;
-
-CreateGameAccountRequest* CreateGameAccountRequest::New() const {
-  return new CreateGameAccountRequest;
-}
-
-void CreateGameAccountRequest::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<CreateGameAccountRequest*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 63) {
-    ZR_(region_, platform_);
-    if (has_account()) {
-      if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
-    }
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool CreateGameAccountRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CreateGameAccountRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.account.v1.AccountId account = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(16)) goto parse_region;
-        break;
-      }
-
-      // optional uint32 region = 2;
-      case 2: {
-        if (tag == 16) {
-         parse_region:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &region_)));
-          set_has_region();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(29)) goto parse_program;
-        break;
-      }
-
-      // optional fixed32 program = 3;
-      case 3: {
-        if (tag == 29) {
-         parse_program:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &program_)));
-          set_has_program();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(32)) goto parse_realm_permissions;
-        break;
-      }
-
-      // optional uint32 realm_permissions = 4 [default = 0];
-      case 4: {
-        if (tag == 32) {
-         parse_realm_permissions:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &realm_permissions_)));
-          set_has_realm_permissions();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(40)) goto parse_account_region;
-        break;
-      }
-
-      // optional uint32 account_region = 5;
-      case 5: {
-        if (tag == 40) {
-         parse_account_region:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &account_region_)));
-          set_has_account_region();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(53)) goto parse_platform;
-        break;
-      }
-
-      // optional fixed32 platform = 6;
-      case 6: {
-        if (tag == 53) {
-         parse_platform:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &platform_)));
-          set_has_platform();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CreateGameAccountRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CreateGameAccountRequest)
-  return false;
-#undef DO_
-}
-
-void CreateGameAccountRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CreateGameAccountRequest)
-  // optional .bgs.protocol.account.v1.AccountId account = 1;
-  if (has_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->account(), output);
-  }
-
-  // optional uint32 region = 2;
-  if (has_region()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output);
-  }
-
-  // optional fixed32 program = 3;
-  if (has_program()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->program(), output);
-  }
-
-  // optional uint32 realm_permissions = 4 [default = 0];
-  if (has_realm_permissions()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->realm_permissions(), output);
-  }
-
-  // optional uint32 account_region = 5;
-  if (has_account_region()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->account_region(), output);
-  }
-
-  // optional fixed32 platform = 6;
-  if (has_platform()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(6, this->platform(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CreateGameAccountRequest)
-}
-
-::google::protobuf::uint8* CreateGameAccountRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CreateGameAccountRequest)
-  // optional .bgs.protocol.account.v1.AccountId account = 1;
-  if (has_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->account(), target);
-  }
-
-  // optional uint32 region = 2;
-  if (has_region()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target);
-  }
-
-  // optional fixed32 program = 3;
-  if (has_program()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->program(), target);
-  }
-
-  // optional uint32 realm_permissions = 4 [default = 0];
-  if (has_realm_permissions()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->realm_permissions(), target);
-  }
-
-  // optional uint32 account_region = 5;
-  if (has_account_region()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->account_region(), target);
-  }
-
-  // optional fixed32 platform = 6;
-  if (has_platform()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(6, this->platform(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CreateGameAccountRequest)
-  return target;
-}
-
-int CreateGameAccountRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.account.v1.AccountId account = 1;
-    if (has_account()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->account());
-    }
-
-    // optional uint32 region = 2;
-    if (has_region()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->region());
-    }
-
-    // optional fixed32 program = 3;
-    if (has_program()) {
-      total_size += 1 + 4;
-    }
-
-    // optional uint32 realm_permissions = 4 [default = 0];
-    if (has_realm_permissions()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->realm_permissions());
-    }
-
-    // optional uint32 account_region = 5;
-    if (has_account_region()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->account_region());
-    }
-
-    // optional fixed32 platform = 6;
-    if (has_platform()) {
-      total_size += 1 + 4;
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void CreateGameAccountRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const CreateGameAccountRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const CreateGameAccountRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void CreateGameAccountRequest::MergeFrom(const CreateGameAccountRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_account()) {
-      mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account());
-    }
-    if (from.has_region()) {
-      set_region(from.region());
-    }
-    if (from.has_program()) {
-      set_program(from.program());
-    }
-    if (from.has_realm_permissions()) {
-      set_realm_permissions(from.realm_permissions());
-    }
-    if (from.has_account_region()) {
-      set_account_region(from.account_region());
-    }
-    if (from.has_platform()) {
-      set_platform(from.platform());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void CreateGameAccountRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void CreateGameAccountRequest::CopyFrom(const CreateGameAccountRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool CreateGameAccountRequest::IsInitialized() const {
-
-  if (has_account()) {
-    if (!this->account().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void CreateGameAccountRequest::Swap(CreateGameAccountRequest* other) {
-  if (other != this) {
-    std::swap(account_, other->account_);
-    std::swap(region_, other->region_);
-    std::swap(program_, other->program_);
-    std::swap(realm_permissions_, other->realm_permissions_);
-    std::swap(account_region_, other->account_region_);
-    std::swap(platform_, other->platform_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata CreateGameAccountRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = CreateGameAccountRequest_descriptor_;
-  metadata.reflection = CreateGameAccountRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int CreateGameAccountResponse::kGameAccountFieldNumber;
-#endif  // !_MSC_VER
-
-CreateGameAccountResponse::CreateGameAccountResponse()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CreateGameAccountResponse)
-}
-
-void CreateGameAccountResponse::InitAsDefaultInstance() {
-  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
-}
-
-CreateGameAccountResponse::CreateGameAccountResponse(const CreateGameAccountResponse& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CreateGameAccountResponse)
-}
-
-void CreateGameAccountResponse::SharedCtor() {
-  _cached_size_ = 0;
-  game_account_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-CreateGameAccountResponse::~CreateGameAccountResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CreateGameAccountResponse)
-  SharedDtor();
-}
-
-void CreateGameAccountResponse::SharedDtor() {
-  if (this != default_instance_) {
-    delete game_account_;
-  }
-}
-
-void CreateGameAccountResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* CreateGameAccountResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return CreateGameAccountResponse_descriptor_;
-}
-
-const CreateGameAccountResponse& CreateGameAccountResponse::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-CreateGameAccountResponse* CreateGameAccountResponse::default_instance_ = NULL;
-
-CreateGameAccountResponse* CreateGameAccountResponse::New() const {
-  return new CreateGameAccountResponse;
-}
-
-void CreateGameAccountResponse::Clear() {
-  if (has_game_account()) {
-    if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool CreateGameAccountResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CreateGameAccountResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CreateGameAccountResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CreateGameAccountResponse)
-  return false;
-#undef DO_
-}
-
-void CreateGameAccountResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CreateGameAccountResponse)
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->game_account(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CreateGameAccountResponse)
-}
-
-::google::protobuf::uint8* CreateGameAccountResponse::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CreateGameAccountResponse)
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->game_account(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CreateGameAccountResponse)
-  return target;
-}
-
-int CreateGameAccountResponse::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-    if (has_game_account()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void CreateGameAccountResponse::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const CreateGameAccountResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const CreateGameAccountResponse*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void CreateGameAccountResponse::MergeFrom(const CreateGameAccountResponse& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_game_account()) {
-      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void CreateGameAccountResponse::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void CreateGameAccountResponse::CopyFrom(const CreateGameAccountResponse& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool CreateGameAccountResponse::IsInitialized() const {
-
-  if (has_game_account()) {
-    if (!this->game_account().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void CreateGameAccountResponse::Swap(CreateGameAccountResponse* other) {
-  if (other != this) {
-    std::swap(game_account_, other->game_account_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata CreateGameAccountResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = CreateGameAccountResponse_descriptor_;
-  metadata.reflection = CreateGameAccountResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int CacheExpireRequest::kAccountFieldNumber;
-const int CacheExpireRequest::kGameAccountFieldNumber;
-const int CacheExpireRequest::kEmailFieldNumber;
-#endif  // !_MSC_VER
-
-CacheExpireRequest::CacheExpireRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CacheExpireRequest)
-}
-
-void CacheExpireRequest::InitAsDefaultInstance() {
-}
-
-CacheExpireRequest::CacheExpireRequest(const CacheExpireRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CacheExpireRequest)
-}
-
-void CacheExpireRequest::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-CacheExpireRequest::~CacheExpireRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CacheExpireRequest)
-  SharedDtor();
-}
-
-void CacheExpireRequest::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void CacheExpireRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* CacheExpireRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return CacheExpireRequest_descriptor_;
-}
-
-const CacheExpireRequest& CacheExpireRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-CacheExpireRequest* CacheExpireRequest::default_instance_ = NULL;
-
-CacheExpireRequest* CacheExpireRequest::New() const {
-  return new CacheExpireRequest;
-}
-
-void CacheExpireRequest::Clear() {
-  account_.Clear();
-  game_account_.Clear();
-  email_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool CacheExpireRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CacheExpireRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // repeated .bgs.protocol.account.v1.AccountId account = 1;
-      case 1: {
-        if (tag == 10) {
-         parse_account:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(10)) goto parse_account;
-        if (input->ExpectTag(18)) goto parse_game_account;
-        break;
-      }
-
-      // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_game_account:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_game_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_game_account;
-        if (input->ExpectTag(26)) goto parse_email;
-        break;
-      }
-
-      // repeated string email = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_email:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->add_email()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->email(this->email_size() - 1).data(),
-            this->email(this->email_size() - 1).length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "email");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_email;
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CacheExpireRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CacheExpireRequest)
-  return false;
-#undef DO_
-}
-
-void CacheExpireRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CacheExpireRequest)
-  // repeated .bgs.protocol.account.v1.AccountId account = 1;
-  for (int i = 0; i < this->account_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->account(i), output);
-  }
-
-  // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
-  for (int i = 0; i < this->game_account_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->game_account(i), output);
-  }
-
-  // repeated string email = 3;
-  for (int i = 0; i < this->email_size(); i++) {
-  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-    this->email(i).data(), this->email(i).length(),
-    ::google::protobuf::internal::WireFormat::SERIALIZE,
-    "email");
-    ::google::protobuf::internal::WireFormatLite::WriteString(
-      3, this->email(i), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CacheExpireRequest)
-}
-
-::google::protobuf::uint8* CacheExpireRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CacheExpireRequest)
-  // repeated .bgs.protocol.account.v1.AccountId account = 1;
-  for (int i = 0; i < this->account_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->account(i), target);
-  }
-
-  // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
-  for (int i = 0; i < this->game_account_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->game_account(i), target);
-  }
-
-  // repeated string email = 3;
-  for (int i = 0; i < this->email_size(); i++) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->email(i).data(), this->email(i).length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "email");
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteStringToArray(3, this->email(i), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CacheExpireRequest)
-  return target;
-}
-
-int CacheExpireRequest::ByteSize() const {
-  int total_size = 0;
-
-  // repeated .bgs.protocol.account.v1.AccountId account = 1;
-  total_size += 1 * this->account_size();
-  for (int i = 0; i < this->account_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->account(i));
-  }
-
-  // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
-  total_size += 1 * this->game_account_size();
-  for (int i = 0; i < this->game_account_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->game_account(i));
-  }
-
-  // repeated string email = 3;
-  total_size += 1 * this->email_size();
-  for (int i = 0; i < this->email_size(); i++) {
-    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
-      this->email(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void CacheExpireRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const CacheExpireRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const CacheExpireRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void CacheExpireRequest::MergeFrom(const CacheExpireRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  account_.MergeFrom(from.account_);
-  game_account_.MergeFrom(from.game_account_);
-  email_.MergeFrom(from.email_);
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void CacheExpireRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void CacheExpireRequest::CopyFrom(const CacheExpireRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool CacheExpireRequest::IsInitialized() const {
-
-  if (!::google::protobuf::internal::AllAreInitialized(this->account())) return false;
-  if (!::google::protobuf::internal::AllAreInitialized(this->game_account())) return false;
-  return true;
-}
-
-void CacheExpireRequest::Swap(CacheExpireRequest* other) {
-  if (other != this) {
-    account_.Swap(&other->account_);
-    game_account_.Swap(&other->game_account_);
-    email_.Swap(&other->email_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata CacheExpireRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = CacheExpireRequest_descriptor_;
-  metadata.reflection = CacheExpireRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int CredentialUpdateRequest::kAccountFieldNumber;
-const int CredentialUpdateRequest::kOldCredentialsFieldNumber;
-const int CredentialUpdateRequest::kNewCredentialsFieldNumber;
-const int CredentialUpdateRequest::kRegionFieldNumber;
-#endif  // !_MSC_VER
-
-CredentialUpdateRequest::CredentialUpdateRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CredentialUpdateRequest)
-}
-
-void CredentialUpdateRequest::InitAsDefaultInstance() {
-  account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
-}
-
-CredentialUpdateRequest::CredentialUpdateRequest(const CredentialUpdateRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CredentialUpdateRequest)
-}
-
-void CredentialUpdateRequest::SharedCtor() {
-  _cached_size_ = 0;
-  account_ = NULL;
-  region_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-CredentialUpdateRequest::~CredentialUpdateRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CredentialUpdateRequest)
-  SharedDtor();
-}
-
-void CredentialUpdateRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete account_;
-  }
-}
-
-void CredentialUpdateRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* CredentialUpdateRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return CredentialUpdateRequest_descriptor_;
-}
-
-const CredentialUpdateRequest& CredentialUpdateRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-CredentialUpdateRequest* CredentialUpdateRequest::default_instance_ = NULL;
-
-CredentialUpdateRequest* CredentialUpdateRequest::New() const {
-  return new CredentialUpdateRequest;
-}
-
-void CredentialUpdateRequest::Clear() {
-  if (_has_bits_[0 / 32] & 9) {
-    if (has_account()) {
-      if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
-    }
-    region_ = 0u;
-  }
-  old_credentials_.Clear();
-  new_credentials_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool CredentialUpdateRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CredentialUpdateRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required .bgs.protocol.account.v1.AccountId account = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_old_credentials;
-        break;
-      }
-
-      // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_old_credentials:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_old_credentials()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_old_credentials;
-        if (input->ExpectTag(26)) goto parse_new_credentials;
-        break;
-      }
-
-      // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_new_credentials:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_new_credentials()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_new_credentials;
-        if (input->ExpectTag(32)) goto parse_region;
-        break;
-      }
-
-      // optional uint32 region = 4;
-      case 4: {
-        if (tag == 32) {
-         parse_region:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &region_)));
-          set_has_region();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CredentialUpdateRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CredentialUpdateRequest)
-  return false;
-#undef DO_
-}
-
-void CredentialUpdateRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CredentialUpdateRequest)
-  // required .bgs.protocol.account.v1.AccountId account = 1;
-  if (has_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->account(), output);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
-  for (int i = 0; i < this->old_credentials_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->old_credentials(i), output);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
-  for (int i = 0; i < this->new_credentials_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      3, this->new_credentials(i), output);
-  }
-
-  // optional uint32 region = 4;
-  if (has_region()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->region(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CredentialUpdateRequest)
-}
-
-::google::protobuf::uint8* CredentialUpdateRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CredentialUpdateRequest)
-  // required .bgs.protocol.account.v1.AccountId account = 1;
-  if (has_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->account(), target);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
-  for (int i = 0; i < this->old_credentials_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->old_credentials(i), target);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
-  for (int i = 0; i < this->new_credentials_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        3, this->new_credentials(i), target);
-  }
-
-  // optional uint32 region = 4;
-  if (has_region()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->region(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CredentialUpdateRequest)
-  return target;
-}
-
-int CredentialUpdateRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required .bgs.protocol.account.v1.AccountId account = 1;
-    if (has_account()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->account());
-    }
-
-    // optional uint32 region = 4;
-    if (has_region()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->region());
-    }
-
-  }
-  // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
-  total_size += 1 * this->old_credentials_size();
-  for (int i = 0; i < this->old_credentials_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->old_credentials(i));
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
-  total_size += 1 * this->new_credentials_size();
-  for (int i = 0; i < this->new_credentials_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->new_credentials(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void CredentialUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const CredentialUpdateRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const CredentialUpdateRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void CredentialUpdateRequest::MergeFrom(const CredentialUpdateRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  old_credentials_.MergeFrom(from.old_credentials_);
-  new_credentials_.MergeFrom(from.new_credentials_);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_account()) {
-      mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account());
-    }
-    if (from.has_region()) {
-      set_region(from.region());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void CredentialUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void CredentialUpdateRequest::CopyFrom(const CredentialUpdateRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool CredentialUpdateRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
-  if (has_account()) {
-    if (!this->account().IsInitialized()) return false;
-  }
-  if (!::google::protobuf::internal::AllAreInitialized(this->old_credentials())) return false;
-  if (!::google::protobuf::internal::AllAreInitialized(this->new_credentials())) return false;
-  return true;
-}
-
-void CredentialUpdateRequest::Swap(CredentialUpdateRequest* other) {
-  if (other != this) {
-    std::swap(account_, other->account_);
-    old_credentials_.Swap(&other->old_credentials_);
-    new_credentials_.Swap(&other->new_credentials_);
-    std::swap(region_, other->region_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata CredentialUpdateRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = CredentialUpdateRequest_descriptor_;
-  metadata.reflection = CredentialUpdateRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-#endif  // !_MSC_VER
-
-CredentialUpdateResponse::CredentialUpdateResponse()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CredentialUpdateResponse)
-}
-
-void CredentialUpdateResponse::InitAsDefaultInstance() {
-}
-
-CredentialUpdateResponse::CredentialUpdateResponse(const CredentialUpdateResponse& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CredentialUpdateResponse)
-}
-
-void CredentialUpdateResponse::SharedCtor() {
-  _cached_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-CredentialUpdateResponse::~CredentialUpdateResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CredentialUpdateResponse)
-  SharedDtor();
-}
-
-void CredentialUpdateResponse::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void CredentialUpdateResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* CredentialUpdateResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return CredentialUpdateResponse_descriptor_;
-}
-
-const CredentialUpdateResponse& CredentialUpdateResponse::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-CredentialUpdateResponse* CredentialUpdateResponse::default_instance_ = NULL;
-
-CredentialUpdateResponse* CredentialUpdateResponse::New() const {
-  return new CredentialUpdateResponse;
-}
-
-void CredentialUpdateResponse::Clear() {
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool CredentialUpdateResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CredentialUpdateResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-  handle_unusual:
-    if (tag == 0 ||
-        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-      goto success;
-    }
-    DO_(::google::protobuf::internal::WireFormat::SkipField(
-          input, tag, mutable_unknown_fields()));
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CredentialUpdateResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CredentialUpdateResponse)
-  return false;
-#undef DO_
-}
-
-void CredentialUpdateResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CredentialUpdateResponse)
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CredentialUpdateResponse)
-}
-
-::google::protobuf::uint8* CredentialUpdateResponse::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CredentialUpdateResponse)
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CredentialUpdateResponse)
-  return target;
-}
-
-int CredentialUpdateResponse::ByteSize() const {
-  int total_size = 0;
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void CredentialUpdateResponse::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const CredentialUpdateResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const CredentialUpdateResponse*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void CredentialUpdateResponse::MergeFrom(const CredentialUpdateResponse& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void CredentialUpdateResponse::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void CredentialUpdateResponse::CopyFrom(const CredentialUpdateResponse& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool CredentialUpdateResponse::IsInitialized() const {
-
-  return true;
-}
-
-void CredentialUpdateResponse::Swap(CredentialUpdateResponse* other) {
-  if (other != this) {
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata CredentialUpdateResponse::GetMetadata() const {
+::google::protobuf::Metadata ResolveAccountResponse::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = CredentialUpdateResponse_descriptor_;
-  metadata.reflection = CredentialUpdateResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int AccountFlagUpdateRequest::kAccountFieldNumber;
-const int AccountFlagUpdateRequest::kRegionFieldNumber;
-const int AccountFlagUpdateRequest::kFlagFieldNumber;
-const int AccountFlagUpdateRequest::kActiveFieldNumber;
-#endif  // !_MSC_VER
-
-AccountFlagUpdateRequest::AccountFlagUpdateRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-}
-
-void AccountFlagUpdateRequest::InitAsDefaultInstance() {
-  account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
-}
-
-AccountFlagUpdateRequest::AccountFlagUpdateRequest(const AccountFlagUpdateRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-}
-
-void AccountFlagUpdateRequest::SharedCtor() {
-  _cached_size_ = 0;
-  account_ = NULL;
-  region_ = 0u;
-  flag_ = GOOGLE_ULONGLONG(0);
-  active_ = false;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-AccountFlagUpdateRequest::~AccountFlagUpdateRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-  SharedDtor();
-}
-
-void AccountFlagUpdateRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete account_;
-  }
-}
-
-void AccountFlagUpdateRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* AccountFlagUpdateRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return AccountFlagUpdateRequest_descriptor_;
-}
-
-const AccountFlagUpdateRequest& AccountFlagUpdateRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-AccountFlagUpdateRequest* AccountFlagUpdateRequest::default_instance_ = NULL;
-
-AccountFlagUpdateRequest* AccountFlagUpdateRequest::New() const {
-  return new AccountFlagUpdateRequest;
-}
-
-void AccountFlagUpdateRequest::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<AccountFlagUpdateRequest*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 15) {
-    ZR_(flag_, active_);
-    if (has_account()) {
-      if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
-    }
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool AccountFlagUpdateRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.account.v1.AccountId account = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(16)) goto parse_region;
-        break;
-      }
-
-      // optional uint32 region = 2;
-      case 2: {
-        if (tag == 16) {
-         parse_region:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &region_)));
-          set_has_region();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_flag;
-        break;
-      }
-
-      // optional uint64 flag = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_flag:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &flag_)));
-          set_has_flag();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(32)) goto parse_active;
-        break;
-      }
-
-      // optional bool active = 4;
-      case 4: {
-        if (tag == 32) {
-         parse_active:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &active_)));
-          set_has_active();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-  return false;
-#undef DO_
-}
-
-void AccountFlagUpdateRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-  // optional .bgs.protocol.account.v1.AccountId account = 1;
-  if (has_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->account(), output);
-  }
-
-  // optional uint32 region = 2;
-  if (has_region()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output);
-  }
-
-  // optional uint64 flag = 3;
-  if (has_flag()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->flag(), output);
-  }
-
-  // optional bool active = 4;
-  if (has_active()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->active(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-}
-
-::google::protobuf::uint8* AccountFlagUpdateRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-  // optional .bgs.protocol.account.v1.AccountId account = 1;
-  if (has_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->account(), target);
-  }
-
-  // optional uint32 region = 2;
-  if (has_region()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target);
-  }
-
-  // optional uint64 flag = 3;
-  if (has_flag()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->flag(), target);
-  }
-
-  // optional bool active = 4;
-  if (has_active()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->active(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountFlagUpdateRequest)
-  return target;
-}
-
-int AccountFlagUpdateRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.account.v1.AccountId account = 1;
-    if (has_account()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->account());
-    }
-
-    // optional uint32 region = 2;
-    if (has_region()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->region());
-    }
-
-    // optional uint64 flag = 3;
-    if (has_flag()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->flag());
-    }
-
-    // optional bool active = 4;
-    if (has_active()) {
-      total_size += 1 + 1;
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void AccountFlagUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const AccountFlagUpdateRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AccountFlagUpdateRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void AccountFlagUpdateRequest::MergeFrom(const AccountFlagUpdateRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_account()) {
-      mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account());
-    }
-    if (from.has_region()) {
-      set_region(from.region());
-    }
-    if (from.has_flag()) {
-      set_flag(from.flag());
-    }
-    if (from.has_active()) {
-      set_active(from.active());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void AccountFlagUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void AccountFlagUpdateRequest::CopyFrom(const AccountFlagUpdateRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AccountFlagUpdateRequest::IsInitialized() const {
-
-  if (has_account()) {
-    if (!this->account().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void AccountFlagUpdateRequest::Swap(AccountFlagUpdateRequest* other) {
-  if (other != this) {
-    std::swap(account_, other->account_);
-    std::swap(region_, other->region_);
-    std::swap(flag_, other->flag_);
-    std::swap(active_, other->active_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata AccountFlagUpdateRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AccountFlagUpdateRequest_descriptor_;
-  metadata.reflection = AccountFlagUpdateRequest_reflection_;
+  metadata.descriptor = ResolveAccountResponse_descriptor_;
+  metadata.reflection = ResolveAccountResponse_reflection_;
   return metadata;
 }
 
@@ -5359,511 +2457,6 @@ void IsIgrAddressRequest::Swap(IsIgrAddressRequest* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int AccountServiceRegion::kIdFieldNumber;
-const int AccountServiceRegion::kShardFieldNumber;
-#endif  // !_MSC_VER
-
-AccountServiceRegion::AccountServiceRegion()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountServiceRegion)
-}
-
-void AccountServiceRegion::InitAsDefaultInstance() {
-}
-
-AccountServiceRegion::AccountServiceRegion(const AccountServiceRegion& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountServiceRegion)
-}
-
-void AccountServiceRegion::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  id_ = 0u;
-  shard_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-AccountServiceRegion::~AccountServiceRegion() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountServiceRegion)
-  SharedDtor();
-}
-
-void AccountServiceRegion::SharedDtor() {
-  if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete shard_;
-  }
-  if (this != default_instance_) {
-  }
-}
-
-void AccountServiceRegion::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* AccountServiceRegion::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return AccountServiceRegion_descriptor_;
-}
-
-const AccountServiceRegion& AccountServiceRegion::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-AccountServiceRegion* AccountServiceRegion::default_instance_ = NULL;
-
-AccountServiceRegion* AccountServiceRegion::New() const {
-  return new AccountServiceRegion;
-}
-
-void AccountServiceRegion::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
-    id_ = 0u;
-    if (has_shard()) {
-      if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        shard_->clear();
-      }
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool AccountServiceRegion::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountServiceRegion)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required uint32 id = 1;
-      case 1: {
-        if (tag == 8) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &id_)));
-          set_has_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_shard;
-        break;
-      }
-
-      // required string shard = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_shard:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_shard()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->shard().data(), this->shard().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "shard");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountServiceRegion)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountServiceRegion)
-  return false;
-#undef DO_
-}
-
-void AccountServiceRegion::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountServiceRegion)
-  // required uint32 id = 1;
-  if (has_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
-  }
-
-  // required string shard = 2;
-  if (has_shard()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->shard().data(), this->shard().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "shard");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->shard(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountServiceRegion)
-}
-
-::google::protobuf::uint8* AccountServiceRegion::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountServiceRegion)
-  // required uint32 id = 1;
-  if (has_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
-  }
-
-  // required string shard = 2;
-  if (has_shard()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->shard().data(), this->shard().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "shard");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->shard(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountServiceRegion)
-  return target;
-}
-
-int AccountServiceRegion::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required uint32 id = 1;
-    if (has_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->id());
-    }
-
-    // required string shard = 2;
-    if (has_shard()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->shard());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void AccountServiceRegion::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const AccountServiceRegion* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AccountServiceRegion*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void AccountServiceRegion::MergeFrom(const AccountServiceRegion& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_id()) {
-      set_id(from.id());
-    }
-    if (from.has_shard()) {
-      set_shard(from.shard());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void AccountServiceRegion::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void AccountServiceRegion::CopyFrom(const AccountServiceRegion& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AccountServiceRegion::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
-  return true;
-}
-
-void AccountServiceRegion::Swap(AccountServiceRegion* other) {
-  if (other != this) {
-    std::swap(id_, other->id_);
-    std::swap(shard_, other->shard_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata AccountServiceRegion::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AccountServiceRegion_descriptor_;
-  metadata.reflection = AccountServiceRegion_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int AccountServiceConfig::kRegionFieldNumber;
-#endif  // !_MSC_VER
-
-AccountServiceConfig::AccountServiceConfig()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountServiceConfig)
-}
-
-void AccountServiceConfig::InitAsDefaultInstance() {
-}
-
-AccountServiceConfig::AccountServiceConfig(const AccountServiceConfig& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountServiceConfig)
-}
-
-void AccountServiceConfig::SharedCtor() {
-  _cached_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-AccountServiceConfig::~AccountServiceConfig() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountServiceConfig)
-  SharedDtor();
-}
-
-void AccountServiceConfig::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void AccountServiceConfig::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* AccountServiceConfig::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return AccountServiceConfig_descriptor_;
-}
-
-const AccountServiceConfig& AccountServiceConfig::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-AccountServiceConfig* AccountServiceConfig::default_instance_ = NULL;
-
-AccountServiceConfig* AccountServiceConfig::New() const {
-  return new AccountServiceConfig;
-}
-
-void AccountServiceConfig::Clear() {
-  region_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool AccountServiceConfig::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountServiceConfig)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
-      case 1: {
-        if (tag == 10) {
-         parse_region:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_region()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(10)) goto parse_region;
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountServiceConfig)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountServiceConfig)
-  return false;
-#undef DO_
-}
-
-void AccountServiceConfig::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountServiceConfig)
-  // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
-  for (int i = 0; i < this->region_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->region(i), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountServiceConfig)
-}
-
-::google::protobuf::uint8* AccountServiceConfig::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountServiceConfig)
-  // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
-  for (int i = 0; i < this->region_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->region(i), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountServiceConfig)
-  return target;
-}
-
-int AccountServiceConfig::ByteSize() const {
-  int total_size = 0;
-
-  // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
-  total_size += 1 * this->region_size();
-  for (int i = 0; i < this->region_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->region(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void AccountServiceConfig::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const AccountServiceConfig* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AccountServiceConfig*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void AccountServiceConfig::MergeFrom(const AccountServiceConfig& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  region_.MergeFrom(from.region_);
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void AccountServiceConfig::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void AccountServiceConfig::CopyFrom(const AccountServiceConfig& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AccountServiceConfig::IsInitialized() const {
-
-  if (!::google::protobuf::internal::AllAreInitialized(this->region())) return false;
-  return true;
-}
-
-void AccountServiceConfig::Swap(AccountServiceConfig* other) {
-  if (other != this) {
-    region_.Swap(&other->region_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata AccountServiceConfig::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AccountServiceConfig_descriptor_;
-  metadata.reflection = AccountServiceConfig_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int GetAccountStateRequest::kEntityIdFieldNumber;
 const int GetAccountStateRequest::kProgramFieldNumber;
 const int GetAccountStateRequest::kRegionFieldNumber;
@@ -6551,6 +3144,479 @@ void GetAccountStateResponse::Swap(GetAccountStateResponse* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
+const int GetSignedAccountStateRequest::kAccountFieldNumber;
+#endif  // !_MSC_VER
+
+GetSignedAccountStateRequest::GetSignedAccountStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+}
+
+void GetSignedAccountStateRequest::InitAsDefaultInstance() {
+  account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+GetSignedAccountStateRequest::GetSignedAccountStateRequest(const GetSignedAccountStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+}
+
+void GetSignedAccountStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  account_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetSignedAccountStateRequest::~GetSignedAccountStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+  SharedDtor();
+}
+
+void GetSignedAccountStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_;
+  }
+}
+
+void GetSignedAccountStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetSignedAccountStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetSignedAccountStateRequest_descriptor_;
+}
+
+const GetSignedAccountStateRequest& GetSignedAccountStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetSignedAccountStateRequest* GetSignedAccountStateRequest::default_instance_ = NULL;
+
+GetSignedAccountStateRequest* GetSignedAccountStateRequest::New() const {
+  return new GetSignedAccountStateRequest;
+}
+
+void GetSignedAccountStateRequest::Clear() {
+  if (has_account()) {
+    if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetSignedAccountStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId account = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+  return false;
+#undef DO_
+}
+
+void GetSignedAccountStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+  // optional .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+}
+
+::google::protobuf::uint8* GetSignedAccountStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+  // optional .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetSignedAccountStateRequest)
+  return target;
+}
+
+int GetSignedAccountStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId account = 1;
+    if (has_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetSignedAccountStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetSignedAccountStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetSignedAccountStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetSignedAccountStateRequest::MergeFrom(const GetSignedAccountStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account()) {
+      mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetSignedAccountStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetSignedAccountStateRequest::CopyFrom(const GetSignedAccountStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetSignedAccountStateRequest::IsInitialized() const {
+
+  if (has_account()) {
+    if (!this->account().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetSignedAccountStateRequest::Swap(GetSignedAccountStateRequest* other) {
+  if (other != this) {
+    std::swap(account_, other->account_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetSignedAccountStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetSignedAccountStateRequest_descriptor_;
+  metadata.reflection = GetSignedAccountStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetSignedAccountStateResponse::kTokenFieldNumber;
+#endif  // !_MSC_VER
+
+GetSignedAccountStateResponse::GetSignedAccountStateResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+}
+
+void GetSignedAccountStateResponse::InitAsDefaultInstance() {
+}
+
+GetSignedAccountStateResponse::GetSignedAccountStateResponse(const GetSignedAccountStateResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+}
+
+void GetSignedAccountStateResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetSignedAccountStateResponse::~GetSignedAccountStateResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+  SharedDtor();
+}
+
+void GetSignedAccountStateResponse::SharedDtor() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void GetSignedAccountStateResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetSignedAccountStateResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetSignedAccountStateResponse_descriptor_;
+}
+
+const GetSignedAccountStateResponse& GetSignedAccountStateResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetSignedAccountStateResponse* GetSignedAccountStateResponse::default_instance_ = NULL;
+
+GetSignedAccountStateResponse* GetSignedAccountStateResponse::New() const {
+  return new GetSignedAccountStateResponse;
+}
+
+void GetSignedAccountStateResponse::Clear() {
+  if (has_token()) {
+    if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      token_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetSignedAccountStateResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string token = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_token()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->token().data(), this->token().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "token");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+  return false;
+#undef DO_
+}
+
+void GetSignedAccountStateResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+  // optional string token = 1;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->token().data(), this->token().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "token");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->token(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+}
+
+::google::protobuf::uint8* GetSignedAccountStateResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+  // optional string token = 1;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->token().data(), this->token().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "token");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->token(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetSignedAccountStateResponse)
+  return target;
+}
+
+int GetSignedAccountStateResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string token = 1;
+    if (has_token()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->token());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetSignedAccountStateResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetSignedAccountStateResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetSignedAccountStateResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetSignedAccountStateResponse::MergeFrom(const GetSignedAccountStateResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_token()) {
+      set_token(from.token());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetSignedAccountStateResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetSignedAccountStateResponse::CopyFrom(const GetSignedAccountStateResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetSignedAccountStateResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetSignedAccountStateResponse::Swap(GetSignedAccountStateResponse* other) {
+  if (other != this) {
+    std::swap(token_, other->token_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetSignedAccountStateResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetSignedAccountStateResponse_descriptor_;
+  metadata.reflection = GetSignedAccountStateResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
 const int GetGameAccountStateRequest::kAccountIdFieldNumber;
 const int GetGameAccountStateRequest::kGameAccountIdFieldNumber;
 const int GetGameAccountStateRequest::kOptionsFieldNumber;
@@ -9264,236 +6330,6 @@ void GetCAISInfoResponse::Swap(GetCAISInfoResponse* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int ForwardCacheExpireRequest::kEntityIdFieldNumber;
-#endif  // !_MSC_VER
-
-ForwardCacheExpireRequest::ForwardCacheExpireRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-}
-
-void ForwardCacheExpireRequest::InitAsDefaultInstance() {
-  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-}
-
-ForwardCacheExpireRequest::ForwardCacheExpireRequest(const ForwardCacheExpireRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-}
-
-void ForwardCacheExpireRequest::SharedCtor() {
-  _cached_size_ = 0;
-  entity_id_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ForwardCacheExpireRequest::~ForwardCacheExpireRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-  SharedDtor();
-}
-
-void ForwardCacheExpireRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete entity_id_;
-  }
-}
-
-void ForwardCacheExpireRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ForwardCacheExpireRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ForwardCacheExpireRequest_descriptor_;
-}
-
-const ForwardCacheExpireRequest& ForwardCacheExpireRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-ForwardCacheExpireRequest* ForwardCacheExpireRequest::default_instance_ = NULL;
-
-ForwardCacheExpireRequest* ForwardCacheExpireRequest::New() const {
-  return new ForwardCacheExpireRequest;
-}
-
-void ForwardCacheExpireRequest::Clear() {
-  if (has_entity_id()) {
-    if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool ForwardCacheExpireRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId entity_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_entity_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-  return false;
-#undef DO_
-}
-
-void ForwardCacheExpireRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-  // optional .bgs.protocol.EntityId entity_id = 1;
-  if (has_entity_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->entity_id(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-}
-
-::google::protobuf::uint8* ForwardCacheExpireRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-  // optional .bgs.protocol.EntityId entity_id = 1;
-  if (has_entity_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->entity_id(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ForwardCacheExpireRequest)
-  return target;
-}
-
-int ForwardCacheExpireRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId entity_id = 1;
-    if (has_entity_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->entity_id());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ForwardCacheExpireRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ForwardCacheExpireRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ForwardCacheExpireRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ForwardCacheExpireRequest::MergeFrom(const ForwardCacheExpireRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_entity_id()) {
-      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ForwardCacheExpireRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ForwardCacheExpireRequest::CopyFrom(const ForwardCacheExpireRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ForwardCacheExpireRequest::IsInitialized() const {
-
-  if (has_entity_id()) {
-    if (!this->entity_id().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void ForwardCacheExpireRequest::Swap(ForwardCacheExpireRequest* other) {
-  if (other != this) {
-    std::swap(entity_id_, other->entity_id_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ForwardCacheExpireRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ForwardCacheExpireRequest_descriptor_;
-  metadata.reflection = ForwardCacheExpireRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int GetAuthorizedDataRequest::kEntityIdFieldNumber;
 const int GetAuthorizedDataRequest::kTagFieldNumber;
 const int GetAuthorizedDataRequest::kPrivilegedNetworkFieldNumber;
@@ -10498,735 +7334,6 @@ void UpdateParentalControlsAndCAISRequest::Swap(UpdateParentalControlsAndCAISReq
 // ===================================================================
 
 #ifndef _MSC_VER
-const int QueueDeductRecordRequest::kDeductRecordFieldNumber;
-#endif  // !_MSC_VER
-
-QueueDeductRecordRequest::QueueDeductRecordRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.QueueDeductRecordRequest)
-}
-
-void QueueDeductRecordRequest::InitAsDefaultInstance() {
-  deduct_record_ = const_cast< ::bgs::protocol::account::v1::DeductRecord*>(&::bgs::protocol::account::v1::DeductRecord::default_instance());
-}
-
-QueueDeductRecordRequest::QueueDeductRecordRequest(const QueueDeductRecordRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.QueueDeductRecordRequest)
-}
-
-void QueueDeductRecordRequest::SharedCtor() {
-  _cached_size_ = 0;
-  deduct_record_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-QueueDeductRecordRequest::~QueueDeductRecordRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.QueueDeductRecordRequest)
-  SharedDtor();
-}
-
-void QueueDeductRecordRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete deduct_record_;
-  }
-}
-
-void QueueDeductRecordRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* QueueDeductRecordRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return QueueDeductRecordRequest_descriptor_;
-}
-
-const QueueDeductRecordRequest& QueueDeductRecordRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-QueueDeductRecordRequest* QueueDeductRecordRequest::default_instance_ = NULL;
-
-QueueDeductRecordRequest* QueueDeductRecordRequest::New() const {
-  return new QueueDeductRecordRequest;
-}
-
-void QueueDeductRecordRequest::Clear() {
-  if (has_deduct_record()) {
-    if (deduct_record_ != NULL) deduct_record_->::bgs::protocol::account::v1::DeductRecord::Clear();
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool QueueDeductRecordRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.QueueDeductRecordRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.account.v1.DeductRecord deduct_record = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_deduct_record()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.QueueDeductRecordRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.QueueDeductRecordRequest)
-  return false;
-#undef DO_
-}
-
-void QueueDeductRecordRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.QueueDeductRecordRequest)
-  // optional .bgs.protocol.account.v1.DeductRecord deduct_record = 1;
-  if (has_deduct_record()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->deduct_record(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.QueueDeductRecordRequest)
-}
-
-::google::protobuf::uint8* QueueDeductRecordRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.QueueDeductRecordRequest)
-  // optional .bgs.protocol.account.v1.DeductRecord deduct_record = 1;
-  if (has_deduct_record()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->deduct_record(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.QueueDeductRecordRequest)
-  return target;
-}
-
-int QueueDeductRecordRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.account.v1.DeductRecord deduct_record = 1;
-    if (has_deduct_record()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->deduct_record());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void QueueDeductRecordRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const QueueDeductRecordRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const QueueDeductRecordRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void QueueDeductRecordRequest::MergeFrom(const QueueDeductRecordRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_deduct_record()) {
-      mutable_deduct_record()->::bgs::protocol::account::v1::DeductRecord::MergeFrom(from.deduct_record());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void QueueDeductRecordRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void QueueDeductRecordRequest::CopyFrom(const QueueDeductRecordRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool QueueDeductRecordRequest::IsInitialized() const {
-
-  if (has_deduct_record()) {
-    if (!this->deduct_record().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void QueueDeductRecordRequest::Swap(QueueDeductRecordRequest* other) {
-  if (other != this) {
-    std::swap(deduct_record_, other->deduct_record_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata QueueDeductRecordRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = QueueDeductRecordRequest_descriptor_;
-  metadata.reflection = QueueDeductRecordRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int GetGameAccountRequest::kGameAccountFieldNumber;
-const int GetGameAccountRequest::kReloadFieldNumber;
-#endif  // !_MSC_VER
-
-GetGameAccountRequest::GetGameAccountRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameAccountRequest)
-}
-
-void GetGameAccountRequest::InitAsDefaultInstance() {
-  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
-}
-
-GetGameAccountRequest::GetGameAccountRequest(const GetGameAccountRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameAccountRequest)
-}
-
-void GetGameAccountRequest::SharedCtor() {
-  _cached_size_ = 0;
-  game_account_ = NULL;
-  reload_ = false;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-GetGameAccountRequest::~GetGameAccountRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameAccountRequest)
-  SharedDtor();
-}
-
-void GetGameAccountRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete game_account_;
-  }
-}
-
-void GetGameAccountRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* GetGameAccountRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return GetGameAccountRequest_descriptor_;
-}
-
-const GetGameAccountRequest& GetGameAccountRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-GetGameAccountRequest* GetGameAccountRequest::default_instance_ = NULL;
-
-GetGameAccountRequest* GetGameAccountRequest::New() const {
-  return new GetGameAccountRequest;
-}
-
-void GetGameAccountRequest::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
-    if (has_game_account()) {
-      if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-    }
-    reload_ = false;
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool GetGameAccountRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameAccountRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(16)) goto parse_reload;
-        break;
-      }
-
-      // optional bool reload = 2 [default = false];
-      case 2: {
-        if (tag == 16) {
-         parse_reload:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &reload_)));
-          set_has_reload();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetGameAccountRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameAccountRequest)
-  return false;
-#undef DO_
-}
-
-void GetGameAccountRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameAccountRequest)
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->game_account(), output);
-  }
-
-  // optional bool reload = 2 [default = false];
-  if (has_reload()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->reload(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameAccountRequest)
-}
-
-::google::protobuf::uint8* GetGameAccountRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameAccountRequest)
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->game_account(), target);
-  }
-
-  // optional bool reload = 2 [default = false];
-  if (has_reload()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->reload(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameAccountRequest)
-  return target;
-}
-
-int GetGameAccountRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-    if (has_game_account()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account());
-    }
-
-    // optional bool reload = 2 [default = false];
-    if (has_reload()) {
-      total_size += 1 + 1;
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void GetGameAccountRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const GetGameAccountRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GetGameAccountRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void GetGameAccountRequest::MergeFrom(const GetGameAccountRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_game_account()) {
-      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
-    }
-    if (from.has_reload()) {
-      set_reload(from.reload());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void GetGameAccountRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void GetGameAccountRequest::CopyFrom(const GetGameAccountRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool GetGameAccountRequest::IsInitialized() const {
-
-  if (has_game_account()) {
-    if (!this->game_account().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void GetGameAccountRequest::Swap(GetGameAccountRequest* other) {
-  if (other != this) {
-    std::swap(game_account_, other->game_account_);
-    std::swap(reload_, other->reload_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata GetGameAccountRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GetGameAccountRequest_descriptor_;
-  metadata.reflection = GetGameAccountRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int GetGameAccountResponse::kBlobFieldNumber;
-#endif  // !_MSC_VER
-
-GetGameAccountResponse::GetGameAccountResponse()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameAccountResponse)
-}
-
-void GetGameAccountResponse::InitAsDefaultInstance() {
-  blob_ = const_cast< ::bgs::protocol::account::v1::GameAccountBlob*>(&::bgs::protocol::account::v1::GameAccountBlob::default_instance());
-}
-
-GetGameAccountResponse::GetGameAccountResponse(const GetGameAccountResponse& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameAccountResponse)
-}
-
-void GetGameAccountResponse::SharedCtor() {
-  _cached_size_ = 0;
-  blob_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-GetGameAccountResponse::~GetGameAccountResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameAccountResponse)
-  SharedDtor();
-}
-
-void GetGameAccountResponse::SharedDtor() {
-  if (this != default_instance_) {
-    delete blob_;
-  }
-}
-
-void GetGameAccountResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* GetGameAccountResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return GetGameAccountResponse_descriptor_;
-}
-
-const GetGameAccountResponse& GetGameAccountResponse::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
-  return *default_instance_;
-}
-
-GetGameAccountResponse* GetGameAccountResponse::default_instance_ = NULL;
-
-GetGameAccountResponse* GetGameAccountResponse::New() const {
-  return new GetGameAccountResponse;
-}
-
-void GetGameAccountResponse::Clear() {
-  if (has_blob()) {
-    if (blob_ != NULL) blob_->::bgs::protocol::account::v1::GameAccountBlob::Clear();
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool GetGameAccountResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameAccountResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_blob()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetGameAccountResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameAccountResponse)
-  return false;
-#undef DO_
-}
-
-void GetGameAccountResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameAccountResponse)
-  // optional .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-  if (has_blob()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->blob(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameAccountResponse)
-}
-
-::google::protobuf::uint8* GetGameAccountResponse::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameAccountResponse)
-  // optional .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-  if (has_blob()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->blob(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameAccountResponse)
-  return target;
-}
-
-int GetGameAccountResponse::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-    if (has_blob()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->blob());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void GetGameAccountResponse::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const GetGameAccountResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GetGameAccountResponse*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void GetGameAccountResponse::MergeFrom(const GetGameAccountResponse& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_blob()) {
-      mutable_blob()->::bgs::protocol::account::v1::GameAccountBlob::MergeFrom(from.blob());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void GetGameAccountResponse::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void GetGameAccountResponse::CopyFrom(const GetGameAccountResponse& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool GetGameAccountResponse::IsInitialized() const {
-
-  if (has_blob()) {
-    if (!this->blob().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void GetGameAccountResponse::Swap(GetGameAccountResponse* other) {
-  if (other != this) {
-    std::swap(blob_, other->blob_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata GetGameAccountResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GetGameAccountResponse_descriptor_;
-  metadata.reflection = GetGameAccountResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int AccountStateNotification::kAccountStateFieldNumber;
 const int AccountStateNotification::kSubscriberIdFieldNumber;
 const int AccountStateNotification::kAccountTagsFieldNumber;
@@ -11330,7 +7437,7 @@ bool AccountStateNotification::MergePartialFromCodedStream(
         break;
       }
 
-      // optional uint64 subscriber_id = 2;
+      // optional uint64 subscriber_id = 2 [deprecated = true];
       case 2: {
         if (tag == 16) {
          parse_subscriber_id:
@@ -11404,7 +7511,7 @@ void AccountStateNotification::SerializeWithCachedSizes(
       1, this->account_state(), output);
   }
 
-  // optional uint64 subscriber_id = 2;
+  // optional uint64 subscriber_id = 2 [deprecated = true];
   if (has_subscriber_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->subscriber_id(), output);
   }
@@ -11437,7 +7544,7 @@ void AccountStateNotification::SerializeWithCachedSizes(
         1, this->account_state(), target);
   }
 
-  // optional uint64 subscriber_id = 2;
+  // optional uint64 subscriber_id = 2 [deprecated = true];
   if (has_subscriber_id()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->subscriber_id(), target);
   }
@@ -11473,7 +7580,7 @@ int AccountStateNotification::ByteSize() const {
           this->account_state());
     }
 
-    // optional uint64 subscriber_id = 2;
+    // optional uint64 subscriber_id = 2 [deprecated = true];
     if (has_subscriber_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt64Size(
@@ -11682,7 +7789,7 @@ bool GameAccountStateNotification::MergePartialFromCodedStream(
         break;
       }
 
-      // optional uint64 subscriber_id = 2;
+      // optional uint64 subscriber_id = 2 [deprecated = true];
       case 2: {
         if (tag == 16) {
          parse_subscriber_id:
@@ -11756,7 +7863,7 @@ void GameAccountStateNotification::SerializeWithCachedSizes(
       1, this->game_account_state(), output);
   }
 
-  // optional uint64 subscriber_id = 2;
+  // optional uint64 subscriber_id = 2 [deprecated = true];
   if (has_subscriber_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->subscriber_id(), output);
   }
@@ -11789,7 +7896,7 @@ void GameAccountStateNotification::SerializeWithCachedSizes(
         1, this->game_account_state(), target);
   }
 
-  // optional uint64 subscriber_id = 2;
+  // optional uint64 subscriber_id = 2 [deprecated = true];
   if (has_subscriber_id()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->subscriber_id(), target);
   }
@@ -11825,7 +7932,7 @@ int GameAccountStateNotification::ByteSize() const {
           this->game_account_state());
     }
 
-    // optional uint64 subscriber_id = 2;
+    // optional uint64 subscriber_id = 2 [deprecated = true];
     if (has_subscriber_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt64Size(
@@ -12526,39 +8633,17 @@ google::protobuf::ServiceDescriptor const* AccountService::descriptor() {
   return AccountService_descriptor_;
 }
 
-void AccountService::GetGameAccountBlob(::bgs::protocol::account::v1::GameAccountHandle const* request, std::function<void(::bgs::protocol::account::v1::GameAccountBlob const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameAccountBlob(bgs.protocol.account.v1.GameAccountHandle{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::account::v1::GameAccountBlob response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 12, request, std::move(callback));
-}
-
-void AccountService::GetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAccountResponse const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetAccount(bgs.protocol.account.v1.GetAccountRequest{ %s })",
+void AccountService::ResolveAccount(::bgs::protocol::account::v1::ResolveAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::ResolveAccountResponse const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.ResolveAccount(bgs.protocol.account.v1.ResolveAccountRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::account::v1::GetAccountResponse response;
+    ::bgs::protocol::account::v1::ResolveAccountResponse response;
     if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
       responseCallback(&response);
   };
   SendRequest(service_hash_, 13, request, std::move(callback));
 }
 
-void AccountService::CreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GameAccountHandle const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CreateGameAccount(bgs.protocol.account.v1.CreateGameAccountRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::account::v1::GameAccountHandle response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 14, request, std::move(callback));
-}
-
 void AccountService::IsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
   TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.IsIgrAddress(bgs.protocol.account.v1.IsIgrAddressRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
@@ -12570,23 +8655,6 @@ void AccountService::IsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequ
   SendRequest(service_hash_, 15, request, std::move(callback));
 }
 
-void AccountService::CacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CacheExpire(bgs.protocol.account.v1.CacheExpireRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 20, request);
-}
-
-void AccountService::CredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, std::function<void(::bgs::protocol::account::v1::CredentialUpdateResponse const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CredentialUpdate(bgs.protocol.account.v1.CredentialUpdateRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::account::v1::CredentialUpdateResponse response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 21, request, std::move(callback));
-}
-
 void AccountService::Subscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function<void(::bgs::protocol::account::v1::SubscriptionUpdateResponse const*)> responseCallback) {
   TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.Subscribe(bgs.protocol.account.v1.SubscriptionUpdateRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
@@ -12675,17 +8743,6 @@ void AccountService::GetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoReques
   SendRequest(service_hash_, 35, request, std::move(callback));
 }
 
-void AccountService::ForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.ForwardCacheExpire(bgs.protocol.account.v1.ForwardCacheExpireRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 36, request, std::move(callback));
-}
-
 void AccountService::GetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAuthorizedDataResponse const*)> responseCallback) {
   TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetAuthorizedData(bgs.protocol.account.v1.GetAuthorizedDataRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
@@ -12697,138 +8754,41 @@ void AccountService::GetAuthorizedData(::bgs::protocol::account::v1::GetAuthoriz
   SendRequest(service_hash_, 37, request, std::move(callback));
 }
 
-void AccountService::AccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.AccountFlagUpdate(bgs.protocol.account.v1.AccountFlagUpdateRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 38, request);
-}
-
-void AccountService::GameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GameAccountFlagUpdate(bgs.protocol.account.v1.GameAccountFlagUpdateRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 39, request);
-}
-
-void AccountService::UpdateParentalControlsAndCAIS(::bgs::protocol::account::v1::UpdateParentalControlsAndCAISRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.UpdateParentalControlsAndCAIS(bgs.protocol.account.v1.UpdateParentalControlsAndCAISRequest{ %s })",
+void AccountService::GetSignedAccountState(::bgs::protocol::account::v1::GetSignedAccountStateRequest const* request, std::function<void(::bgs::protocol::account::v1::GetSignedAccountStateResponse const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetSignedAccountState(bgs.protocol.account.v1.GetSignedAccountStateRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 40, request, std::move(callback));
-}
-
-void AccountService::CreateGameAccount2(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::CreateGameAccountResponse const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CreateGameAccount2(bgs.protocol.account.v1.CreateGameAccountRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::account::v1::CreateGameAccountResponse response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 41, request, std::move(callback));
-}
-
-void AccountService::GetGameAccount(::bgs::protocol::account::v1::GetGameAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameAccountResponse const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameAccount(bgs.protocol.account.v1.GetGameAccountRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::account::v1::GetGameAccountResponse response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 42, request, std::move(callback));
-}
-
-void AccountService::QueueDeductRecord(::bgs::protocol::account::v1::QueueDeductRecordRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.QueueDeductRecord(bgs.protocol.account.v1.QueueDeductRecordRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
+    ::bgs::protocol::account::v1::GetSignedAccountStateResponse response;
     if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
       responseCallback(&response);
   };
-  SendRequest(service_hash_, 43, request, std::move(callback));
+  SendRequest(service_hash_, 44, request, std::move(callback));
 }
 
 void AccountService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
   switch(methodId) {
-    case 12: {
-      ::bgs::protocol::account::v1::GameAccountHandle request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameAccountBlob server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameAccountBlob(bgs.protocol.account.v1.GameAccountHandle{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::account::v1::GameAccountBlob::descriptor());
-        AccountService* self = static_cast<AccountService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameAccountBlob() returned bgs.protocol.account.v1.GameAccountBlob{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 12, token, response);
-        else
-          self->SendResponse(self->service_hash_, 12, token, status);
-      };
-      ::bgs::protocol::account::v1::GameAccountBlob response;
-      uint32 status = HandleGetGameAccountBlob(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
     case 13: {
-      ::bgs::protocol::account::v1::GetAccountRequest request;
+      ::bgs::protocol::account::v1::ResolveAccountRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetAccount server method call.", GetCallerInfo().c_str());
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.ResolveAccount server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 13, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetAccount(bgs.protocol.account.v1.GetAccountRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.ResolveAccount(bgs.protocol.account.v1.ResolveAccountRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::account::v1::GetAccountResponse::descriptor());
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::account::v1::ResolveAccountResponse::descriptor());
         AccountService* self = static_cast<AccountService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetAccount() returned bgs.protocol.account.v1.GetAccountResponse{ %s } status %u.",
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.ResolveAccount() returned bgs.protocol.account.v1.ResolveAccountResponse{ %s } status %u.",
           self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
         if (!status)
           self->SendResponse(self->service_hash_, 13, token, response);
         else
           self->SendResponse(self->service_hash_, 13, token, status);
       };
-      ::bgs::protocol::account::v1::GetAccountResponse response;
-      uint32 status = HandleGetAccount(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 14: {
-      ::bgs::protocol::account::v1::CreateGameAccountRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CreateGameAccount server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 14, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CreateGameAccount(bgs.protocol.account.v1.CreateGameAccountRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::account::v1::GameAccountHandle::descriptor());
-        AccountService* self = static_cast<AccountService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CreateGameAccount() returned bgs.protocol.account.v1.GameAccountHandle{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 14, token, response);
-        else
-          self->SendResponse(self->service_hash_, 14, token, status);
-      };
-      ::bgs::protocol::account::v1::GameAccountHandle response;
-      uint32 status = HandleCreateGameAccount(&request, &response, continuation);
+      ::bgs::protocol::account::v1::ResolveAccountResponse response;
+      uint32 status = HandleResolveAccount(&request, &response, continuation);
       if (continuation)
         continuation(this, status, &response);
       break;
@@ -12859,46 +8819,6 @@ void AccountService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
         continuation(this, status, &response);
       break;
     }
-    case 20: {
-      ::bgs::protocol::account::v1::CacheExpireRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CacheExpire server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 20, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleCacheExpire(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CacheExpire(bgs.protocol.account.v1.CacheExpireRequest{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 20, token, status);
-      break;
-    }
-    case 21: {
-      ::bgs::protocol::account::v1::CredentialUpdateRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CredentialUpdate server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 21, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CredentialUpdate(bgs.protocol.account.v1.CredentialUpdateRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::account::v1::CredentialUpdateResponse::descriptor());
-        AccountService* self = static_cast<AccountService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CredentialUpdate() returned bgs.protocol.account.v1.CredentialUpdateResponse{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 21, token, response);
-        else
-          self->SendResponse(self->service_hash_, 21, token, status);
-      };
-      ::bgs::protocol::account::v1::CredentialUpdateResponse response;
-      uint32 status = HandleCredentialUpdate(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
     case 25: {
       ::bgs::protocol::account::v1::SubscriptionUpdateRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
@@ -13107,32 +9027,6 @@ void AccountService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
         continuation(this, status, &response);
       break;
     }
-    case 36: {
-      ::bgs::protocol::account::v1::ForwardCacheExpireRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.ForwardCacheExpire server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 36, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.ForwardCacheExpire(bgs.protocol.account.v1.ForwardCacheExpireRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        AccountService* self = static_cast<AccountService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.ForwardCacheExpire() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 36, token, response);
-        else
-          self->SendResponse(self->service_hash_, 36, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleForwardCacheExpire(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
     case 37: {
       ::bgs::protocol::account::v1::GetAuthorizedDataRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
@@ -13159,134 +9053,28 @@ void AccountService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
         continuation(this, status, &response);
       break;
     }
-    case 38: {
-      ::bgs::protocol::account::v1::AccountFlagUpdateRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.AccountFlagUpdate server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 38, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleAccountFlagUpdate(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.AccountFlagUpdate(bgs.protocol.account.v1.AccountFlagUpdateRequest{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 38, token, status);
-      break;
-    }
-    case 39: {
-      ::bgs::protocol::account::v1::GameAccountFlagUpdateRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GameAccountFlagUpdate server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 39, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleGameAccountFlagUpdate(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GameAccountFlagUpdate(bgs.protocol.account.v1.GameAccountFlagUpdateRequest{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 39, token, status);
-      break;
-    }
-    case 40: {
-      ::bgs::protocol::account::v1::UpdateParentalControlsAndCAISRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.UpdateParentalControlsAndCAIS server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 40, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.UpdateParentalControlsAndCAIS(bgs.protocol.account.v1.UpdateParentalControlsAndCAISRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        AccountService* self = static_cast<AccountService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.UpdateParentalControlsAndCAIS() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 40, token, response);
-        else
-          self->SendResponse(self->service_hash_, 40, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleUpdateParentalControlsAndCAIS(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 41: {
-      ::bgs::protocol::account::v1::CreateGameAccountRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CreateGameAccount2 server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 41, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CreateGameAccount2(bgs.protocol.account.v1.CreateGameAccountRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::account::v1::CreateGameAccountResponse::descriptor());
-        AccountService* self = static_cast<AccountService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CreateGameAccount2() returned bgs.protocol.account.v1.CreateGameAccountResponse{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 41, token, response);
-        else
-          self->SendResponse(self->service_hash_, 41, token, status);
-      };
-      ::bgs::protocol::account::v1::CreateGameAccountResponse response;
-      uint32 status = HandleCreateGameAccount2(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 42: {
-      ::bgs::protocol::account::v1::GetGameAccountRequest request;
+    case 44: {
+      ::bgs::protocol::account::v1::GetSignedAccountStateRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameAccount server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 42, token, ERROR_RPC_MALFORMED_REQUEST);
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetSignedAccountState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 44, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameAccount(bgs.protocol.account.v1.GetGameAccountRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetSignedAccountState(bgs.protocol.account.v1.GetSignedAccountStateRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::account::v1::GetGameAccountResponse::descriptor());
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::account::v1::GetSignedAccountStateResponse::descriptor());
         AccountService* self = static_cast<AccountService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameAccount() returned bgs.protocol.account.v1.GetGameAccountResponse{ %s } status %u.",
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetSignedAccountState() returned bgs.protocol.account.v1.GetSignedAccountStateResponse{ %s } status %u.",
           self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
         if (!status)
-          self->SendResponse(self->service_hash_, 42, token, response);
+          self->SendResponse(self->service_hash_, 44, token, response);
         else
-          self->SendResponse(self->service_hash_, 42, token, status);
+          self->SendResponse(self->service_hash_, 44, token, status);
       };
-      ::bgs::protocol::account::v1::GetGameAccountResponse response;
-      uint32 status = HandleGetGameAccount(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 43: {
-      ::bgs::protocol::account::v1::QueueDeductRecordRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.QueueDeductRecord server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 43, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.QueueDeductRecord(bgs.protocol.account.v1.QueueDeductRecordRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        AccountService* self = static_cast<AccountService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.QueueDeductRecord() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 43, token, response);
-        else
-          self->SendResponse(self->service_hash_, 43, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleQueueDeductRecord(&request, &response, continuation);
+      ::bgs::protocol::account::v1::GetSignedAccountStateResponse response;
+      uint32 status = HandleGetSignedAccountState(&request, &response, continuation);
       if (continuation)
         continuation(this, status, &response);
       break;
@@ -13298,20 +9086,8 @@ void AccountService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
     }
 }
 
-uint32 AccountService::HandleGetGameAccountBlob(::bgs::protocol::account::v1::GameAccountHandle const* request, ::bgs::protocol::account::v1::GameAccountBlob* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameAccountBlob({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 AccountService::HandleGetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, ::bgs::protocol::account::v1::GetAccountResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetAccount({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 AccountService::HandleCreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, ::bgs::protocol::account::v1::GameAccountHandle* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CreateGameAccount({ %s })",
+uint32 AccountService::HandleResolveAccount(::bgs::protocol::account::v1::ResolveAccountRequest const* request, ::bgs::protocol::account::v1::ResolveAccountResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.ResolveAccount({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
@@ -13322,18 +9098,6 @@ uint32 AccountService::HandleIsIgrAddress(::bgs::protocol::account::v1::IsIgrAdd
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 AccountService::HandleCacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CacheExpire({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 AccountService::HandleCredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, ::bgs::protocol::account::v1::CredentialUpdateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CredentialUpdate({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
 uint32 AccountService::HandleSubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::account::v1::SubscriptionUpdateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.Subscribe({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
@@ -13382,50 +9146,14 @@ uint32 AccountService::HandleGetCAISInfo(::bgs::protocol::account::v1::GetCAISIn
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 AccountService::HandleForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.ForwardCacheExpire({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
 uint32 AccountService::HandleGetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, ::bgs::protocol::account::v1::GetAuthorizedDataResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetAuthorizedData({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 AccountService::HandleAccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.AccountFlagUpdate({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 AccountService::HandleGameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GameAccountFlagUpdate({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 AccountService::HandleUpdateParentalControlsAndCAIS(::bgs::protocol::account::v1::UpdateParentalControlsAndCAISRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.UpdateParentalControlsAndCAIS({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 AccountService::HandleCreateGameAccount2(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, ::bgs::protocol::account::v1::CreateGameAccountResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CreateGameAccount2({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 AccountService::HandleGetGameAccount(::bgs::protocol::account::v1::GetGameAccountRequest const* request, ::bgs::protocol::account::v1::GetGameAccountResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameAccount({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 AccountService::HandleQueueDeductRecord(::bgs::protocol::account::v1::QueueDeductRecordRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.QueueDeductRecord({ %s })",
+uint32 AccountService::HandleGetSignedAccountState(::bgs::protocol::account::v1::GetSignedAccountStateRequest const* request, ::bgs::protocol::account::v1::GetSignedAccountStateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetSignedAccountState({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
diff --git a/src/server/proto/Client/account_service.pb.h b/src/server/proto/Client/account_service.pb.h
index 5dec970ce07..3522f351b72 100644
--- a/src/server/proto/Client/account_service.pb.h
+++ b/src/server/proto/Client/account_service.pb.h
@@ -43,22 +43,16 @@ void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
 void protobuf_AssignDesc_account_5fservice_2eproto();
 void protobuf_ShutdownFile_account_5fservice_2eproto();
 
-class GetAccountRequest;
-class GetAccountResponse;
-class CreateGameAccountRequest;
-class CreateGameAccountResponse;
-class CacheExpireRequest;
-class CredentialUpdateRequest;
-class CredentialUpdateResponse;
-class AccountFlagUpdateRequest;
+class ResolveAccountRequest;
+class ResolveAccountResponse;
 class GameAccountFlagUpdateRequest;
 class SubscriptionUpdateRequest;
 class SubscriptionUpdateResponse;
 class IsIgrAddressRequest;
-class AccountServiceRegion;
-class AccountServiceConfig;
 class GetAccountStateRequest;
 class GetAccountStateResponse;
+class GetSignedAccountStateRequest;
+class GetSignedAccountStateResponse;
 class GetGameAccountStateRequest;
 class GetGameAccountStateResponse;
 class GetLicensesRequest;
@@ -69,13 +63,9 @@ class GetGameTimeRemainingInfoRequest;
 class GetGameTimeRemainingInfoResponse;
 class GetCAISInfoRequest;
 class GetCAISInfoResponse;
-class ForwardCacheExpireRequest;
 class GetAuthorizedDataRequest;
 class GetAuthorizedDataResponse;
 class UpdateParentalControlsAndCAISRequest;
-class QueueDeductRecordRequest;
-class GetGameAccountRequest;
-class GetGameAccountResponse;
 class AccountStateNotification;
 class GameAccountStateNotification;
 class GameAccountNotification;
@@ -83,14 +73,14 @@ class GameAccountSessionNotification;
 
 // ===================================================================
 
-class TC_PROTO_API GetAccountRequest : public ::google::protobuf::Message {
+class TC_PROTO_API ResolveAccountRequest : public ::google::protobuf::Message {
  public:
-  GetAccountRequest();
-  virtual ~GetAccountRequest();
+  ResolveAccountRequest();
+  virtual ~ResolveAccountRequest();
 
-  GetAccountRequest(const GetAccountRequest& from);
+  ResolveAccountRequest(const ResolveAccountRequest& from);
 
-  inline GetAccountRequest& operator=(const GetAccountRequest& from) {
+  inline ResolveAccountRequest& operator=(const ResolveAccountRequest& from) {
     CopyFrom(from);
     return *this;
   }
@@ -104,17 +94,17 @@ class TC_PROTO_API GetAccountRequest : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const GetAccountRequest& default_instance();
+  static const ResolveAccountRequest& default_instance();
 
-  void Swap(GetAccountRequest* other);
+  void Swap(ResolveAccountRequest* other);
 
   // implements Message ----------------------------------------------
 
-  GetAccountRequest* New() const;
+  ResolveAccountRequest* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GetAccountRequest& from);
-  void MergeFrom(const GetAccountRequest& from);
+  void CopyFrom(const ResolveAccountRequest& from);
+  void MergeFrom(const ResolveAccountRequest& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -145,133 +135,43 @@ class TC_PROTO_API GetAccountRequest : public ::google::protobuf::Message {
   inline ::bgs::protocol::account::v1::AccountReference* release_ref();
   inline void set_allocated_ref(::bgs::protocol::account::v1::AccountReference* ref);
 
-  // optional bool reload = 2 [default = false];
-  inline bool has_reload() const;
-  inline void clear_reload();
-  static const int kReloadFieldNumber = 2;
-  inline bool reload() const;
-  inline void set_reload(bool value);
-
-  // optional bool fetch_all = 10 [default = false];
-  inline bool has_fetch_all() const;
-  inline void clear_fetch_all();
-  static const int kFetchAllFieldNumber = 10;
-  inline bool fetch_all() const;
-  inline void set_fetch_all(bool value);
-
-  // optional bool fetch_blob = 11 [default = false];
-  inline bool has_fetch_blob() const;
-  inline void clear_fetch_blob();
-  static const int kFetchBlobFieldNumber = 11;
-  inline bool fetch_blob() const;
-  inline void set_fetch_blob(bool value);
-
-  // optional bool fetch_id = 12 [default = false];
+  // optional bool fetch_id = 12;
   inline bool has_fetch_id() const;
   inline void clear_fetch_id();
   static const int kFetchIdFieldNumber = 12;
   inline bool fetch_id() const;
   inline void set_fetch_id(bool value);
 
-  // optional bool fetch_email = 13 [default = false];
-  inline bool has_fetch_email() const;
-  inline void clear_fetch_email();
-  static const int kFetchEmailFieldNumber = 13;
-  inline bool fetch_email() const;
-  inline void set_fetch_email(bool value);
-
-  // optional bool fetch_battle_tag = 14 [default = false];
-  inline bool has_fetch_battle_tag() const;
-  inline void clear_fetch_battle_tag();
-  static const int kFetchBattleTagFieldNumber = 14;
-  inline bool fetch_battle_tag() const;
-  inline void set_fetch_battle_tag(bool value);
-
-  // optional bool fetch_full_name = 15 [default = false];
-  inline bool has_fetch_full_name() const;
-  inline void clear_fetch_full_name();
-  static const int kFetchFullNameFieldNumber = 15;
-  inline bool fetch_full_name() const;
-  inline void set_fetch_full_name(bool value);
-
-  // optional bool fetch_links = 16 [default = false];
-  inline bool has_fetch_links() const;
-  inline void clear_fetch_links();
-  static const int kFetchLinksFieldNumber = 16;
-  inline bool fetch_links() const;
-  inline void set_fetch_links(bool value);
-
-  // optional bool fetch_parental_controls = 17 [default = false];
-  inline bool has_fetch_parental_controls() const;
-  inline void clear_fetch_parental_controls();
-  static const int kFetchParentalControlsFieldNumber = 17;
-  inline bool fetch_parental_controls() const;
-  inline void set_fetch_parental_controls(bool value);
-
-  // optional bool fetch_cais_id = 18 [default = false];
-  inline bool has_fetch_cais_id() const;
-  inline void clear_fetch_cais_id();
-  static const int kFetchCaisIdFieldNumber = 18;
-  inline bool fetch_cais_id() const;
-  inline void set_fetch_cais_id(bool value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountRequest)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ResolveAccountRequest)
  private:
   inline void set_has_ref();
   inline void clear_has_ref();
-  inline void set_has_reload();
-  inline void clear_has_reload();
-  inline void set_has_fetch_all();
-  inline void clear_has_fetch_all();
-  inline void set_has_fetch_blob();
-  inline void clear_has_fetch_blob();
   inline void set_has_fetch_id();
   inline void clear_has_fetch_id();
-  inline void set_has_fetch_email();
-  inline void clear_has_fetch_email();
-  inline void set_has_fetch_battle_tag();
-  inline void clear_has_fetch_battle_tag();
-  inline void set_has_fetch_full_name();
-  inline void clear_has_fetch_full_name();
-  inline void set_has_fetch_links();
-  inline void clear_has_fetch_links();
-  inline void set_has_fetch_parental_controls();
-  inline void clear_has_fetch_parental_controls();
-  inline void set_has_fetch_cais_id();
-  inline void clear_has_fetch_cais_id();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
   ::bgs::protocol::account::v1::AccountReference* ref_;
-  bool reload_;
-  bool fetch_all_;
-  bool fetch_blob_;
   bool fetch_id_;
-  bool fetch_email_;
-  bool fetch_battle_tag_;
-  bool fetch_full_name_;
-  bool fetch_links_;
-  bool fetch_parental_controls_;
-  bool fetch_cais_id_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
   friend void protobuf_AssignDesc_account_5fservice_2eproto();
   friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static GetAccountRequest* default_instance_;
+  static ResolveAccountRequest* default_instance_;
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API GetAccountResponse : public ::google::protobuf::Message {
+class TC_PROTO_API ResolveAccountResponse : public ::google::protobuf::Message {
  public:
-  GetAccountResponse();
-  virtual ~GetAccountResponse();
+  ResolveAccountResponse();
+  virtual ~ResolveAccountResponse();
 
-  GetAccountResponse(const GetAccountResponse& from);
+  ResolveAccountResponse(const ResolveAccountResponse& from);
 
-  inline GetAccountResponse& operator=(const GetAccountResponse& from) {
+  inline ResolveAccountResponse& operator=(const ResolveAccountResponse& from) {
     CopyFrom(from);
     return *this;
   }
@@ -285,17 +185,17 @@ class TC_PROTO_API GetAccountResponse : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const GetAccountResponse& default_instance();
+  static const ResolveAccountResponse& default_instance();
 
-  void Swap(GetAccountResponse* other);
+  void Swap(ResolveAccountResponse* other);
 
   // implements Message ----------------------------------------------
 
-  GetAccountResponse* New() const;
+  ResolveAccountResponse* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GetAccountResponse& from);
-  void MergeFrom(const GetAccountResponse& from);
+  void CopyFrom(const ResolveAccountResponse& from);
+  void MergeFrom(const ResolveAccountResponse& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -317,15 +217,6 @@ class TC_PROTO_API GetAccountResponse : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional .bgs.protocol.account.v1.AccountBlob blob = 11;
-  inline bool has_blob() const;
-  inline void clear_blob();
-  static const int kBlobFieldNumber = 11;
-  inline const ::bgs::protocol::account::v1::AccountBlob& blob() const;
-  inline ::bgs::protocol::account::v1::AccountBlob* mutable_blob();
-  inline ::bgs::protocol::account::v1::AccountBlob* release_blob();
-  inline void set_allocated_blob(::bgs::protocol::account::v1::AccountBlob* blob);
-
   // optional .bgs.protocol.account.v1.AccountId id = 12;
   inline bool has_id() const;
   inline void clear_id();
@@ -335,733 +226,22 @@ class TC_PROTO_API GetAccountResponse : public ::google::protobuf::Message {
   inline ::bgs::protocol::account::v1::AccountId* release_id();
   inline void set_allocated_id(::bgs::protocol::account::v1::AccountId* id);
 
-  // repeated string email = 13;
-  inline int email_size() const;
-  inline void clear_email();
-  static const int kEmailFieldNumber = 13;
-  inline const ::std::string& email(int index) const;
-  inline ::std::string* mutable_email(int index);
-  inline void set_email(int index, const ::std::string& value);
-  inline void set_email(int index, const char* value);
-  inline void set_email(int index, const char* value, size_t size);
-  inline ::std::string* add_email();
-  inline void add_email(const ::std::string& value);
-  inline void add_email(const char* value);
-  inline void add_email(const char* value, size_t size);
-  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& email() const;
-  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_email();
-
-  // optional string battle_tag = 14;
-  inline bool has_battle_tag() const;
-  inline void clear_battle_tag();
-  static const int kBattleTagFieldNumber = 14;
-  inline const ::std::string& battle_tag() const;
-  inline void set_battle_tag(const ::std::string& value);
-  inline void set_battle_tag(const char* value);
-  inline void set_battle_tag(const char* value, size_t size);
-  inline ::std::string* mutable_battle_tag();
-  inline ::std::string* release_battle_tag();
-  inline void set_allocated_battle_tag(::std::string* battle_tag);
-
-  // optional string full_name = 15;
-  inline bool has_full_name() const;
-  inline void clear_full_name();
-  static const int kFullNameFieldNumber = 15;
-  inline const ::std::string& full_name() const;
-  inline void set_full_name(const ::std::string& value);
-  inline void set_full_name(const char* value);
-  inline void set_full_name(const char* value, size_t size);
-  inline ::std::string* mutable_full_name();
-  inline ::std::string* release_full_name();
-  inline void set_allocated_full_name(::std::string* full_name);
-
-  // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
-  inline int links_size() const;
-  inline void clear_links();
-  static const int kLinksFieldNumber = 16;
-  inline const ::bgs::protocol::account::v1::GameAccountLink& links(int index) const;
-  inline ::bgs::protocol::account::v1::GameAccountLink* mutable_links(int index);
-  inline ::bgs::protocol::account::v1::GameAccountLink* add_links();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >&
-      links() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >*
-      mutable_links();
-
-  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
-  inline bool has_parental_control_info() const;
-  inline void clear_parental_control_info();
-  static const int kParentalControlInfoFieldNumber = 17;
-  inline const ::bgs::protocol::account::v1::ParentalControlInfo& parental_control_info() const;
-  inline ::bgs::protocol::account::v1::ParentalControlInfo* mutable_parental_control_info();
-  inline ::bgs::protocol::account::v1::ParentalControlInfo* release_parental_control_info();
-  inline void set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info);
-
-  // optional string cais_id = 18;
-  inline bool has_cais_id() const;
-  inline void clear_cais_id();
-  static const int kCaisIdFieldNumber = 18;
-  inline const ::std::string& cais_id() const;
-  inline void set_cais_id(const ::std::string& value);
-  inline void set_cais_id(const char* value);
-  inline void set_cais_id(const char* value, size_t size);
-  inline ::std::string* mutable_cais_id();
-  inline ::std::string* release_cais_id();
-  inline void set_allocated_cais_id(::std::string* cais_id);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountResponse)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ResolveAccountResponse)
  private:
-  inline void set_has_blob();
-  inline void clear_has_blob();
   inline void set_has_id();
   inline void clear_has_id();
-  inline void set_has_battle_tag();
-  inline void clear_has_battle_tag();
-  inline void set_has_full_name();
-  inline void clear_has_full_name();
-  inline void set_has_parental_control_info();
-  inline void clear_has_parental_control_info();
-  inline void set_has_cais_id();
-  inline void clear_has_cais_id();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::bgs::protocol::account::v1::AccountBlob* blob_;
   ::bgs::protocol::account::v1::AccountId* id_;
-  ::google::protobuf::RepeatedPtrField< ::std::string> email_;
-  ::std::string* battle_tag_;
-  ::std::string* full_name_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink > links_;
-  ::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info_;
-  ::std::string* cais_id_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static GetAccountResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API CreateGameAccountRequest : public ::google::protobuf::Message {
- public:
-  CreateGameAccountRequest();
-  virtual ~CreateGameAccountRequest();
-
-  CreateGameAccountRequest(const CreateGameAccountRequest& from);
-
-  inline CreateGameAccountRequest& operator=(const CreateGameAccountRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const CreateGameAccountRequest& default_instance();
-
-  void Swap(CreateGameAccountRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  CreateGameAccountRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const CreateGameAccountRequest& from);
-  void MergeFrom(const CreateGameAccountRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.account.v1.AccountId account = 1;
-  inline bool has_account() const;
-  inline void clear_account();
-  static const int kAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::AccountId& account() const;
-  inline ::bgs::protocol::account::v1::AccountId* mutable_account();
-  inline ::bgs::protocol::account::v1::AccountId* release_account();
-  inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account);
-
-  // optional uint32 region = 2;
-  inline bool has_region() const;
-  inline void clear_region();
-  static const int kRegionFieldNumber = 2;
-  inline ::google::protobuf::uint32 region() const;
-  inline void set_region(::google::protobuf::uint32 value);
-
-  // optional fixed32 program = 3;
-  inline bool has_program() const;
-  inline void clear_program();
-  static const int kProgramFieldNumber = 3;
-  inline ::google::protobuf::uint32 program() const;
-  inline void set_program(::google::protobuf::uint32 value);
-
-  // optional uint32 realm_permissions = 4 [default = 0];
-  inline bool has_realm_permissions() const;
-  inline void clear_realm_permissions();
-  static const int kRealmPermissionsFieldNumber = 4;
-  inline ::google::protobuf::uint32 realm_permissions() const;
-  inline void set_realm_permissions(::google::protobuf::uint32 value);
-
-  // optional uint32 account_region = 5;
-  inline bool has_account_region() const;
-  inline void clear_account_region();
-  static const int kAccountRegionFieldNumber = 5;
-  inline ::google::protobuf::uint32 account_region() const;
-  inline void set_account_region(::google::protobuf::uint32 value);
-
-  // optional fixed32 platform = 6;
-  inline bool has_platform() const;
-  inline void clear_platform();
-  static const int kPlatformFieldNumber = 6;
-  inline ::google::protobuf::uint32 platform() const;
-  inline void set_platform(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CreateGameAccountRequest)
- private:
-  inline void set_has_account();
-  inline void clear_has_account();
-  inline void set_has_region();
-  inline void clear_has_region();
-  inline void set_has_program();
-  inline void clear_has_program();
-  inline void set_has_realm_permissions();
-  inline void clear_has_realm_permissions();
-  inline void set_has_account_region();
-  inline void clear_has_account_region();
-  inline void set_has_platform();
-  inline void clear_has_platform();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::account::v1::AccountId* account_;
-  ::google::protobuf::uint32 region_;
-  ::google::protobuf::uint32 program_;
-  ::google::protobuf::uint32 realm_permissions_;
-  ::google::protobuf::uint32 account_region_;
-  ::google::protobuf::uint32 platform_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static CreateGameAccountRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API CreateGameAccountResponse : public ::google::protobuf::Message {
- public:
-  CreateGameAccountResponse();
-  virtual ~CreateGameAccountResponse();
-
-  CreateGameAccountResponse(const CreateGameAccountResponse& from);
-
-  inline CreateGameAccountResponse& operator=(const CreateGameAccountResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const CreateGameAccountResponse& default_instance();
-
-  void Swap(CreateGameAccountResponse* other);
-
-  // implements Message ----------------------------------------------
-
-  CreateGameAccountResponse* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const CreateGameAccountResponse& from);
-  void MergeFrom(const CreateGameAccountResponse& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  inline bool has_game_account() const;
-  inline void clear_game_account();
-  static const int kGameAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
-  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
-  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
-  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CreateGameAccountResponse)
- private:
-  inline void set_has_game_account();
-  inline void clear_has_game_account();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static CreateGameAccountResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API CacheExpireRequest : public ::google::protobuf::Message {
- public:
-  CacheExpireRequest();
-  virtual ~CacheExpireRequest();
-
-  CacheExpireRequest(const CacheExpireRequest& from);
-
-  inline CacheExpireRequest& operator=(const CacheExpireRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const CacheExpireRequest& default_instance();
-
-  void Swap(CacheExpireRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  CacheExpireRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const CacheExpireRequest& from);
-  void MergeFrom(const CacheExpireRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // repeated .bgs.protocol.account.v1.AccountId account = 1;
-  inline int account_size() const;
-  inline void clear_account();
-  static const int kAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::AccountId& account(int index) const;
-  inline ::bgs::protocol::account::v1::AccountId* mutable_account(int index);
-  inline ::bgs::protocol::account::v1::AccountId* add_account();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >&
-      account() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >*
-      mutable_account();
-
-  // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
-  inline int game_account_size() const;
-  inline void clear_game_account();
-  static const int kGameAccountFieldNumber = 2;
-  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account(int index) const;
-  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account(int index);
-  inline ::bgs::protocol::account::v1::GameAccountHandle* add_game_account();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >&
-      game_account() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >*
-      mutable_game_account();
-
-  // repeated string email = 3;
-  inline int email_size() const;
-  inline void clear_email();
-  static const int kEmailFieldNumber = 3;
-  inline const ::std::string& email(int index) const;
-  inline ::std::string* mutable_email(int index);
-  inline void set_email(int index, const ::std::string& value);
-  inline void set_email(int index, const char* value);
-  inline void set_email(int index, const char* value, size_t size);
-  inline ::std::string* add_email();
-  inline void add_email(const ::std::string& value);
-  inline void add_email(const char* value);
-  inline void add_email(const char* value, size_t size);
-  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& email() const;
-  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_email();
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CacheExpireRequest)
- private:
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId > account_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle > game_account_;
-  ::google::protobuf::RepeatedPtrField< ::std::string> email_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static CacheExpireRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API CredentialUpdateRequest : public ::google::protobuf::Message {
- public:
-  CredentialUpdateRequest();
-  virtual ~CredentialUpdateRequest();
-
-  CredentialUpdateRequest(const CredentialUpdateRequest& from);
-
-  inline CredentialUpdateRequest& operator=(const CredentialUpdateRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const CredentialUpdateRequest& default_instance();
-
-  void Swap(CredentialUpdateRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  CredentialUpdateRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const CredentialUpdateRequest& from);
-  void MergeFrom(const CredentialUpdateRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // required .bgs.protocol.account.v1.AccountId account = 1;
-  inline bool has_account() const;
-  inline void clear_account();
-  static const int kAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::AccountId& account() const;
-  inline ::bgs::protocol::account::v1::AccountId* mutable_account();
-  inline ::bgs::protocol::account::v1::AccountId* release_account();
-  inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account);
-
-  // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
-  inline int old_credentials_size() const;
-  inline void clear_old_credentials();
-  static const int kOldCredentialsFieldNumber = 2;
-  inline const ::bgs::protocol::account::v1::AccountCredential& old_credentials(int index) const;
-  inline ::bgs::protocol::account::v1::AccountCredential* mutable_old_credentials(int index);
-  inline ::bgs::protocol::account::v1::AccountCredential* add_old_credentials();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
-      old_credentials() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
-      mutable_old_credentials();
-
-  // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
-  inline int new_credentials_size() const;
-  inline void clear_new_credentials();
-  static const int kNewCredentialsFieldNumber = 3;
-  inline const ::bgs::protocol::account::v1::AccountCredential& new_credentials(int index) const;
-  inline ::bgs::protocol::account::v1::AccountCredential* mutable_new_credentials(int index);
-  inline ::bgs::protocol::account::v1::AccountCredential* add_new_credentials();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
-      new_credentials() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
-      mutable_new_credentials();
-
-  // optional uint32 region = 4;
-  inline bool has_region() const;
-  inline void clear_region();
-  static const int kRegionFieldNumber = 4;
-  inline ::google::protobuf::uint32 region() const;
-  inline void set_region(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CredentialUpdateRequest)
- private:
-  inline void set_has_account();
-  inline void clear_has_account();
-  inline void set_has_region();
-  inline void clear_has_region();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::account::v1::AccountId* account_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential > old_credentials_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential > new_credentials_;
-  ::google::protobuf::uint32 region_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
   friend void protobuf_AssignDesc_account_5fservice_2eproto();
   friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static CredentialUpdateRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API CredentialUpdateResponse : public ::google::protobuf::Message {
- public:
-  CredentialUpdateResponse();
-  virtual ~CredentialUpdateResponse();
-
-  CredentialUpdateResponse(const CredentialUpdateResponse& from);
-
-  inline CredentialUpdateResponse& operator=(const CredentialUpdateResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const CredentialUpdateResponse& default_instance();
-
-  void Swap(CredentialUpdateResponse* other);
-
-  // implements Message ----------------------------------------------
-
-  CredentialUpdateResponse* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const CredentialUpdateResponse& from);
-  void MergeFrom(const CredentialUpdateResponse& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CredentialUpdateResponse)
- private:
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static CredentialUpdateResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API AccountFlagUpdateRequest : public ::google::protobuf::Message {
- public:
-  AccountFlagUpdateRequest();
-  virtual ~AccountFlagUpdateRequest();
-
-  AccountFlagUpdateRequest(const AccountFlagUpdateRequest& from);
-
-  inline AccountFlagUpdateRequest& operator=(const AccountFlagUpdateRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const AccountFlagUpdateRequest& default_instance();
-
-  void Swap(AccountFlagUpdateRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  AccountFlagUpdateRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AccountFlagUpdateRequest& from);
-  void MergeFrom(const AccountFlagUpdateRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.account.v1.AccountId account = 1;
-  inline bool has_account() const;
-  inline void clear_account();
-  static const int kAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::AccountId& account() const;
-  inline ::bgs::protocol::account::v1::AccountId* mutable_account();
-  inline ::bgs::protocol::account::v1::AccountId* release_account();
-  inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account);
-
-  // optional uint32 region = 2;
-  inline bool has_region() const;
-  inline void clear_region();
-  static const int kRegionFieldNumber = 2;
-  inline ::google::protobuf::uint32 region() const;
-  inline void set_region(::google::protobuf::uint32 value);
-
-  // optional uint64 flag = 3;
-  inline bool has_flag() const;
-  inline void clear_flag();
-  static const int kFlagFieldNumber = 3;
-  inline ::google::protobuf::uint64 flag() const;
-  inline void set_flag(::google::protobuf::uint64 value);
-
-  // optional bool active = 4;
-  inline bool has_active() const;
-  inline void clear_active();
-  static const int kActiveFieldNumber = 4;
-  inline bool active() const;
-  inline void set_active(bool value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountFlagUpdateRequest)
- private:
-  inline void set_has_account();
-  inline void clear_has_account();
-  inline void set_has_region();
-  inline void clear_has_region();
-  inline void set_has_flag();
-  inline void clear_has_flag();
-  inline void set_has_active();
-  inline void clear_has_active();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::account::v1::AccountId* account_;
-  ::google::protobuf::uint64 flag_;
-  ::google::protobuf::uint32 region_;
-  bool active_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static AccountFlagUpdateRequest* default_instance_;
+  static ResolveAccountResponse* default_instance_;
 };
 // -------------------------------------------------------------------
 
@@ -1424,14 +604,14 @@ class TC_PROTO_API IsIgrAddressRequest : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API AccountServiceRegion : public ::google::protobuf::Message {
+class TC_PROTO_API GetAccountStateRequest : public ::google::protobuf::Message {
  public:
-  AccountServiceRegion();
-  virtual ~AccountServiceRegion();
+  GetAccountStateRequest();
+  virtual ~GetAccountStateRequest();
 
-  AccountServiceRegion(const AccountServiceRegion& from);
+  GetAccountStateRequest(const GetAccountStateRequest& from);
 
-  inline AccountServiceRegion& operator=(const AccountServiceRegion& from) {
+  inline GetAccountStateRequest& operator=(const GetAccountStateRequest& from) {
     CopyFrom(from);
     return *this;
   }
@@ -1445,17 +625,17 @@ class TC_PROTO_API AccountServiceRegion : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const AccountServiceRegion& default_instance();
+  static const GetAccountStateRequest& default_instance();
 
-  void Swap(AccountServiceRegion* other);
+  void Swap(GetAccountStateRequest* other);
 
   // implements Message ----------------------------------------------
 
-  AccountServiceRegion* New() const;
+  GetAccountStateRequest* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AccountServiceRegion& from);
-  void MergeFrom(const AccountServiceRegion& from);
+  void CopyFrom(const GetAccountStateRequest& from);
+  void MergeFrom(const GetAccountStateRequest& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -1477,55 +657,86 @@ class TC_PROTO_API AccountServiceRegion : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // required uint32 id = 1;
-  inline bool has_id() const;
-  inline void clear_id();
-  static const int kIdFieldNumber = 1;
-  inline ::google::protobuf::uint32 id() const;
-  inline void set_id(::google::protobuf::uint32 value);
-
-  // required string shard = 2;
-  inline bool has_shard() const;
-  inline void clear_shard();
-  static const int kShardFieldNumber = 2;
-  inline const ::std::string& shard() const;
-  inline void set_shard(const ::std::string& value);
-  inline void set_shard(const char* value);
-  inline void set_shard(const char* value, size_t size);
-  inline ::std::string* mutable_shard();
-  inline ::std::string* release_shard();
-  inline void set_allocated_shard(::std::string* shard);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountServiceRegion)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // optional uint32 program = 2;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 2;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional uint32 region = 3;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 3;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 10;
+  inline const ::bgs::protocol::account::v1::AccountFieldOptions& options() const;
+  inline ::bgs::protocol::account::v1::AccountFieldOptions* mutable_options();
+  inline ::bgs::protocol::account::v1::AccountFieldOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::account::v1::AccountFieldOptions* options);
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
+  inline bool has_tags() const;
+  inline void clear_tags();
+  static const int kTagsFieldNumber = 11;
+  inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const;
+  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags();
+  inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags();
+  inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateRequest)
  private:
-  inline void set_has_id();
-  inline void clear_has_id();
-  inline void set_has_shard();
-  inline void clear_has_shard();
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_region();
+  inline void clear_has_region();
+  inline void set_has_options();
+  inline void clear_has_options();
+  inline void set_has_tags();
+  inline void clear_has_tags();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::std::string* shard_;
-  ::google::protobuf::uint32 id_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint32 region_;
+  ::bgs::protocol::account::v1::AccountFieldOptions* options_;
+  ::bgs::protocol::account::v1::AccountFieldTags* tags_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
   friend void protobuf_AssignDesc_account_5fservice_2eproto();
   friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static AccountServiceRegion* default_instance_;
+  static GetAccountStateRequest* default_instance_;
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API AccountServiceConfig : public ::google::protobuf::Message {
+class TC_PROTO_API GetAccountStateResponse : public ::google::protobuf::Message {
  public:
-  AccountServiceConfig();
-  virtual ~AccountServiceConfig();
+  GetAccountStateResponse();
+  virtual ~GetAccountStateResponse();
 
-  AccountServiceConfig(const AccountServiceConfig& from);
+  GetAccountStateResponse(const GetAccountStateResponse& from);
 
-  inline AccountServiceConfig& operator=(const AccountServiceConfig& from) {
+  inline GetAccountStateResponse& operator=(const GetAccountStateResponse& from) {
     CopyFrom(from);
     return *this;
   }
@@ -1539,17 +750,17 @@ class TC_PROTO_API AccountServiceConfig : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const AccountServiceConfig& default_instance();
+  static const GetAccountStateResponse& default_instance();
 
-  void Swap(AccountServiceConfig* other);
+  void Swap(GetAccountStateResponse* other);
 
   // implements Message ----------------------------------------------
 
-  AccountServiceConfig* New() const;
+  GetAccountStateResponse* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AccountServiceConfig& from);
-  void MergeFrom(const AccountServiceConfig& from);
+  void CopyFrom(const GetAccountStateResponse& from);
+  void MergeFrom(const GetAccountStateResponse& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -1571,43 +782,54 @@ class TC_PROTO_API AccountServiceConfig : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
-  inline int region_size() const;
-  inline void clear_region();
-  static const int kRegionFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::AccountServiceRegion& region(int index) const;
-  inline ::bgs::protocol::account::v1::AccountServiceRegion* mutable_region(int index);
-  inline ::bgs::protocol::account::v1::AccountServiceRegion* add_region();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >&
-      region() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >*
-      mutable_region();
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountServiceConfig)
+  // optional .bgs.protocol.account.v1.AccountState state = 1;
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountState& state() const;
+  inline ::bgs::protocol::account::v1::AccountState* mutable_state();
+  inline ::bgs::protocol::account::v1::AccountState* release_state();
+  inline void set_allocated_state(::bgs::protocol::account::v1::AccountState* state);
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
+  inline bool has_tags() const;
+  inline void clear_tags();
+  static const int kTagsFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const;
+  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags();
+  inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags();
+  inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateResponse)
  private:
+  inline void set_has_state();
+  inline void clear_has_state();
+  inline void set_has_tags();
+  inline void clear_has_tags();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion > region_;
+  ::bgs::protocol::account::v1::AccountState* state_;
+  ::bgs::protocol::account::v1::AccountFieldTags* tags_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
   friend void protobuf_AssignDesc_account_5fservice_2eproto();
   friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static AccountServiceConfig* default_instance_;
+  static GetAccountStateResponse* default_instance_;
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API GetAccountStateRequest : public ::google::protobuf::Message {
+class TC_PROTO_API GetSignedAccountStateRequest : public ::google::protobuf::Message {
  public:
-  GetAccountStateRequest();
-  virtual ~GetAccountStateRequest();
+  GetSignedAccountStateRequest();
+  virtual ~GetSignedAccountStateRequest();
 
-  GetAccountStateRequest(const GetAccountStateRequest& from);
+  GetSignedAccountStateRequest(const GetSignedAccountStateRequest& from);
 
-  inline GetAccountStateRequest& operator=(const GetAccountStateRequest& from) {
+  inline GetSignedAccountStateRequest& operator=(const GetSignedAccountStateRequest& from) {
     CopyFrom(from);
     return *this;
   }
@@ -1621,17 +843,17 @@ class TC_PROTO_API GetAccountStateRequest : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const GetAccountStateRequest& default_instance();
+  static const GetSignedAccountStateRequest& default_instance();
 
-  void Swap(GetAccountStateRequest* other);
+  void Swap(GetSignedAccountStateRequest* other);
 
   // implements Message ----------------------------------------------
 
-  GetAccountStateRequest* New() const;
+  GetSignedAccountStateRequest* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GetAccountStateRequest& from);
-  void MergeFrom(const GetAccountStateRequest& from);
+  void CopyFrom(const GetSignedAccountStateRequest& from);
+  void MergeFrom(const GetSignedAccountStateRequest& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -1653,86 +875,42 @@ class TC_PROTO_API GetAccountStateRequest : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional .bgs.protocol.EntityId entity_id = 1;
-  inline bool has_entity_id() const;
-  inline void clear_entity_id();
-  static const int kEntityIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& entity_id() const;
-  inline ::bgs::protocol::EntityId* mutable_entity_id();
-  inline ::bgs::protocol::EntityId* release_entity_id();
-  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
-
-  // optional uint32 program = 2;
-  inline bool has_program() const;
-  inline void clear_program();
-  static const int kProgramFieldNumber = 2;
-  inline ::google::protobuf::uint32 program() const;
-  inline void set_program(::google::protobuf::uint32 value);
-
-  // optional uint32 region = 3;
-  inline bool has_region() const;
-  inline void clear_region();
-  static const int kRegionFieldNumber = 3;
-  inline ::google::protobuf::uint32 region() const;
-  inline void set_region(::google::protobuf::uint32 value);
-
-  // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
-  inline bool has_options() const;
-  inline void clear_options();
-  static const int kOptionsFieldNumber = 10;
-  inline const ::bgs::protocol::account::v1::AccountFieldOptions& options() const;
-  inline ::bgs::protocol::account::v1::AccountFieldOptions* mutable_options();
-  inline ::bgs::protocol::account::v1::AccountFieldOptions* release_options();
-  inline void set_allocated_options(::bgs::protocol::account::v1::AccountFieldOptions* options);
-
-  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
-  inline bool has_tags() const;
-  inline void clear_tags();
-  static const int kTagsFieldNumber = 11;
-  inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const;
-  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags();
-  inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags();
-  inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags);
+  // optional .bgs.protocol.account.v1.AccountId account = 1;
+  inline bool has_account() const;
+  inline void clear_account();
+  static const int kAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& account() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_account();
+  inline ::bgs::protocol::account::v1::AccountId* release_account();
+  inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account);
 
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateRequest)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetSignedAccountStateRequest)
  private:
-  inline void set_has_entity_id();
-  inline void clear_has_entity_id();
-  inline void set_has_program();
-  inline void clear_has_program();
-  inline void set_has_region();
-  inline void clear_has_region();
-  inline void set_has_options();
-  inline void clear_has_options();
-  inline void set_has_tags();
-  inline void clear_has_tags();
+  inline void set_has_account();
+  inline void clear_has_account();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::bgs::protocol::EntityId* entity_id_;
-  ::google::protobuf::uint32 program_;
-  ::google::protobuf::uint32 region_;
-  ::bgs::protocol::account::v1::AccountFieldOptions* options_;
-  ::bgs::protocol::account::v1::AccountFieldTags* tags_;
+  ::bgs::protocol::account::v1::AccountId* account_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
   friend void protobuf_AssignDesc_account_5fservice_2eproto();
   friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static GetAccountStateRequest* default_instance_;
+  static GetSignedAccountStateRequest* default_instance_;
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API GetAccountStateResponse : public ::google::protobuf::Message {
+class TC_PROTO_API GetSignedAccountStateResponse : public ::google::protobuf::Message {
  public:
-  GetAccountStateResponse();
-  virtual ~GetAccountStateResponse();
+  GetSignedAccountStateResponse();
+  virtual ~GetSignedAccountStateResponse();
 
-  GetAccountStateResponse(const GetAccountStateResponse& from);
+  GetSignedAccountStateResponse(const GetSignedAccountStateResponse& from);
 
-  inline GetAccountStateResponse& operator=(const GetAccountStateResponse& from) {
+  inline GetSignedAccountStateResponse& operator=(const GetSignedAccountStateResponse& from) {
     CopyFrom(from);
     return *this;
   }
@@ -1746,17 +924,17 @@ class TC_PROTO_API GetAccountStateResponse : public ::google::protobuf::Message
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const GetAccountStateResponse& default_instance();
+  static const GetSignedAccountStateResponse& default_instance();
 
-  void Swap(GetAccountStateResponse* other);
+  void Swap(GetSignedAccountStateResponse* other);
 
   // implements Message ----------------------------------------------
 
-  GetAccountStateResponse* New() const;
+  GetSignedAccountStateResponse* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GetAccountStateResponse& from);
-  void MergeFrom(const GetAccountStateResponse& from);
+  void CopyFrom(const GetSignedAccountStateResponse& from);
+  void MergeFrom(const GetSignedAccountStateResponse& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -1778,43 +956,34 @@ class TC_PROTO_API GetAccountStateResponse : public ::google::protobuf::Message
 
   // accessors -------------------------------------------------------
 
-  // optional .bgs.protocol.account.v1.AccountState state = 1;
-  inline bool has_state() const;
-  inline void clear_state();
-  static const int kStateFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::AccountState& state() const;
-  inline ::bgs::protocol::account::v1::AccountState* mutable_state();
-  inline ::bgs::protocol::account::v1::AccountState* release_state();
-  inline void set_allocated_state(::bgs::protocol::account::v1::AccountState* state);
-
-  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
-  inline bool has_tags() const;
-  inline void clear_tags();
-  static const int kTagsFieldNumber = 2;
-  inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const;
-  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags();
-  inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags();
-  inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateResponse)
+  // optional string token = 1;
+  inline bool has_token() const;
+  inline void clear_token();
+  static const int kTokenFieldNumber = 1;
+  inline const ::std::string& token() const;
+  inline void set_token(const ::std::string& value);
+  inline void set_token(const char* value);
+  inline void set_token(const char* value, size_t size);
+  inline ::std::string* mutable_token();
+  inline ::std::string* release_token();
+  inline void set_allocated_token(::std::string* token);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetSignedAccountStateResponse)
  private:
-  inline void set_has_state();
-  inline void clear_has_state();
-  inline void set_has_tags();
-  inline void clear_has_tags();
+  inline void set_has_token();
+  inline void clear_has_token();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::bgs::protocol::account::v1::AccountState* state_;
-  ::bgs::protocol::account::v1::AccountFieldTags* tags_;
+  ::std::string* token_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
   friend void protobuf_AssignDesc_account_5fservice_2eproto();
   friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static GetAccountStateResponse* default_instance_;
+  static GetSignedAccountStateResponse* default_instance_;
 };
 // -------------------------------------------------------------------
 
@@ -2739,87 +1908,6 @@ class TC_PROTO_API GetCAISInfoResponse : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API ForwardCacheExpireRequest : public ::google::protobuf::Message {
- public:
-  ForwardCacheExpireRequest();
-  virtual ~ForwardCacheExpireRequest();
-
-  ForwardCacheExpireRequest(const ForwardCacheExpireRequest& from);
-
-  inline ForwardCacheExpireRequest& operator=(const ForwardCacheExpireRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ForwardCacheExpireRequest& default_instance();
-
-  void Swap(ForwardCacheExpireRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  ForwardCacheExpireRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ForwardCacheExpireRequest& from);
-  void MergeFrom(const ForwardCacheExpireRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId entity_id = 1;
-  inline bool has_entity_id() const;
-  inline void clear_entity_id();
-  static const int kEntityIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& entity_id() const;
-  inline ::bgs::protocol::EntityId* mutable_entity_id();
-  inline ::bgs::protocol::EntityId* release_entity_id();
-  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ForwardCacheExpireRequest)
- private:
-  inline void set_has_entity_id();
-  inline void clear_has_entity_id();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* entity_id_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static ForwardCacheExpireRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API GetAuthorizedDataRequest : public ::google::protobuf::Message {
  public:
   GetAuthorizedDataRequest();
@@ -3148,259 +2236,6 @@ class TC_PROTO_API UpdateParentalControlsAndCAISRequest : public ::google::proto
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API QueueDeductRecordRequest : public ::google::protobuf::Message {
- public:
-  QueueDeductRecordRequest();
-  virtual ~QueueDeductRecordRequest();
-
-  QueueDeductRecordRequest(const QueueDeductRecordRequest& from);
-
-  inline QueueDeductRecordRequest& operator=(const QueueDeductRecordRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const QueueDeductRecordRequest& default_instance();
-
-  void Swap(QueueDeductRecordRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  QueueDeductRecordRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const QueueDeductRecordRequest& from);
-  void MergeFrom(const QueueDeductRecordRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.account.v1.DeductRecord deduct_record = 1;
-  inline bool has_deduct_record() const;
-  inline void clear_deduct_record();
-  static const int kDeductRecordFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::DeductRecord& deduct_record() const;
-  inline ::bgs::protocol::account::v1::DeductRecord* mutable_deduct_record();
-  inline ::bgs::protocol::account::v1::DeductRecord* release_deduct_record();
-  inline void set_allocated_deduct_record(::bgs::protocol::account::v1::DeductRecord* deduct_record);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.QueueDeductRecordRequest)
- private:
-  inline void set_has_deduct_record();
-  inline void clear_has_deduct_record();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::account::v1::DeductRecord* deduct_record_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static QueueDeductRecordRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API GetGameAccountRequest : public ::google::protobuf::Message {
- public:
-  GetGameAccountRequest();
-  virtual ~GetGameAccountRequest();
-
-  GetGameAccountRequest(const GetGameAccountRequest& from);
-
-  inline GetGameAccountRequest& operator=(const GetGameAccountRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const GetGameAccountRequest& default_instance();
-
-  void Swap(GetGameAccountRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  GetGameAccountRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GetGameAccountRequest& from);
-  void MergeFrom(const GetGameAccountRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  inline bool has_game_account() const;
-  inline void clear_game_account();
-  static const int kGameAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
-  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
-  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
-  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
-
-  // optional bool reload = 2 [default = false];
-  inline bool has_reload() const;
-  inline void clear_reload();
-  static const int kReloadFieldNumber = 2;
-  inline bool reload() const;
-  inline void set_reload(bool value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameAccountRequest)
- private:
-  inline void set_has_game_account();
-  inline void clear_has_game_account();
-  inline void set_has_reload();
-  inline void clear_has_reload();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
-  bool reload_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static GetGameAccountRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API GetGameAccountResponse : public ::google::protobuf::Message {
- public:
-  GetGameAccountResponse();
-  virtual ~GetGameAccountResponse();
-
-  GetGameAccountResponse(const GetGameAccountResponse& from);
-
-  inline GetGameAccountResponse& operator=(const GetGameAccountResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const GetGameAccountResponse& default_instance();
-
-  void Swap(GetGameAccountResponse* other);
-
-  // implements Message ----------------------------------------------
-
-  GetGameAccountResponse* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GetGameAccountResponse& from);
-  void MergeFrom(const GetGameAccountResponse& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-  inline bool has_blob() const;
-  inline void clear_blob();
-  static const int kBlobFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::GameAccountBlob& blob() const;
-  inline ::bgs::protocol::account::v1::GameAccountBlob* mutable_blob();
-  inline ::bgs::protocol::account::v1::GameAccountBlob* release_blob();
-  inline void set_allocated_blob(::bgs::protocol::account::v1::GameAccountBlob* blob);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameAccountResponse)
- private:
-  inline void set_has_blob();
-  inline void clear_has_blob();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::account::v1::GameAccountBlob* blob_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
-  friend void protobuf_AssignDesc_account_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static GetGameAccountResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API AccountStateNotification : public ::google::protobuf::Message {
  public:
   AccountStateNotification();
@@ -3463,12 +2298,12 @@ class TC_PROTO_API AccountStateNotification : public ::google::protobuf::Message
   inline ::bgs::protocol::account::v1::AccountState* release_account_state();
   inline void set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state);
 
-  // optional uint64 subscriber_id = 2;
-  inline bool has_subscriber_id() const;
-  inline void clear_subscriber_id();
+  // optional uint64 subscriber_id = 2 [deprecated = true];
+  inline bool has_subscriber_id() const PROTOBUF_DEPRECATED;
+  inline void clear_subscriber_id() PROTOBUF_DEPRECATED;
   static const int kSubscriberIdFieldNumber = 2;
-  inline ::google::protobuf::uint64 subscriber_id() const;
-  inline void set_subscriber_id(::google::protobuf::uint64 value);
+  inline ::google::protobuf::uint64 subscriber_id() const PROTOBUF_DEPRECATED;
+  inline void set_subscriber_id(::google::protobuf::uint64 value) PROTOBUF_DEPRECATED;
 
   // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
   inline bool has_account_tags() const;
@@ -3576,12 +2411,12 @@ class TC_PROTO_API GameAccountStateNotification : public ::google::protobuf::Mes
   inline ::bgs::protocol::account::v1::GameAccountState* release_game_account_state();
   inline void set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state);
 
-  // optional uint64 subscriber_id = 2;
-  inline bool has_subscriber_id() const;
-  inline void clear_subscriber_id();
+  // optional uint64 subscriber_id = 2 [deprecated = true];
+  inline bool has_subscriber_id() const PROTOBUF_DEPRECATED;
+  inline void clear_subscriber_id() PROTOBUF_DEPRECATED;
   static const int kSubscriberIdFieldNumber = 2;
-  inline ::google::protobuf::uint64 subscriber_id() const;
-  inline void set_subscriber_id(::google::protobuf::uint64 value);
+  inline ::google::protobuf::uint64 subscriber_id() const PROTOBUF_DEPRECATED;
+  inline void set_subscriber_id(::google::protobuf::uint64 value) PROTOBUF_DEPRECATED;
 
   // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3;
   inline bool has_game_account_tags() const;
@@ -3838,12 +2673,8 @@ class TC_PROTO_API AccountService : public ServiceBase
 
   // client methods --------------------------------------------------
 
-  void GetGameAccountBlob(::bgs::protocol::account::v1::GameAccountHandle const* request, std::function<void(::bgs::protocol::account::v1::GameAccountBlob const*)> responseCallback);
-  void GetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAccountResponse const*)> responseCallback);
-  void CreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GameAccountHandle const*)> responseCallback);
+  void ResolveAccount(::bgs::protocol::account::v1::ResolveAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::ResolveAccountResponse const*)> responseCallback);
   void IsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void CacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request);
-  void CredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, std::function<void(::bgs::protocol::account::v1::CredentialUpdateResponse const*)> responseCallback);
   void Subscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function<void(::bgs::protocol::account::v1::SubscriptionUpdateResponse const*)> responseCallback);
   void Unsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void GetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAccountStateResponse const*)> responseCallback);
@@ -3852,25 +2683,15 @@ class TC_PROTO_API AccountService : public ServiceBase
   void GetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse const*)> responseCallback);
   void GetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameSessionInfoResponse const*)> responseCallback);
   void GetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, std::function<void(::bgs::protocol::account::v1::GetCAISInfoResponse const*)> responseCallback);
-  void ForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void GetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAuthorizedDataResponse const*)> responseCallback);
-  void AccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request);
-  void GameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request);
-  void UpdateParentalControlsAndCAIS(::bgs::protocol::account::v1::UpdateParentalControlsAndCAISRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void CreateGameAccount2(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::CreateGameAccountResponse const*)> responseCallback);
-  void GetGameAccount(::bgs::protocol::account::v1::GetGameAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameAccountResponse const*)> responseCallback);
-  void QueueDeductRecord(::bgs::protocol::account::v1::QueueDeductRecordRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void GetSignedAccountState(::bgs::protocol::account::v1::GetSignedAccountStateRequest const* request, std::function<void(::bgs::protocol::account::v1::GetSignedAccountStateResponse const*)> responseCallback);
   // server methods --------------------------------------------------
 
   void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
 
  protected:
-  virtual uint32 HandleGetGameAccountBlob(::bgs::protocol::account::v1::GameAccountHandle const* request, ::bgs::protocol::account::v1::GameAccountBlob* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleGetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, ::bgs::protocol::account::v1::GetAccountResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleCreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, ::bgs::protocol::account::v1::GameAccountHandle* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleResolveAccount(::bgs::protocol::account::v1::ResolveAccountRequest const* request, ::bgs::protocol::account::v1::ResolveAccountResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleIsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleCacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request);
-  virtual uint32 HandleCredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, ::bgs::protocol::account::v1::CredentialUpdateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleSubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::account::v1::SubscriptionUpdateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleUnsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleGetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, ::bgs::protocol::account::v1::GetAccountStateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
@@ -3879,14 +2700,8 @@ class TC_PROTO_API AccountService : public ServiceBase
   virtual uint32 HandleGetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleGetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, ::bgs::protocol::account::v1::GetGameSessionInfoResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleGetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, ::bgs::protocol::account::v1::GetCAISInfoResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleGetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, ::bgs::protocol::account::v1::GetAuthorizedDataResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleAccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request);
-  virtual uint32 HandleGameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request);
-  virtual uint32 HandleUpdateParentalControlsAndCAIS(::bgs::protocol::account::v1::UpdateParentalControlsAndCAISRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleCreateGameAccount2(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, ::bgs::protocol::account::v1::CreateGameAccountResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleGetGameAccount(::bgs::protocol::account::v1::GetGameAccountRequest const* request, ::bgs::protocol::account::v1::GetGameAccountResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleQueueDeductRecord(::bgs::protocol::account::v1::QueueDeductRecordRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleGetSignedAccountState(::bgs::protocol::account::v1::GetSignedAccountStateRequest const* request, ::bgs::protocol::account::v1::GetSignedAccountStateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
 
  private:
   uint32 service_hash_;
@@ -3935,39 +2750,39 @@ class TC_PROTO_API AccountListener : public ServiceBase
 
 // ===================================================================
 
-// GetAccountRequest
+// ResolveAccountRequest
 
 // optional .bgs.protocol.account.v1.AccountReference ref = 1;
-inline bool GetAccountRequest::has_ref() const {
+inline bool ResolveAccountRequest::has_ref() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void GetAccountRequest::set_has_ref() {
+inline void ResolveAccountRequest::set_has_ref() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void GetAccountRequest::clear_has_ref() {
+inline void ResolveAccountRequest::clear_has_ref() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void GetAccountRequest::clear_ref() {
+inline void ResolveAccountRequest::clear_ref() {
   if (ref_ != NULL) ref_->::bgs::protocol::account::v1::AccountReference::Clear();
   clear_has_ref();
 }
-inline const ::bgs::protocol::account::v1::AccountReference& GetAccountRequest::ref() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.ref)
+inline const ::bgs::protocol::account::v1::AccountReference& ResolveAccountRequest::ref() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ResolveAccountRequest.ref)
   return ref_ != NULL ? *ref_ : *default_instance_->ref_;
 }
-inline ::bgs::protocol::account::v1::AccountReference* GetAccountRequest::mutable_ref() {
+inline ::bgs::protocol::account::v1::AccountReference* ResolveAccountRequest::mutable_ref() {
   set_has_ref();
   if (ref_ == NULL) ref_ = new ::bgs::protocol::account::v1::AccountReference;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountRequest.ref)
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.ResolveAccountRequest.ref)
   return ref_;
 }
-inline ::bgs::protocol::account::v1::AccountReference* GetAccountRequest::release_ref() {
+inline ::bgs::protocol::account::v1::AccountReference* ResolveAccountRequest::release_ref() {
   clear_has_ref();
   ::bgs::protocol::account::v1::AccountReference* temp = ref_;
   ref_ = NULL;
   return temp;
 }
-inline void GetAccountRequest::set_allocated_ref(::bgs::protocol::account::v1::AccountReference* ref) {
+inline void ResolveAccountRequest::set_allocated_ref(::bgs::protocol::account::v1::AccountReference* ref) {
   delete ref_;
   ref_ = ref;
   if (ref) {
@@ -3975,325 +2790,68 @@ inline void GetAccountRequest::set_allocated_ref(::bgs::protocol::account::v1::A
   } else {
     clear_has_ref();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountRequest.ref)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.ResolveAccountRequest.ref)
 }
 
-// optional bool reload = 2 [default = false];
-inline bool GetAccountRequest::has_reload() const {
+// optional bool fetch_id = 12;
+inline bool ResolveAccountRequest::has_fetch_id() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline void GetAccountRequest::set_has_reload() {
+inline void ResolveAccountRequest::set_has_fetch_id() {
   _has_bits_[0] |= 0x00000002u;
 }
-inline void GetAccountRequest::clear_has_reload() {
+inline void ResolveAccountRequest::clear_has_fetch_id() {
   _has_bits_[0] &= ~0x00000002u;
 }
-inline void GetAccountRequest::clear_reload() {
-  reload_ = false;
-  clear_has_reload();
-}
-inline bool GetAccountRequest::reload() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.reload)
-  return reload_;
-}
-inline void GetAccountRequest::set_reload(bool value) {
-  set_has_reload();
-  reload_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.reload)
-}
-
-// optional bool fetch_all = 10 [default = false];
-inline bool GetAccountRequest::has_fetch_all() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void GetAccountRequest::set_has_fetch_all() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void GetAccountRequest::clear_has_fetch_all() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void GetAccountRequest::clear_fetch_all() {
-  fetch_all_ = false;
-  clear_has_fetch_all();
-}
-inline bool GetAccountRequest::fetch_all() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_all)
-  return fetch_all_;
-}
-inline void GetAccountRequest::set_fetch_all(bool value) {
-  set_has_fetch_all();
-  fetch_all_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_all)
-}
-
-// optional bool fetch_blob = 11 [default = false];
-inline bool GetAccountRequest::has_fetch_blob() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void GetAccountRequest::set_has_fetch_blob() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void GetAccountRequest::clear_has_fetch_blob() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void GetAccountRequest::clear_fetch_blob() {
-  fetch_blob_ = false;
-  clear_has_fetch_blob();
-}
-inline bool GetAccountRequest::fetch_blob() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_blob)
-  return fetch_blob_;
-}
-inline void GetAccountRequest::set_fetch_blob(bool value) {
-  set_has_fetch_blob();
-  fetch_blob_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_blob)
-}
-
-// optional bool fetch_id = 12 [default = false];
-inline bool GetAccountRequest::has_fetch_id() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void GetAccountRequest::set_has_fetch_id() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void GetAccountRequest::clear_has_fetch_id() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void GetAccountRequest::clear_fetch_id() {
+inline void ResolveAccountRequest::clear_fetch_id() {
   fetch_id_ = false;
   clear_has_fetch_id();
 }
-inline bool GetAccountRequest::fetch_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_id)
+inline bool ResolveAccountRequest::fetch_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ResolveAccountRequest.fetch_id)
   return fetch_id_;
 }
-inline void GetAccountRequest::set_fetch_id(bool value) {
+inline void ResolveAccountRequest::set_fetch_id(bool value) {
   set_has_fetch_id();
   fetch_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_id)
-}
-
-// optional bool fetch_email = 13 [default = false];
-inline bool GetAccountRequest::has_fetch_email() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
-}
-inline void GetAccountRequest::set_has_fetch_email() {
-  _has_bits_[0] |= 0x00000020u;
-}
-inline void GetAccountRequest::clear_has_fetch_email() {
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline void GetAccountRequest::clear_fetch_email() {
-  fetch_email_ = false;
-  clear_has_fetch_email();
-}
-inline bool GetAccountRequest::fetch_email() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_email)
-  return fetch_email_;
-}
-inline void GetAccountRequest::set_fetch_email(bool value) {
-  set_has_fetch_email();
-  fetch_email_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_email)
-}
-
-// optional bool fetch_battle_tag = 14 [default = false];
-inline bool GetAccountRequest::has_fetch_battle_tag() const {
-  return (_has_bits_[0] & 0x00000040u) != 0;
-}
-inline void GetAccountRequest::set_has_fetch_battle_tag() {
-  _has_bits_[0] |= 0x00000040u;
-}
-inline void GetAccountRequest::clear_has_fetch_battle_tag() {
-  _has_bits_[0] &= ~0x00000040u;
-}
-inline void GetAccountRequest::clear_fetch_battle_tag() {
-  fetch_battle_tag_ = false;
-  clear_has_fetch_battle_tag();
-}
-inline bool GetAccountRequest::fetch_battle_tag() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_battle_tag)
-  return fetch_battle_tag_;
-}
-inline void GetAccountRequest::set_fetch_battle_tag(bool value) {
-  set_has_fetch_battle_tag();
-  fetch_battle_tag_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_battle_tag)
-}
-
-// optional bool fetch_full_name = 15 [default = false];
-inline bool GetAccountRequest::has_fetch_full_name() const {
-  return (_has_bits_[0] & 0x00000080u) != 0;
-}
-inline void GetAccountRequest::set_has_fetch_full_name() {
-  _has_bits_[0] |= 0x00000080u;
-}
-inline void GetAccountRequest::clear_has_fetch_full_name() {
-  _has_bits_[0] &= ~0x00000080u;
-}
-inline void GetAccountRequest::clear_fetch_full_name() {
-  fetch_full_name_ = false;
-  clear_has_fetch_full_name();
-}
-inline bool GetAccountRequest::fetch_full_name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_full_name)
-  return fetch_full_name_;
-}
-inline void GetAccountRequest::set_fetch_full_name(bool value) {
-  set_has_fetch_full_name();
-  fetch_full_name_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_full_name)
-}
-
-// optional bool fetch_links = 16 [default = false];
-inline bool GetAccountRequest::has_fetch_links() const {
-  return (_has_bits_[0] & 0x00000100u) != 0;
-}
-inline void GetAccountRequest::set_has_fetch_links() {
-  _has_bits_[0] |= 0x00000100u;
-}
-inline void GetAccountRequest::clear_has_fetch_links() {
-  _has_bits_[0] &= ~0x00000100u;
-}
-inline void GetAccountRequest::clear_fetch_links() {
-  fetch_links_ = false;
-  clear_has_fetch_links();
-}
-inline bool GetAccountRequest::fetch_links() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_links)
-  return fetch_links_;
-}
-inline void GetAccountRequest::set_fetch_links(bool value) {
-  set_has_fetch_links();
-  fetch_links_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_links)
-}
-
-// optional bool fetch_parental_controls = 17 [default = false];
-inline bool GetAccountRequest::has_fetch_parental_controls() const {
-  return (_has_bits_[0] & 0x00000200u) != 0;
-}
-inline void GetAccountRequest::set_has_fetch_parental_controls() {
-  _has_bits_[0] |= 0x00000200u;
-}
-inline void GetAccountRequest::clear_has_fetch_parental_controls() {
-  _has_bits_[0] &= ~0x00000200u;
-}
-inline void GetAccountRequest::clear_fetch_parental_controls() {
-  fetch_parental_controls_ = false;
-  clear_has_fetch_parental_controls();
-}
-inline bool GetAccountRequest::fetch_parental_controls() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_parental_controls)
-  return fetch_parental_controls_;
-}
-inline void GetAccountRequest::set_fetch_parental_controls(bool value) {
-  set_has_fetch_parental_controls();
-  fetch_parental_controls_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_parental_controls)
-}
-
-// optional bool fetch_cais_id = 18 [default = false];
-inline bool GetAccountRequest::has_fetch_cais_id() const {
-  return (_has_bits_[0] & 0x00000400u) != 0;
-}
-inline void GetAccountRequest::set_has_fetch_cais_id() {
-  _has_bits_[0] |= 0x00000400u;
-}
-inline void GetAccountRequest::clear_has_fetch_cais_id() {
-  _has_bits_[0] &= ~0x00000400u;
-}
-inline void GetAccountRequest::clear_fetch_cais_id() {
-  fetch_cais_id_ = false;
-  clear_has_fetch_cais_id();
-}
-inline bool GetAccountRequest::fetch_cais_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_cais_id)
-  return fetch_cais_id_;
-}
-inline void GetAccountRequest::set_fetch_cais_id(bool value) {
-  set_has_fetch_cais_id();
-  fetch_cais_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_cais_id)
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ResolveAccountRequest.fetch_id)
 }
 
 // -------------------------------------------------------------------
 
-// GetAccountResponse
+// ResolveAccountResponse
 
-// optional .bgs.protocol.account.v1.AccountBlob blob = 11;
-inline bool GetAccountResponse::has_blob() const {
+// optional .bgs.protocol.account.v1.AccountId id = 12;
+inline bool ResolveAccountResponse::has_id() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void GetAccountResponse::set_has_blob() {
+inline void ResolveAccountResponse::set_has_id() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void GetAccountResponse::clear_has_blob() {
+inline void ResolveAccountResponse::clear_has_id() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void GetAccountResponse::clear_blob() {
-  if (blob_ != NULL) blob_->::bgs::protocol::account::v1::AccountBlob::Clear();
-  clear_has_blob();
-}
-inline const ::bgs::protocol::account::v1::AccountBlob& GetAccountResponse::blob() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.blob)
-  return blob_ != NULL ? *blob_ : *default_instance_->blob_;
-}
-inline ::bgs::protocol::account::v1::AccountBlob* GetAccountResponse::mutable_blob() {
-  set_has_blob();
-  if (blob_ == NULL) blob_ = new ::bgs::protocol::account::v1::AccountBlob;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.blob)
-  return blob_;
-}
-inline ::bgs::protocol::account::v1::AccountBlob* GetAccountResponse::release_blob() {
-  clear_has_blob();
-  ::bgs::protocol::account::v1::AccountBlob* temp = blob_;
-  blob_ = NULL;
-  return temp;
-}
-inline void GetAccountResponse::set_allocated_blob(::bgs::protocol::account::v1::AccountBlob* blob) {
-  delete blob_;
-  blob_ = blob;
-  if (blob) {
-    set_has_blob();
-  } else {
-    clear_has_blob();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.blob)
-}
-
-// optional .bgs.protocol.account.v1.AccountId id = 12;
-inline bool GetAccountResponse::has_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void GetAccountResponse::set_has_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void GetAccountResponse::clear_has_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void GetAccountResponse::clear_id() {
+inline void ResolveAccountResponse::clear_id() {
   if (id_ != NULL) id_->::bgs::protocol::account::v1::AccountId::Clear();
   clear_has_id();
 }
-inline const ::bgs::protocol::account::v1::AccountId& GetAccountResponse::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.id)
+inline const ::bgs::protocol::account::v1::AccountId& ResolveAccountResponse::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ResolveAccountResponse.id)
   return id_ != NULL ? *id_ : *default_instance_->id_;
 }
-inline ::bgs::protocol::account::v1::AccountId* GetAccountResponse::mutable_id() {
+inline ::bgs::protocol::account::v1::AccountId* ResolveAccountResponse::mutable_id() {
   set_has_id();
   if (id_ == NULL) id_ = new ::bgs::protocol::account::v1::AccountId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.id)
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.ResolveAccountResponse.id)
   return id_;
 }
-inline ::bgs::protocol::account::v1::AccountId* GetAccountResponse::release_id() {
+inline ::bgs::protocol::account::v1::AccountId* ResolveAccountResponse::release_id() {
   clear_has_id();
   ::bgs::protocol::account::v1::AccountId* temp = id_;
   id_ = NULL;
   return temp;
 }
-inline void GetAccountResponse::set_allocated_id(::bgs::protocol::account::v1::AccountId* id) {
+inline void ResolveAccountResponse::set_allocated_id(::bgs::protocol::account::v1::AccountId* id) {
   delete id_;
   id_ = id;
   if (id) {
@@ -4301,938 +2859,7 @@ inline void GetAccountResponse::set_allocated_id(::bgs::protocol::account::v1::A
   } else {
     clear_has_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.id)
-}
-
-// repeated string email = 13;
-inline int GetAccountResponse::email_size() const {
-  return email_.size();
-}
-inline void GetAccountResponse::clear_email() {
-  email_.Clear();
-}
-inline const ::std::string& GetAccountResponse::email(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.email)
-  return email_.Get(index);
-}
-inline ::std::string* GetAccountResponse::mutable_email(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.email)
-  return email_.Mutable(index);
-}
-inline void GetAccountResponse::set_email(int index, const ::std::string& value) {
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountResponse.email)
-  email_.Mutable(index)->assign(value);
-}
-inline void GetAccountResponse::set_email(int index, const char* value) {
-  email_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAccountResponse.email)
-}
-inline void GetAccountResponse::set_email(int index, const char* value, size_t size) {
-  email_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAccountResponse.email)
-}
-inline ::std::string* GetAccountResponse::add_email() {
-  return email_.Add();
-}
-inline void GetAccountResponse::add_email(const ::std::string& value) {
-  email_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAccountResponse.email)
-}
-inline void GetAccountResponse::add_email(const char* value) {
-  email_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.GetAccountResponse.email)
-}
-inline void GetAccountResponse::add_email(const char* value, size_t size) {
-  email_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.GetAccountResponse.email)
-}
-inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
-GetAccountResponse::email() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAccountResponse.email)
-  return email_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::std::string>*
-GetAccountResponse::mutable_email() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAccountResponse.email)
-  return &email_;
-}
-
-// optional string battle_tag = 14;
-inline bool GetAccountResponse::has_battle_tag() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void GetAccountResponse::set_has_battle_tag() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void GetAccountResponse::clear_has_battle_tag() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void GetAccountResponse::clear_battle_tag() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_->clear();
-  }
-  clear_has_battle_tag();
-}
-inline const ::std::string& GetAccountResponse::battle_tag() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.battle_tag)
-  return *battle_tag_;
-}
-inline void GetAccountResponse::set_battle_tag(const ::std::string& value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountResponse.battle_tag)
-}
-inline void GetAccountResponse::set_battle_tag(const char* value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAccountResponse.battle_tag)
-}
-inline void GetAccountResponse::set_battle_tag(const char* value, size_t size) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAccountResponse.battle_tag)
-}
-inline ::std::string* GetAccountResponse::mutable_battle_tag() {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.battle_tag)
-  return battle_tag_;
-}
-inline ::std::string* GetAccountResponse::release_battle_tag() {
-  clear_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = battle_tag_;
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void GetAccountResponse::set_allocated_battle_tag(::std::string* battle_tag) {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (battle_tag) {
-    set_has_battle_tag();
-    battle_tag_ = battle_tag;
-  } else {
-    clear_has_battle_tag();
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.battle_tag)
-}
-
-// optional string full_name = 15;
-inline bool GetAccountResponse::has_full_name() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void GetAccountResponse::set_has_full_name() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void GetAccountResponse::clear_has_full_name() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void GetAccountResponse::clear_full_name() {
-  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_->clear();
-  }
-  clear_has_full_name();
-}
-inline const ::std::string& GetAccountResponse::full_name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.full_name)
-  return *full_name_;
-}
-inline void GetAccountResponse::set_full_name(const ::std::string& value) {
-  set_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_ = new ::std::string;
-  }
-  full_name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountResponse.full_name)
-}
-inline void GetAccountResponse::set_full_name(const char* value) {
-  set_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_ = new ::std::string;
-  }
-  full_name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAccountResponse.full_name)
-}
-inline void GetAccountResponse::set_full_name(const char* value, size_t size) {
-  set_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_ = new ::std::string;
-  }
-  full_name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAccountResponse.full_name)
-}
-inline ::std::string* GetAccountResponse::mutable_full_name() {
-  set_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.full_name)
-  return full_name_;
-}
-inline ::std::string* GetAccountResponse::release_full_name() {
-  clear_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = full_name_;
-    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void GetAccountResponse::set_allocated_full_name(::std::string* full_name) {
-  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete full_name_;
-  }
-  if (full_name) {
-    set_has_full_name();
-    full_name_ = full_name;
-  } else {
-    clear_has_full_name();
-    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.full_name)
-}
-
-// repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
-inline int GetAccountResponse::links_size() const {
-  return links_.size();
-}
-inline void GetAccountResponse::clear_links() {
-  links_.Clear();
-}
-inline const ::bgs::protocol::account::v1::GameAccountLink& GetAccountResponse::links(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.links)
-  return links_.Get(index);
-}
-inline ::bgs::protocol::account::v1::GameAccountLink* GetAccountResponse::mutable_links(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.links)
-  return links_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::GameAccountLink* GetAccountResponse::add_links() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAccountResponse.links)
-  return links_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >&
-GetAccountResponse::links() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAccountResponse.links)
-  return links_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >*
-GetAccountResponse::mutable_links() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAccountResponse.links)
-  return &links_;
-}
-
-// optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
-inline bool GetAccountResponse::has_parental_control_info() const {
-  return (_has_bits_[0] & 0x00000040u) != 0;
-}
-inline void GetAccountResponse::set_has_parental_control_info() {
-  _has_bits_[0] |= 0x00000040u;
-}
-inline void GetAccountResponse::clear_has_parental_control_info() {
-  _has_bits_[0] &= ~0x00000040u;
-}
-inline void GetAccountResponse::clear_parental_control_info() {
-  if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
-  clear_has_parental_control_info();
-}
-inline const ::bgs::protocol::account::v1::ParentalControlInfo& GetAccountResponse::parental_control_info() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.parental_control_info)
-  return parental_control_info_ != NULL ? *parental_control_info_ : *default_instance_->parental_control_info_;
-}
-inline ::bgs::protocol::account::v1::ParentalControlInfo* GetAccountResponse::mutable_parental_control_info() {
-  set_has_parental_control_info();
-  if (parental_control_info_ == NULL) parental_control_info_ = new ::bgs::protocol::account::v1::ParentalControlInfo;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.parental_control_info)
-  return parental_control_info_;
-}
-inline ::bgs::protocol::account::v1::ParentalControlInfo* GetAccountResponse::release_parental_control_info() {
-  clear_has_parental_control_info();
-  ::bgs::protocol::account::v1::ParentalControlInfo* temp = parental_control_info_;
-  parental_control_info_ = NULL;
-  return temp;
-}
-inline void GetAccountResponse::set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info) {
-  delete parental_control_info_;
-  parental_control_info_ = parental_control_info;
-  if (parental_control_info) {
-    set_has_parental_control_info();
-  } else {
-    clear_has_parental_control_info();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.parental_control_info)
-}
-
-// optional string cais_id = 18;
-inline bool GetAccountResponse::has_cais_id() const {
-  return (_has_bits_[0] & 0x00000080u) != 0;
-}
-inline void GetAccountResponse::set_has_cais_id() {
-  _has_bits_[0] |= 0x00000080u;
-}
-inline void GetAccountResponse::clear_has_cais_id() {
-  _has_bits_[0] &= ~0x00000080u;
-}
-inline void GetAccountResponse::clear_cais_id() {
-  if (cais_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_->clear();
-  }
-  clear_has_cais_id();
-}
-inline const ::std::string& GetAccountResponse::cais_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.cais_id)
-  return *cais_id_;
-}
-inline void GetAccountResponse::set_cais_id(const ::std::string& value) {
-  set_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_ = new ::std::string;
-  }
-  cais_id_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountResponse.cais_id)
-}
-inline void GetAccountResponse::set_cais_id(const char* value) {
-  set_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_ = new ::std::string;
-  }
-  cais_id_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAccountResponse.cais_id)
-}
-inline void GetAccountResponse::set_cais_id(const char* value, size_t size) {
-  set_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_ = new ::std::string;
-  }
-  cais_id_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAccountResponse.cais_id)
-}
-inline ::std::string* GetAccountResponse::mutable_cais_id() {
-  set_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.cais_id)
-  return cais_id_;
-}
-inline ::std::string* GetAccountResponse::release_cais_id() {
-  clear_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = cais_id_;
-    cais_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void GetAccountResponse::set_allocated_cais_id(::std::string* cais_id) {
-  if (cais_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete cais_id_;
-  }
-  if (cais_id) {
-    set_has_cais_id();
-    cais_id_ = cais_id;
-  } else {
-    clear_has_cais_id();
-    cais_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.cais_id)
-}
-
-// -------------------------------------------------------------------
-
-// CreateGameAccountRequest
-
-// optional .bgs.protocol.account.v1.AccountId account = 1;
-inline bool CreateGameAccountRequest::has_account() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void CreateGameAccountRequest::set_has_account() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void CreateGameAccountRequest::clear_has_account() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void CreateGameAccountRequest::clear_account() {
-  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
-  clear_has_account();
-}
-inline const ::bgs::protocol::account::v1::AccountId& CreateGameAccountRequest::account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.account)
-  return account_ != NULL ? *account_ : *default_instance_->account_;
-}
-inline ::bgs::protocol::account::v1::AccountId* CreateGameAccountRequest::mutable_account() {
-  set_has_account();
-  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CreateGameAccountRequest.account)
-  return account_;
-}
-inline ::bgs::protocol::account::v1::AccountId* CreateGameAccountRequest::release_account() {
-  clear_has_account();
-  ::bgs::protocol::account::v1::AccountId* temp = account_;
-  account_ = NULL;
-  return temp;
-}
-inline void CreateGameAccountRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) {
-  delete account_;
-  account_ = account;
-  if (account) {
-    set_has_account();
-  } else {
-    clear_has_account();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.CreateGameAccountRequest.account)
-}
-
-// optional uint32 region = 2;
-inline bool CreateGameAccountRequest::has_region() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void CreateGameAccountRequest::set_has_region() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void CreateGameAccountRequest::clear_has_region() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void CreateGameAccountRequest::clear_region() {
-  region_ = 0u;
-  clear_has_region();
-}
-inline ::google::protobuf::uint32 CreateGameAccountRequest::region() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.region)
-  return region_;
-}
-inline void CreateGameAccountRequest::set_region(::google::protobuf::uint32 value) {
-  set_has_region();
-  region_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.region)
-}
-
-// optional fixed32 program = 3;
-inline bool CreateGameAccountRequest::has_program() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void CreateGameAccountRequest::set_has_program() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void CreateGameAccountRequest::clear_has_program() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void CreateGameAccountRequest::clear_program() {
-  program_ = 0u;
-  clear_has_program();
-}
-inline ::google::protobuf::uint32 CreateGameAccountRequest::program() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.program)
-  return program_;
-}
-inline void CreateGameAccountRequest::set_program(::google::protobuf::uint32 value) {
-  set_has_program();
-  program_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.program)
-}
-
-// optional uint32 realm_permissions = 4 [default = 0];
-inline bool CreateGameAccountRequest::has_realm_permissions() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void CreateGameAccountRequest::set_has_realm_permissions() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void CreateGameAccountRequest::clear_has_realm_permissions() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void CreateGameAccountRequest::clear_realm_permissions() {
-  realm_permissions_ = 0u;
-  clear_has_realm_permissions();
-}
-inline ::google::protobuf::uint32 CreateGameAccountRequest::realm_permissions() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.realm_permissions)
-  return realm_permissions_;
-}
-inline void CreateGameAccountRequest::set_realm_permissions(::google::protobuf::uint32 value) {
-  set_has_realm_permissions();
-  realm_permissions_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.realm_permissions)
-}
-
-// optional uint32 account_region = 5;
-inline bool CreateGameAccountRequest::has_account_region() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void CreateGameAccountRequest::set_has_account_region() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void CreateGameAccountRequest::clear_has_account_region() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void CreateGameAccountRequest::clear_account_region() {
-  account_region_ = 0u;
-  clear_has_account_region();
-}
-inline ::google::protobuf::uint32 CreateGameAccountRequest::account_region() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.account_region)
-  return account_region_;
-}
-inline void CreateGameAccountRequest::set_account_region(::google::protobuf::uint32 value) {
-  set_has_account_region();
-  account_region_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.account_region)
-}
-
-// optional fixed32 platform = 6;
-inline bool CreateGameAccountRequest::has_platform() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
-}
-inline void CreateGameAccountRequest::set_has_platform() {
-  _has_bits_[0] |= 0x00000020u;
-}
-inline void CreateGameAccountRequest::clear_has_platform() {
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline void CreateGameAccountRequest::clear_platform() {
-  platform_ = 0u;
-  clear_has_platform();
-}
-inline ::google::protobuf::uint32 CreateGameAccountRequest::platform() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.platform)
-  return platform_;
-}
-inline void CreateGameAccountRequest::set_platform(::google::protobuf::uint32 value) {
-  set_has_platform();
-  platform_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.platform)
-}
-
-// -------------------------------------------------------------------
-
-// CreateGameAccountResponse
-
-// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-inline bool CreateGameAccountResponse::has_game_account() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void CreateGameAccountResponse::set_has_game_account() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void CreateGameAccountResponse::clear_has_game_account() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void CreateGameAccountResponse::clear_game_account() {
-  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-  clear_has_game_account();
-}
-inline const ::bgs::protocol::account::v1::GameAccountHandle& CreateGameAccountResponse::game_account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountResponse.game_account)
-  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* CreateGameAccountResponse::mutable_game_account() {
-  set_has_game_account();
-  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CreateGameAccountResponse.game_account)
-  return game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* CreateGameAccountResponse::release_game_account() {
-  clear_has_game_account();
-  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
-  game_account_ = NULL;
-  return temp;
-}
-inline void CreateGameAccountResponse::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
-  delete game_account_;
-  game_account_ = game_account;
-  if (game_account) {
-    set_has_game_account();
-  } else {
-    clear_has_game_account();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.CreateGameAccountResponse.game_account)
-}
-
-// -------------------------------------------------------------------
-
-// CacheExpireRequest
-
-// repeated .bgs.protocol.account.v1.AccountId account = 1;
-inline int CacheExpireRequest::account_size() const {
-  return account_.size();
-}
-inline void CacheExpireRequest::clear_account() {
-  account_.Clear();
-}
-inline const ::bgs::protocol::account::v1::AccountId& CacheExpireRequest::account(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CacheExpireRequest.account)
-  return account_.Get(index);
-}
-inline ::bgs::protocol::account::v1::AccountId* CacheExpireRequest::mutable_account(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CacheExpireRequest.account)
-  return account_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::AccountId* CacheExpireRequest::add_account() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CacheExpireRequest.account)
-  return account_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >&
-CacheExpireRequest::account() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CacheExpireRequest.account)
-  return account_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >*
-CacheExpireRequest::mutable_account() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CacheExpireRequest.account)
-  return &account_;
-}
-
-// repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
-inline int CacheExpireRequest::game_account_size() const {
-  return game_account_.size();
-}
-inline void CacheExpireRequest::clear_game_account() {
-  game_account_.Clear();
-}
-inline const ::bgs::protocol::account::v1::GameAccountHandle& CacheExpireRequest::game_account(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CacheExpireRequest.game_account)
-  return game_account_.Get(index);
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* CacheExpireRequest::mutable_game_account(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CacheExpireRequest.game_account)
-  return game_account_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* CacheExpireRequest::add_game_account() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CacheExpireRequest.game_account)
-  return game_account_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >&
-CacheExpireRequest::game_account() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CacheExpireRequest.game_account)
-  return game_account_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >*
-CacheExpireRequest::mutable_game_account() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CacheExpireRequest.game_account)
-  return &game_account_;
-}
-
-// repeated string email = 3;
-inline int CacheExpireRequest::email_size() const {
-  return email_.size();
-}
-inline void CacheExpireRequest::clear_email() {
-  email_.Clear();
-}
-inline const ::std::string& CacheExpireRequest::email(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CacheExpireRequest.email)
-  return email_.Get(index);
-}
-inline ::std::string* CacheExpireRequest::mutable_email(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CacheExpireRequest.email)
-  return email_.Mutable(index);
-}
-inline void CacheExpireRequest::set_email(int index, const ::std::string& value) {
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CacheExpireRequest.email)
-  email_.Mutable(index)->assign(value);
-}
-inline void CacheExpireRequest::set_email(int index, const char* value) {
-  email_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.CacheExpireRequest.email)
-}
-inline void CacheExpireRequest::set_email(int index, const char* value, size_t size) {
-  email_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.CacheExpireRequest.email)
-}
-inline ::std::string* CacheExpireRequest::add_email() {
-  return email_.Add();
-}
-inline void CacheExpireRequest::add_email(const ::std::string& value) {
-  email_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CacheExpireRequest.email)
-}
-inline void CacheExpireRequest::add_email(const char* value) {
-  email_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.CacheExpireRequest.email)
-}
-inline void CacheExpireRequest::add_email(const char* value, size_t size) {
-  email_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.CacheExpireRequest.email)
-}
-inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
-CacheExpireRequest::email() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CacheExpireRequest.email)
-  return email_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::std::string>*
-CacheExpireRequest::mutable_email() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CacheExpireRequest.email)
-  return &email_;
-}
-
-// -------------------------------------------------------------------
-
-// CredentialUpdateRequest
-
-// required .bgs.protocol.account.v1.AccountId account = 1;
-inline bool CredentialUpdateRequest::has_account() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void CredentialUpdateRequest::set_has_account() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void CredentialUpdateRequest::clear_has_account() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void CredentialUpdateRequest::clear_account() {
-  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
-  clear_has_account();
-}
-inline const ::bgs::protocol::account::v1::AccountId& CredentialUpdateRequest::account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.account)
-  return account_ != NULL ? *account_ : *default_instance_->account_;
-}
-inline ::bgs::protocol::account::v1::AccountId* CredentialUpdateRequest::mutable_account() {
-  set_has_account();
-  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CredentialUpdateRequest.account)
-  return account_;
-}
-inline ::bgs::protocol::account::v1::AccountId* CredentialUpdateRequest::release_account() {
-  clear_has_account();
-  ::bgs::protocol::account::v1::AccountId* temp = account_;
-  account_ = NULL;
-  return temp;
-}
-inline void CredentialUpdateRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) {
-  delete account_;
-  account_ = account;
-  if (account) {
-    set_has_account();
-  } else {
-    clear_has_account();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.CredentialUpdateRequest.account)
-}
-
-// repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
-inline int CredentialUpdateRequest::old_credentials_size() const {
-  return old_credentials_.size();
-}
-inline void CredentialUpdateRequest::clear_old_credentials() {
-  old_credentials_.Clear();
-}
-inline const ::bgs::protocol::account::v1::AccountCredential& CredentialUpdateRequest::old_credentials(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
-  return old_credentials_.Get(index);
-}
-inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::mutable_old_credentials(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
-  return old_credentials_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::add_old_credentials() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
-  return old_credentials_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
-CredentialUpdateRequest::old_credentials() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
-  return old_credentials_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
-CredentialUpdateRequest::mutable_old_credentials() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
-  return &old_credentials_;
-}
-
-// repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
-inline int CredentialUpdateRequest::new_credentials_size() const {
-  return new_credentials_.size();
-}
-inline void CredentialUpdateRequest::clear_new_credentials() {
-  new_credentials_.Clear();
-}
-inline const ::bgs::protocol::account::v1::AccountCredential& CredentialUpdateRequest::new_credentials(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
-  return new_credentials_.Get(index);
-}
-inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::mutable_new_credentials(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
-  return new_credentials_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::add_new_credentials() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
-  return new_credentials_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
-CredentialUpdateRequest::new_credentials() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
-  return new_credentials_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
-CredentialUpdateRequest::mutable_new_credentials() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
-  return &new_credentials_;
-}
-
-// optional uint32 region = 4;
-inline bool CredentialUpdateRequest::has_region() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void CredentialUpdateRequest::set_has_region() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void CredentialUpdateRequest::clear_has_region() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void CredentialUpdateRequest::clear_region() {
-  region_ = 0u;
-  clear_has_region();
-}
-inline ::google::protobuf::uint32 CredentialUpdateRequest::region() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.region)
-  return region_;
-}
-inline void CredentialUpdateRequest::set_region(::google::protobuf::uint32 value) {
-  set_has_region();
-  region_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CredentialUpdateRequest.region)
-}
-
-// -------------------------------------------------------------------
-
-// CredentialUpdateResponse
-
-// -------------------------------------------------------------------
-
-// AccountFlagUpdateRequest
-
-// optional .bgs.protocol.account.v1.AccountId account = 1;
-inline bool AccountFlagUpdateRequest::has_account() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void AccountFlagUpdateRequest::set_has_account() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void AccountFlagUpdateRequest::clear_has_account() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void AccountFlagUpdateRequest::clear_account() {
-  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
-  clear_has_account();
-}
-inline const ::bgs::protocol::account::v1::AccountId& AccountFlagUpdateRequest::account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.account)
-  return account_ != NULL ? *account_ : *default_instance_->account_;
-}
-inline ::bgs::protocol::account::v1::AccountId* AccountFlagUpdateRequest::mutable_account() {
-  set_has_account();
-  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountFlagUpdateRequest.account)
-  return account_;
-}
-inline ::bgs::protocol::account::v1::AccountId* AccountFlagUpdateRequest::release_account() {
-  clear_has_account();
-  ::bgs::protocol::account::v1::AccountId* temp = account_;
-  account_ = NULL;
-  return temp;
-}
-inline void AccountFlagUpdateRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) {
-  delete account_;
-  account_ = account;
-  if (account) {
-    set_has_account();
-  } else {
-    clear_has_account();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountFlagUpdateRequest.account)
-}
-
-// optional uint32 region = 2;
-inline bool AccountFlagUpdateRequest::has_region() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void AccountFlagUpdateRequest::set_has_region() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void AccountFlagUpdateRequest::clear_has_region() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void AccountFlagUpdateRequest::clear_region() {
-  region_ = 0u;
-  clear_has_region();
-}
-inline ::google::protobuf::uint32 AccountFlagUpdateRequest::region() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.region)
-  return region_;
-}
-inline void AccountFlagUpdateRequest::set_region(::google::protobuf::uint32 value) {
-  set_has_region();
-  region_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFlagUpdateRequest.region)
-}
-
-// optional uint64 flag = 3;
-inline bool AccountFlagUpdateRequest::has_flag() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void AccountFlagUpdateRequest::set_has_flag() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void AccountFlagUpdateRequest::clear_has_flag() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void AccountFlagUpdateRequest::clear_flag() {
-  flag_ = GOOGLE_ULONGLONG(0);
-  clear_has_flag();
-}
-inline ::google::protobuf::uint64 AccountFlagUpdateRequest::flag() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.flag)
-  return flag_;
-}
-inline void AccountFlagUpdateRequest::set_flag(::google::protobuf::uint64 value) {
-  set_has_flag();
-  flag_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFlagUpdateRequest.flag)
-}
-
-// optional bool active = 4;
-inline bool AccountFlagUpdateRequest::has_active() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void AccountFlagUpdateRequest::set_has_active() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void AccountFlagUpdateRequest::clear_has_active() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void AccountFlagUpdateRequest::clear_active() {
-  active_ = false;
-  clear_has_active();
-}
-inline bool AccountFlagUpdateRequest::active() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.active)
-  return active_;
-}
-inline void AccountFlagUpdateRequest::set_active(bool value) {
-  set_has_active();
-  active_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFlagUpdateRequest.active)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.ResolveAccountResponse.id)
 }
 
 // -------------------------------------------------------------------
@@ -5502,144 +3129,6 @@ inline void IsIgrAddressRequest::set_region(::google::protobuf::uint32 value) {
 
 // -------------------------------------------------------------------
 
-// AccountServiceRegion
-
-// required uint32 id = 1;
-inline bool AccountServiceRegion::has_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void AccountServiceRegion::set_has_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void AccountServiceRegion::clear_has_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void AccountServiceRegion::clear_id() {
-  id_ = 0u;
-  clear_has_id();
-}
-inline ::google::protobuf::uint32 AccountServiceRegion::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountServiceRegion.id)
-  return id_;
-}
-inline void AccountServiceRegion::set_id(::google::protobuf::uint32 value) {
-  set_has_id();
-  id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountServiceRegion.id)
-}
-
-// required string shard = 2;
-inline bool AccountServiceRegion::has_shard() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void AccountServiceRegion::set_has_shard() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void AccountServiceRegion::clear_has_shard() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void AccountServiceRegion::clear_shard() {
-  if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    shard_->clear();
-  }
-  clear_has_shard();
-}
-inline const ::std::string& AccountServiceRegion::shard() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountServiceRegion.shard)
-  return *shard_;
-}
-inline void AccountServiceRegion::set_shard(const ::std::string& value) {
-  set_has_shard();
-  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    shard_ = new ::std::string;
-  }
-  shard_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountServiceRegion.shard)
-}
-inline void AccountServiceRegion::set_shard(const char* value) {
-  set_has_shard();
-  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    shard_ = new ::std::string;
-  }
-  shard_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountServiceRegion.shard)
-}
-inline void AccountServiceRegion::set_shard(const char* value, size_t size) {
-  set_has_shard();
-  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    shard_ = new ::std::string;
-  }
-  shard_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountServiceRegion.shard)
-}
-inline ::std::string* AccountServiceRegion::mutable_shard() {
-  set_has_shard();
-  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    shard_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountServiceRegion.shard)
-  return shard_;
-}
-inline ::std::string* AccountServiceRegion::release_shard() {
-  clear_has_shard();
-  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = shard_;
-    shard_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void AccountServiceRegion::set_allocated_shard(::std::string* shard) {
-  if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete shard_;
-  }
-  if (shard) {
-    set_has_shard();
-    shard_ = shard;
-  } else {
-    clear_has_shard();
-    shard_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountServiceRegion.shard)
-}
-
-// -------------------------------------------------------------------
-
-// AccountServiceConfig
-
-// repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
-inline int AccountServiceConfig::region_size() const {
-  return region_.size();
-}
-inline void AccountServiceConfig::clear_region() {
-  region_.Clear();
-}
-inline const ::bgs::protocol::account::v1::AccountServiceRegion& AccountServiceConfig::region(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountServiceConfig.region)
-  return region_.Get(index);
-}
-inline ::bgs::protocol::account::v1::AccountServiceRegion* AccountServiceConfig::mutable_region(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountServiceConfig.region)
-  return region_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::AccountServiceRegion* AccountServiceConfig::add_region() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountServiceConfig.region)
-  return region_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >&
-AccountServiceConfig::region() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountServiceConfig.region)
-  return region_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >*
-AccountServiceConfig::mutable_region() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountServiceConfig.region)
-  return &region_;
-}
-
-// -------------------------------------------------------------------
-
 // GetAccountStateRequest
 
 // optional .bgs.protocol.EntityId entity_id = 1;
@@ -5901,6 +3390,131 @@ inline void GetAccountStateResponse::set_allocated_tags(::bgs::protocol::account
 
 // -------------------------------------------------------------------
 
+// GetSignedAccountStateRequest
+
+// optional .bgs.protocol.account.v1.AccountId account = 1;
+inline bool GetSignedAccountStateRequest::has_account() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetSignedAccountStateRequest::set_has_account() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetSignedAccountStateRequest::clear_has_account() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetSignedAccountStateRequest::clear_account() {
+  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_account();
+}
+inline const ::bgs::protocol::account::v1::AccountId& GetSignedAccountStateRequest::account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetSignedAccountStateRequest.account)
+  return account_ != NULL ? *account_ : *default_instance_->account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* GetSignedAccountStateRequest::mutable_account() {
+  set_has_account();
+  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetSignedAccountStateRequest.account)
+  return account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* GetSignedAccountStateRequest::release_account() {
+  clear_has_account();
+  ::bgs::protocol::account::v1::AccountId* temp = account_;
+  account_ = NULL;
+  return temp;
+}
+inline void GetSignedAccountStateRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) {
+  delete account_;
+  account_ = account;
+  if (account) {
+    set_has_account();
+  } else {
+    clear_has_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetSignedAccountStateRequest.account)
+}
+
+// -------------------------------------------------------------------
+
+// GetSignedAccountStateResponse
+
+// optional string token = 1;
+inline bool GetSignedAccountStateResponse::has_token() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetSignedAccountStateResponse::set_has_token() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetSignedAccountStateResponse::clear_has_token() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetSignedAccountStateResponse::clear_token() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_->clear();
+  }
+  clear_has_token();
+}
+inline const ::std::string& GetSignedAccountStateResponse::token() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
+  return *token_;
+}
+inline void GetSignedAccountStateResponse::set_token(const ::std::string& value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
+}
+inline void GetSignedAccountStateResponse::set_token(const char* value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
+}
+inline void GetSignedAccountStateResponse::set_token(const char* value, size_t size) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
+}
+inline ::std::string* GetSignedAccountStateResponse::mutable_token() {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
+  return token_;
+}
+inline ::std::string* GetSignedAccountStateResponse::release_token() {
+  clear_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = token_;
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GetSignedAccountStateResponse::set_allocated_token(::std::string* token) {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  if (token) {
+    set_has_token();
+    token_ = token;
+  } else {
+    clear_has_token();
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
+}
+
+// -------------------------------------------------------------------
+
 // GetGameAccountStateRequest
 
 // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true];
@@ -6665,51 +4279,6 @@ inline void GetCAISInfoResponse::set_allocated_cais_info(::bgs::protocol::accoun
 
 // -------------------------------------------------------------------
 
-// ForwardCacheExpireRequest
-
-// optional .bgs.protocol.EntityId entity_id = 1;
-inline bool ForwardCacheExpireRequest::has_entity_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void ForwardCacheExpireRequest::set_has_entity_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void ForwardCacheExpireRequest::clear_has_entity_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void ForwardCacheExpireRequest::clear_entity_id() {
-  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_entity_id();
-}
-inline const ::bgs::protocol::EntityId& ForwardCacheExpireRequest::entity_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ForwardCacheExpireRequest.entity_id)
-  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
-}
-inline ::bgs::protocol::EntityId* ForwardCacheExpireRequest::mutable_entity_id() {
-  set_has_entity_id();
-  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.ForwardCacheExpireRequest.entity_id)
-  return entity_id_;
-}
-inline ::bgs::protocol::EntityId* ForwardCacheExpireRequest::release_entity_id() {
-  clear_has_entity_id();
-  ::bgs::protocol::EntityId* temp = entity_id_;
-  entity_id_ = NULL;
-  return temp;
-}
-inline void ForwardCacheExpireRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
-  delete entity_id_;
-  entity_id_ = entity_id;
-  if (entity_id) {
-    set_has_entity_id();
-  } else {
-    clear_has_entity_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.ForwardCacheExpireRequest.entity_id)
-}
-
-// -------------------------------------------------------------------
-
 // GetAuthorizedDataRequest
 
 // optional .bgs.protocol.EntityId entity_id = 1;
@@ -7101,165 +4670,6 @@ inline void UpdateParentalControlsAndCAISRequest::set_end_time(::google::protobu
 
 // -------------------------------------------------------------------
 
-// QueueDeductRecordRequest
-
-// optional .bgs.protocol.account.v1.DeductRecord deduct_record = 1;
-inline bool QueueDeductRecordRequest::has_deduct_record() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void QueueDeductRecordRequest::set_has_deduct_record() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void QueueDeductRecordRequest::clear_has_deduct_record() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void QueueDeductRecordRequest::clear_deduct_record() {
-  if (deduct_record_ != NULL) deduct_record_->::bgs::protocol::account::v1::DeductRecord::Clear();
-  clear_has_deduct_record();
-}
-inline const ::bgs::protocol::account::v1::DeductRecord& QueueDeductRecordRequest::deduct_record() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.QueueDeductRecordRequest.deduct_record)
-  return deduct_record_ != NULL ? *deduct_record_ : *default_instance_->deduct_record_;
-}
-inline ::bgs::protocol::account::v1::DeductRecord* QueueDeductRecordRequest::mutable_deduct_record() {
-  set_has_deduct_record();
-  if (deduct_record_ == NULL) deduct_record_ = new ::bgs::protocol::account::v1::DeductRecord;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.QueueDeductRecordRequest.deduct_record)
-  return deduct_record_;
-}
-inline ::bgs::protocol::account::v1::DeductRecord* QueueDeductRecordRequest::release_deduct_record() {
-  clear_has_deduct_record();
-  ::bgs::protocol::account::v1::DeductRecord* temp = deduct_record_;
-  deduct_record_ = NULL;
-  return temp;
-}
-inline void QueueDeductRecordRequest::set_allocated_deduct_record(::bgs::protocol::account::v1::DeductRecord* deduct_record) {
-  delete deduct_record_;
-  deduct_record_ = deduct_record;
-  if (deduct_record) {
-    set_has_deduct_record();
-  } else {
-    clear_has_deduct_record();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.QueueDeductRecordRequest.deduct_record)
-}
-
-// -------------------------------------------------------------------
-
-// GetGameAccountRequest
-
-// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-inline bool GetGameAccountRequest::has_game_account() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void GetGameAccountRequest::set_has_game_account() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void GetGameAccountRequest::clear_has_game_account() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void GetGameAccountRequest::clear_game_account() {
-  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-  clear_has_game_account();
-}
-inline const ::bgs::protocol::account::v1::GameAccountHandle& GetGameAccountRequest::game_account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountRequest.game_account)
-  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* GetGameAccountRequest::mutable_game_account() {
-  set_has_game_account();
-  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountRequest.game_account)
-  return game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* GetGameAccountRequest::release_game_account() {
-  clear_has_game_account();
-  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
-  game_account_ = NULL;
-  return temp;
-}
-inline void GetGameAccountRequest::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
-  delete game_account_;
-  game_account_ = game_account;
-  if (game_account) {
-    set_has_game_account();
-  } else {
-    clear_has_game_account();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountRequest.game_account)
-}
-
-// optional bool reload = 2 [default = false];
-inline bool GetGameAccountRequest::has_reload() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void GetGameAccountRequest::set_has_reload() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void GetGameAccountRequest::clear_has_reload() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void GetGameAccountRequest::clear_reload() {
-  reload_ = false;
-  clear_has_reload();
-}
-inline bool GetGameAccountRequest::reload() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountRequest.reload)
-  return reload_;
-}
-inline void GetGameAccountRequest::set_reload(bool value) {
-  set_has_reload();
-  reload_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetGameAccountRequest.reload)
-}
-
-// -------------------------------------------------------------------
-
-// GetGameAccountResponse
-
-// optional .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-inline bool GetGameAccountResponse::has_blob() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void GetGameAccountResponse::set_has_blob() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void GetGameAccountResponse::clear_has_blob() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void GetGameAccountResponse::clear_blob() {
-  if (blob_ != NULL) blob_->::bgs::protocol::account::v1::GameAccountBlob::Clear();
-  clear_has_blob();
-}
-inline const ::bgs::protocol::account::v1::GameAccountBlob& GetGameAccountResponse::blob() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountResponse.blob)
-  return blob_ != NULL ? *blob_ : *default_instance_->blob_;
-}
-inline ::bgs::protocol::account::v1::GameAccountBlob* GetGameAccountResponse::mutable_blob() {
-  set_has_blob();
-  if (blob_ == NULL) blob_ = new ::bgs::protocol::account::v1::GameAccountBlob;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountResponse.blob)
-  return blob_;
-}
-inline ::bgs::protocol::account::v1::GameAccountBlob* GetGameAccountResponse::release_blob() {
-  clear_has_blob();
-  ::bgs::protocol::account::v1::GameAccountBlob* temp = blob_;
-  blob_ = NULL;
-  return temp;
-}
-inline void GetGameAccountResponse::set_allocated_blob(::bgs::protocol::account::v1::GameAccountBlob* blob) {
-  delete blob_;
-  blob_ = blob;
-  if (blob) {
-    set_has_blob();
-  } else {
-    clear_has_blob();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountResponse.blob)
-}
-
-// -------------------------------------------------------------------
-
 // AccountStateNotification
 
 // optional .bgs.protocol.account.v1.AccountState account_state = 1;
@@ -7303,7 +4713,7 @@ inline void AccountStateNotification::set_allocated_account_state(::bgs::protoco
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateNotification.account_state)
 }
 
-// optional uint64 subscriber_id = 2;
+// optional uint64 subscriber_id = 2 [deprecated = true];
 inline bool AccountStateNotification::has_subscriber_id() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
@@ -7437,7 +4847,7 @@ inline void GameAccountStateNotification::set_allocated_game_account_state(::bgs
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state)
 }
 
-// optional uint64 subscriber_id = 2;
+// optional uint64 subscriber_id = 2 [deprecated = true];
 inline bool GameAccountStateNotification::has_subscriber_id() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
diff --git a/src/server/proto/Client/account_types.pb.cc b/src/server/proto/Client/account_types.pb.cc
index ec77b9b7650..fa7df436004 100644
--- a/src/server/proto/Client/account_types.pb.cc
+++ b/src/server/proto/Client/account_types.pb.cc
@@ -31,36 +31,15 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* AccountLicense_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   AccountLicense_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AccountCredential_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AccountCredential_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AccountBlob_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AccountBlob_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AccountBlobList_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AccountBlobList_reflection_ = NULL;
 const ::google::protobuf::Descriptor* GameAccountHandle_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   GameAccountHandle_reflection_ = NULL;
-const ::google::protobuf::Descriptor* GameAccountLink_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  GameAccountLink_reflection_ = NULL;
-const ::google::protobuf::Descriptor* GameAccountBlob_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  GameAccountBlob_reflection_ = NULL;
-const ::google::protobuf::Descriptor* GameAccountBlobList_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  GameAccountBlobList_reflection_ = NULL;
 const ::google::protobuf::Descriptor* AccountReference_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   AccountReference_reflection_ = NULL;
 const ::google::protobuf::Descriptor* Identity_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   Identity_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AccountInfo_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AccountInfo_reflection_ = NULL;
 const ::google::protobuf::Descriptor* ProgramTag_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   ProgramTag_reflection_ = NULL;
@@ -137,21 +116,6 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* AuthorizedData_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   AuthorizedData_reflection_ = NULL;
-const ::google::protobuf::Descriptor* BenefactorAddress_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  BenefactorAddress_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ExternalBenefactorLookup_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ExternalBenefactorLookup_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AuthBenefactor_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AuthBenefactor_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ApplicationInfo_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ApplicationInfo_reflection_ = NULL;
-const ::google::protobuf::Descriptor* DeductRecord_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  DeductRecord_reflection_ = NULL;
 const ::google::protobuf::Descriptor* IgrId_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   IgrId_reflection_ = NULL;
@@ -159,7 +123,14 @@ struct IgrIdOneofInstance {
   const ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
   ::google::protobuf::uint32 external_id_;
 }* IgrId_default_oneof_instance_ = NULL;
+const ::google::protobuf::Descriptor* IgrAddress_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  IgrAddress_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountRestriction_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountRestriction_reflection_ = NULL;
 const ::google::protobuf::EnumDescriptor* IdentityVerificationStatus_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* RestrictionType_descriptor_ = NULL;
 
 }  // namespace
 
@@ -201,73 +172,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AccountLicense));
-  AccountCredential_descriptor_ = file->message_type(2);
-  static const int AccountCredential_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, data_),
-  };
-  AccountCredential_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      AccountCredential_descriptor_,
-      AccountCredential::default_instance_,
-      AccountCredential_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AccountCredential));
-  AccountBlob_descriptor_ = file->message_type(3);
-  static const int AccountBlob_offsets_[21] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, region_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, email_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, flags_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, secure_release_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, whitelist_start_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, whitelist_end_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, full_name_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, licenses_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, credentials_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, account_links_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, battle_tag_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, default_currency_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, legal_region_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, legal_locale_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, cache_expiration_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, parental_control_info_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, country_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, preferred_region_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, identity_check_status_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, cais_id_),
-  };
-  AccountBlob_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      AccountBlob_descriptor_,
-      AccountBlob::default_instance_,
-      AccountBlob_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AccountBlob));
-  AccountBlobList_descriptor_ = file->message_type(4);
-  static const int AccountBlobList_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlobList, blob_),
-  };
-  AccountBlobList_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      AccountBlobList_descriptor_,
-      AccountBlobList::default_instance_,
-      AccountBlobList_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlobList, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlobList, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AccountBlobList));
-  GameAccountHandle_descriptor_ = file->message_type(5);
+  GameAccountHandle_descriptor_ = file->message_type(2);
   static const int GameAccountHandle_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, program_),
@@ -284,68 +189,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameAccountHandle));
-  GameAccountLink_descriptor_ = file->message_type(6);
-  static const int GameAccountLink_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, game_account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, name_),
-  };
-  GameAccountLink_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      GameAccountLink_descriptor_,
-      GameAccountLink::default_instance_,
-      GameAccountLink_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GameAccountLink));
-  GameAccountBlob_descriptor_ = file->message_type(7);
-  static const int GameAccountBlob_offsets_[16] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, game_account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, name_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, realm_permissions_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, status_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, flags_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, billing_flags_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, cache_expiration_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, subscription_expiration_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, units_remaining_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, status_expiration_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, box_level_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, box_level_expiration_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, licenses_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, raf_account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, raf_info_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, raf_expiration_),
-  };
-  GameAccountBlob_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      GameAccountBlob_descriptor_,
-      GameAccountBlob::default_instance_,
-      GameAccountBlob_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GameAccountBlob));
-  GameAccountBlobList_descriptor_ = file->message_type(8);
-  static const int GameAccountBlobList_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlobList, blob_),
-  };
-  GameAccountBlobList_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      GameAccountBlobList_descriptor_,
-      GameAccountBlobList::default_instance_,
-      GameAccountBlobList_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlobList, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlobList, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GameAccountBlobList));
-  AccountReference_descriptor_ = file->message_type(9);
+  AccountReference_descriptor_ = file->message_type(3);
   static const int AccountReference_offsets_[5] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, email_),
@@ -364,7 +208,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AccountReference));
-  Identity_descriptor_ = file->message_type(10);
+  Identity_descriptor_ = file->message_type(4);
   static const int Identity_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, account_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, game_account_),
@@ -381,27 +225,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(Identity));
-  AccountInfo_descriptor_ = file->message_type(11);
-  static const int AccountInfo_offsets_[6] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, account_paid_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, country_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, battle_tag_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, manual_review_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, identity_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, account_muted_),
-  };
-  AccountInfo_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      AccountInfo_descriptor_,
-      AccountInfo::default_instance_,
-      AccountInfo_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AccountInfo));
-  ProgramTag_descriptor_ = file->message_type(12);
+  ProgramTag_descriptor_ = file->message_type(5);
   static const int ProgramTag_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, program_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, tag_),
@@ -417,7 +241,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ProgramTag));
-  RegionTag_descriptor_ = file->message_type(13);
+  RegionTag_descriptor_ = file->message_type(6);
   static const int RegionTag_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, region_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, tag_),
@@ -433,7 +257,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(RegionTag));
-  AccountFieldTags_descriptor_ = file->message_type(14);
+  AccountFieldTags_descriptor_ = file->message_type(7);
   static const int AccountFieldTags_offsets_[6] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, account_level_info_tag_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, privacy_info_tag_),
@@ -453,7 +277,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AccountFieldTags));
-  GameAccountFieldTags_descriptor_ = file->message_type(15);
+  GameAccountFieldTags_descriptor_ = file->message_type(8);
   static const int GameAccountFieldTags_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, game_level_info_tag_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, game_time_info_tag_),
@@ -471,7 +295,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameAccountFieldTags));
-  AccountFieldOptions_descriptor_ = file->message_type(16);
+  AccountFieldOptions_descriptor_ = file->message_type(9);
   static const int AccountFieldOptions_offsets_[7] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, all_fields_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_account_level_info_),
@@ -492,7 +316,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AccountFieldOptions));
-  GameAccountFieldOptions_descriptor_ = file->message_type(17);
+  GameAccountFieldOptions_descriptor_ = file->message_type(10);
   static const int GameAccountFieldOptions_offsets_[5] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, all_fields_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, field_game_level_info_),
@@ -511,7 +335,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameAccountFieldOptions));
-  SubscriberReference_descriptor_ = file->message_type(18);
+  SubscriberReference_descriptor_ = file->message_type(11);
   static const int SubscriberReference_offsets_[7] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, object_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, entity_id_),
@@ -532,8 +356,8 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(SubscriberReference));
-  AccountLevelInfo_descriptor_ = file->message_type(19);
-  static const int AccountLevelInfo_offsets_[11] = {
+  AccountLevelInfo_descriptor_ = file->message_type(12);
+  static const int AccountLevelInfo_offsets_[15] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, licenses_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, default_currency_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, country_),
@@ -545,6 +369,10 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, account_paid_any_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, identity_check_status_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, email_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, headless_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, test_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, restriction_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, is_sms_protected_),
   };
   AccountLevelInfo_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -557,12 +385,13 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AccountLevelInfo));
-  PrivacyInfo_descriptor_ = file->message_type(20);
-  static const int PrivacyInfo_offsets_[4] = {
+  PrivacyInfo_descriptor_ = file->message_type(13);
+  static const int PrivacyInfo_offsets_[5] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_using_rid_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_real_id_visible_for_view_friends_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_visible_for_view_friends_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_hidden_from_friend_finder_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, game_info_privacy_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, only_allow_friend_whispers_),
   };
   PrivacyInfo_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -576,14 +405,16 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(PrivacyInfo));
   PrivacyInfo_GameInfoPrivacy_descriptor_ = PrivacyInfo_descriptor_->enum_type(0);
-  ParentalControlInfo_descriptor_ = file->message_type(21);
-  static const int ParentalControlInfo_offsets_[6] = {
+  ParentalControlInfo_descriptor_ = file->message_type(14);
+  static const int ParentalControlInfo_offsets_[8] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, timezone_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, minutes_per_day_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, minutes_per_week_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, can_receive_voice_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, can_send_voice_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, play_schedule_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, can_join_group_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, can_use_profile_),
   };
   ParentalControlInfo_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -596,7 +427,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ParentalControlInfo));
-  GameLevelInfo_descriptor_ = file->message_type(22);
+  GameLevelInfo_descriptor_ = file->message_type(15);
   static const int GameLevelInfo_offsets_[8] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_trial_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_lifetime_),
@@ -618,7 +449,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameLevelInfo));
-  GameTimeInfo_descriptor_ = file->message_type(23);
+  GameTimeInfo_descriptor_ = file->message_type(16);
   static const int GameTimeInfo_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, is_unlimited_play_time_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, play_time_expires_),
@@ -636,7 +467,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameTimeInfo));
-  GameTimeRemainingInfo_descriptor_ = file->message_type(24);
+  GameTimeRemainingInfo_descriptor_ = file->message_type(17);
   static const int GameTimeRemainingInfo_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, minutes_remaining_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, parental_daily_minutes_remaining_),
@@ -654,7 +485,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameTimeRemainingInfo));
-  GameStatus_descriptor_ = file->message_type(25);
+  GameStatus_descriptor_ = file->message_type(18);
   static const int GameStatus_offsets_[6] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_suspended_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_banned_),
@@ -674,7 +505,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameStatus));
-  RAFInfo_descriptor_ = file->message_type(26);
+  RAFInfo_descriptor_ = file->message_type(19);
   static const int RAFInfo_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RAFInfo, raf_info_),
   };
@@ -689,7 +520,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(RAFInfo));
-  GameSessionInfo_descriptor_ = file->message_type(27);
+  GameSessionInfo_descriptor_ = file->message_type(20);
   static const int GameSessionInfo_offsets_[7] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, start_time_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, location_),
@@ -710,7 +541,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameSessionInfo));
-  GameSessionUpdateInfo_descriptor_ = file->message_type(28);
+  GameSessionUpdateInfo_descriptor_ = file->message_type(21);
   static const int GameSessionUpdateInfo_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionUpdateInfo, cais_),
   };
@@ -725,7 +556,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameSessionUpdateInfo));
-  GameSessionLocation_descriptor_ = file->message_type(29);
+  GameSessionLocation_descriptor_ = file->message_type(22);
   static const int GameSessionLocation_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, ip_address_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, country_),
@@ -742,7 +573,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameSessionLocation));
-  CAIS_descriptor_ = file->message_type(30);
+  CAIS_descriptor_ = file->message_type(23);
   static const int CAIS_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, played_minutes_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, rested_minutes_),
@@ -759,7 +590,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(CAIS));
-  GameAccountList_descriptor_ = file->message_type(31);
+  GameAccountList_descriptor_ = file->message_type(24);
   static const int GameAccountList_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, region_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, handle_),
@@ -775,7 +606,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameAccountList));
-  AccountState_descriptor_ = file->message_type(32);
+  AccountState_descriptor_ = file->message_type(25);
   static const int AccountState_offsets_[6] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, account_level_info_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, privacy_info_),
@@ -795,7 +626,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AccountState));
-  AccountStateTagged_descriptor_ = file->message_type(33);
+  AccountStateTagged_descriptor_ = file->message_type(26);
   static const int AccountStateTagged_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, account_state_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, account_tags_),
@@ -811,7 +642,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AccountStateTagged));
-  GameAccountState_descriptor_ = file->message_type(34);
+  GameAccountState_descriptor_ = file->message_type(27);
   static const int GameAccountState_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, game_level_info_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, game_time_info_),
@@ -829,7 +660,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameAccountState));
-  GameAccountStateTagged_descriptor_ = file->message_type(35);
+  GameAccountStateTagged_descriptor_ = file->message_type(28);
   static const int GameAccountStateTagged_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, game_account_state_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, game_account_tags_),
@@ -845,7 +676,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GameAccountStateTagged));
-  AuthorizedData_descriptor_ = file->message_type(36);
+  AuthorizedData_descriptor_ = file->message_type(29);
   static const int AuthorizedData_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, data_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, license_),
@@ -861,96 +692,7 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AuthorizedData));
-  BenefactorAddress_descriptor_ = file->message_type(37);
-  static const int BenefactorAddress_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BenefactorAddress, region_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BenefactorAddress, igr_address_),
-  };
-  BenefactorAddress_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      BenefactorAddress_descriptor_,
-      BenefactorAddress::default_instance_,
-      BenefactorAddress_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BenefactorAddress, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BenefactorAddress, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(BenefactorAddress));
-  ExternalBenefactorLookup_descriptor_ = file->message_type(38);
-  static const int ExternalBenefactorLookup_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExternalBenefactorLookup, benefactor_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExternalBenefactorLookup, region_),
-  };
-  ExternalBenefactorLookup_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ExternalBenefactorLookup_descriptor_,
-      ExternalBenefactorLookup::default_instance_,
-      ExternalBenefactorLookup_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExternalBenefactorLookup, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ExternalBenefactorLookup, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ExternalBenefactorLookup));
-  AuthBenefactor_descriptor_ = file->message_type(39);
-  static const int AuthBenefactor_offsets_[4] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthBenefactor, igr_address_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthBenefactor, benefactor_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthBenefactor, active_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthBenefactor, last_update_time_),
-  };
-  AuthBenefactor_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      AuthBenefactor_descriptor_,
-      AuthBenefactor::default_instance_,
-      AuthBenefactor_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthBenefactor, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthBenefactor, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AuthBenefactor));
-  ApplicationInfo_descriptor_ = file->message_type(40);
-  static const int ApplicationInfo_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ApplicationInfo, platform_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ApplicationInfo, locale_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ApplicationInfo, application_version_),
-  };
-  ApplicationInfo_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ApplicationInfo_descriptor_,
-      ApplicationInfo::default_instance_,
-      ApplicationInfo_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ApplicationInfo, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ApplicationInfo, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ApplicationInfo));
-  DeductRecord_descriptor_ = file->message_type(41);
-  static const int DeductRecord_offsets_[8] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, game_account_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, benefactor_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, start_time_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, end_time_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, client_address_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, application_info_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, session_owner_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, free_session_),
-  };
-  DeductRecord_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      DeductRecord_descriptor_,
-      DeductRecord::default_instance_,
-      DeductRecord_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeductRecord, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(DeductRecord));
-  IgrId_descriptor_ = file->message_type(42);
+  IgrId_descriptor_ = file->message_type(30);
   static const int IgrId_offsets_[3] = {
     PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(IgrId_default_oneof_instance_, game_account_),
     PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(IgrId_default_oneof_instance_, external_id_),
@@ -969,7 +711,44 @@ void protobuf_AssignDesc_account_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(IgrId));
+  IgrAddress_descriptor_ = file->message_type(31);
+  static const int IgrAddress_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IgrAddress, client_address_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IgrAddress, region_),
+  };
+  IgrAddress_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      IgrAddress_descriptor_,
+      IgrAddress::default_instance_,
+      IgrAddress_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IgrAddress, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IgrAddress, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(IgrAddress));
+  AccountRestriction_descriptor_ = file->message_type(32);
+  static const int AccountRestriction_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountRestriction, restriction_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountRestriction, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountRestriction, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountRestriction, platform_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountRestriction, expire_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountRestriction, created_time_),
+  };
+  AccountRestriction_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountRestriction_descriptor_,
+      AccountRestriction::default_instance_,
+      AccountRestriction_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountRestriction, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountRestriction, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountRestriction));
   IdentityVerificationStatus_descriptor_ = file->enum_type(0);
+  RestrictionType_descriptor_ = file->enum_type(1);
 }
 
 namespace {
@@ -987,26 +766,12 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     AccountLicense_descriptor_, &AccountLicense::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AccountCredential_descriptor_, &AccountCredential::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AccountBlob_descriptor_, &AccountBlob::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AccountBlobList_descriptor_, &AccountBlobList::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     GameAccountHandle_descriptor_, &GameAccountHandle::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GameAccountLink_descriptor_, &GameAccountLink::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GameAccountBlob_descriptor_, &GameAccountBlob::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GameAccountBlobList_descriptor_, &GameAccountBlobList::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     AccountReference_descriptor_, &AccountReference::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     Identity_descriptor_, &Identity::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AccountInfo_descriptor_, &AccountInfo::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     ProgramTag_descriptor_, &ProgramTag::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     RegionTag_descriptor_, &RegionTag::default_instance());
@@ -1057,17 +822,11 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     AuthorizedData_descriptor_, &AuthorizedData::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    BenefactorAddress_descriptor_, &BenefactorAddress::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ExternalBenefactorLookup_descriptor_, &ExternalBenefactorLookup::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AuthBenefactor_descriptor_, &AuthBenefactor::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ApplicationInfo_descriptor_, &ApplicationInfo::default_instance());
+    IgrId_descriptor_, &IgrId::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    DeductRecord_descriptor_, &DeductRecord::default_instance());
+    IgrAddress_descriptor_, &IgrAddress::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    IgrId_descriptor_, &IgrId::default_instance());
+    AccountRestriction_descriptor_, &AccountRestriction::default_instance());
 }
 
 }  // namespace
@@ -1077,26 +836,12 @@ void protobuf_ShutdownFile_account_5ftypes_2eproto() {
   delete AccountId_reflection_;
   delete AccountLicense::default_instance_;
   delete AccountLicense_reflection_;
-  delete AccountCredential::default_instance_;
-  delete AccountCredential_reflection_;
-  delete AccountBlob::default_instance_;
-  delete AccountBlob_reflection_;
-  delete AccountBlobList::default_instance_;
-  delete AccountBlobList_reflection_;
   delete GameAccountHandle::default_instance_;
   delete GameAccountHandle_reflection_;
-  delete GameAccountLink::default_instance_;
-  delete GameAccountLink_reflection_;
-  delete GameAccountBlob::default_instance_;
-  delete GameAccountBlob_reflection_;
-  delete GameAccountBlobList::default_instance_;
-  delete GameAccountBlobList_reflection_;
   delete AccountReference::default_instance_;
   delete AccountReference_reflection_;
   delete Identity::default_instance_;
   delete Identity_reflection_;
-  delete AccountInfo::default_instance_;
-  delete AccountInfo_reflection_;
   delete ProgramTag::default_instance_;
   delete ProgramTag_reflection_;
   delete RegionTag::default_instance_;
@@ -1147,19 +892,13 @@ void protobuf_ShutdownFile_account_5ftypes_2eproto() {
   delete GameAccountStateTagged_reflection_;
   delete AuthorizedData::default_instance_;
   delete AuthorizedData_reflection_;
-  delete BenefactorAddress::default_instance_;
-  delete BenefactorAddress_reflection_;
-  delete ExternalBenefactorLookup::default_instance_;
-  delete ExternalBenefactorLookup_reflection_;
-  delete AuthBenefactor::default_instance_;
-  delete AuthBenefactor_reflection_;
-  delete ApplicationInfo::default_instance_;
-  delete ApplicationInfo_reflection_;
-  delete DeductRecord::default_instance_;
-  delete DeductRecord_reflection_;
   delete IgrId::default_instance_;
   delete IgrId_default_oneof_instance_;
   delete IgrId_reflection_;
+  delete IgrAddress::default_instance_;
+  delete IgrAddress_reflection_;
+  delete AccountRestriction::default_instance_;
+  delete AccountRestriction_reflection_;
 }
 
 void protobuf_AddDesc_account_5ftypes_2eproto() {
@@ -1173,207 +912,161 @@ void protobuf_AddDesc_account_5ftypes_2eproto() {
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\023account_types.proto\022\027bgs.protocol.acco"
     "unt.v1\032\022entity_types.proto\032\017rpc_types.pr"
-    "oto\"\027\n\tAccountId\022\n\n\002id\030\001 \002(\007\"-\n\016AccountL"
-    "icense\022\n\n\002id\030\001 \002(\r\022\017\n\007expires\030\002 \001(\004\"-\n\021A"
-    "ccountCredential\022\n\n\002id\030\001 \002(\r\022\014\n\004data\030\002 \001"
-    "(\014\"\260\005\n\013AccountBlob\022\n\n\002id\030\002 \002(\007\022\016\n\006region"
-    "\030\003 \002(\r\022\r\n\005email\030\004 \003(\t\022\r\n\005flags\030\005 \002(\004\022\026\n\016"
-    "secure_release\030\006 \001(\004\022\027\n\017whitelist_start\030"
-    "\007 \001(\004\022\025\n\rwhitelist_end\030\010 \001(\004\022\021\n\tfull_nam"
-    "e\030\n \002(\t\0229\n\010licenses\030\024 \003(\0132\'.bgs.protocol"
-    ".account.v1.AccountLicense\022\?\n\013credential"
-    "s\030\025 \003(\0132*.bgs.protocol.account.v1.Accoun"
-    "tCredential\022\?\n\raccount_links\030\026 \003(\0132(.bgs"
-    ".protocol.account.v1.GameAccountLink\022\022\n\n"
-    "battle_tag\030\027 \001(\t\022\030\n\020default_currency\030\031 \001"
-    "(\007\022\024\n\014legal_region\030\032 \001(\r\022\024\n\014legal_locale"
-    "\030\033 \001(\007\022\030\n\020cache_expiration\030\036 \002(\004\022K\n\025pare"
-    "ntal_control_info\030\037 \001(\0132,.bgs.protocol.a"
-    "ccount.v1.ParentalControlInfo\022\017\n\007country"
-    "\030  \001(\t\022\030\n\020preferred_region\030! \001(\r\022R\n\025iden"
-    "tity_check_status\030\" \001(\01623.bgs.protocol.a"
-    "ccount.v1.IdentityVerificationStatus\022\017\n\007"
-    "cais_id\030# \001(\t\"E\n\017AccountBlobList\0222\n\004blob"
-    "\030\001 \003(\0132$.bgs.protocol.account.v1.Account"
-    "Blob\"@\n\021GameAccountHandle\022\n\n\002id\030\001 \002(\007\022\017\n"
-    "\007program\030\002 \002(\007\022\016\n\006region\030\003 \002(\r\"a\n\017GameAc"
-    "countLink\022@\n\014game_account\030\001 \002(\0132*.bgs.pr"
-    "otocol.account.v1.GameAccountHandle\022\014\n\004n"
-    "ame\030\002 \002(\t\"\327\003\n\017GameAccountBlob\022@\n\014game_ac"
-    "count\030\001 \002(\0132*.bgs.protocol.account.v1.Ga"
-    "meAccountHandle\022\016\n\004name\030\002 \001(\t:\000\022\034\n\021realm"
-    "_permissions\030\003 \001(\r:\0010\022\016\n\006status\030\004 \002(\r\022\020\n"
-    "\005flags\030\005 \001(\004:\0010\022\030\n\rbilling_flags\030\006 \001(\r:\001"
-    "0\022\030\n\020cache_expiration\030\007 \002(\004\022\037\n\027subscript"
-    "ion_expiration\030\n \001(\004\022\027\n\017units_remaining\030"
-    "\013 \001(\r\022\031\n\021status_expiration\030\014 \001(\004\022\021\n\tbox_"
-    "level\030\r \001(\r\022\034\n\024box_level_expiration\030\016 \001("
-    "\004\0229\n\010licenses\030\024 \003(\0132\'.bgs.protocol.accou"
-    "nt.v1.AccountLicense\022\023\n\013raf_account\030\025 \001("
-    "\007\022\020\n\010raf_info\030\026 \001(\014\022\026\n\016raf_expiration\030\027 "
-    "\001(\004\"M\n\023GameAccountBlobList\0226\n\004blob\030\001 \003(\013"
-    "2(.bgs.protocol.account.v1.GameAccountBl"
-    "ob\"\220\001\n\020AccountReference\022\n\n\002id\030\001 \001(\007\022\r\n\005e"
+    "oto\")\n\tAccountId\022\024\n\002id\030\001 \002(\007B\010\212\371+\004\022\002\020\000:\006"
+    "\202\371+\002\010\001\"-\n\016AccountLicense\022\n\n\002id\030\001 \002(\r\022\017\n\007"
+    "expires\030\002 \001(\004\"k\n\021GameAccountHandle\022\024\n\002id"
+    "\030\001 \002(\007B\010\212\371+\004\022\002\020\000\022\031\n\007program\030\002 \002(\007B\010\212\371+\004\022"
+    "\002\020\000\022\035\n\006region\030\003 \002(\rB\r\212\371+\t\022\007\n\005\010\001\020\377\001:\006\202\371+\002"
+    "\010\001\"\220\001\n\020AccountReference\022\n\n\002id\030\001 \001(\007\022\r\n\005e"
     "mail\030\002 \001(\t\022:\n\006handle\030\003 \001(\0132*.bgs.protoco"
     "l.account.v1.GameAccountHandle\022\022\n\nbattle"
-    "_tag\030\004 \001(\t\022\021\n\006region\030\n \001(\r:\0010\"\253\001\n\010Identi"
+    "_tag\030\004 \001(\t\022\021\n\006region\030\n \001(\r:\0010\"\263\001\n\010Identi"
     "ty\0223\n\007account\030\001 \001(\0132\".bgs.protocol.accou"
     "nt.v1.AccountId\022@\n\014game_account\030\002 \001(\0132*."
     "bgs.protocol.account.v1.GameAccountHandl"
     "e\022(\n\007process\030\003 \001(\0132\027.bgs.protocol.Proces"
-    "sId\"\306\001\n\013AccountInfo\022\033\n\014account_paid\030\001 \001("
-    "\010:\005false\022\025\n\ncountry_id\030\002 \001(\007:\0010\022\022\n\nbattl"
-    "e_tag\030\003 \001(\t\022\034\n\rmanual_review\030\004 \001(\010:\005fals"
-    "e\0223\n\010identity\030\005 \001(\0132!.bgs.protocol.accou"
-    "nt.v1.Identity\022\034\n\raccount_muted\030\006 \001(\010:\005f"
-    "alse\"*\n\nProgramTag\022\017\n\007program\030\001 \001(\007\022\013\n\003t"
-    "ag\030\002 \001(\007\"(\n\tRegionTag\022\016\n\006region\030\001 \001(\007\022\013\n"
-    "\003tag\030\002 \001(\007\"\260\002\n\020AccountFieldTags\022\036\n\026accou"
-    "nt_level_info_tag\030\002 \001(\007\022\030\n\020privacy_info_"
-    "tag\030\003 \001(\007\022!\n\031parental_control_info_tag\030\004"
-    " \001(\007\022A\n\024game_level_info_tags\030\007 \003(\0132#.bgs"
-    ".protocol.account.v1.ProgramTag\022=\n\020game_"
-    "status_tags\030\t \003(\0132#.bgs.protocol.account"
-    ".v1.ProgramTag\022=\n\021game_account_tags\030\013 \003("
-    "\0132\".bgs.protocol.account.v1.RegionTag\"~\n"
-    "\024GameAccountFieldTags\022\033\n\023game_level_info"
-    "_tag\030\002 \001(\007\022\032\n\022game_time_info_tag\030\003 \001(\007\022\027"
-    "\n\017game_status_tag\030\004 \001(\007\022\024\n\014raf_info_tag\030"
-    "\005 \001(\007\"\343\001\n\023AccountFieldOptions\022\022\n\nall_fie"
-    "lds\030\001 \001(\010\022 \n\030field_account_level_info\030\002 "
-    "\001(\010\022\032\n\022field_privacy_info\030\003 \001(\010\022#\n\033field"
-    "_parental_control_info\030\004 \001(\010\022\035\n\025field_ga"
-    "me_level_info\030\006 \001(\010\022\031\n\021field_game_status"
-    "\030\007 \001(\010\022\033\n\023field_game_accounts\030\010 \001(\010\"\235\001\n\027"
-    "GameAccountFieldOptions\022\022\n\nall_fields\030\001 "
-    "\001(\010\022\035\n\025field_game_level_info\030\002 \001(\010\022\034\n\024fi"
-    "eld_game_time_info\030\003 \001(\010\022\031\n\021field_game_s"
-    "tatus\030\004 \001(\010\022\026\n\016field_raf_info\030\005 \001(\010\"\222\003\n\023"
-    "SubscriberReference\022\024\n\tobject_id\030\001 \001(\004:\001"
-    "0\022)\n\tentity_id\030\002 \001(\0132\026.bgs.protocol.Enti"
-    "tyId\022E\n\017account_options\030\003 \001(\0132,.bgs.prot"
-    "ocol.account.v1.AccountFieldOptions\022\?\n\014a"
-    "ccount_tags\030\004 \001(\0132).bgs.protocol.account"
-    ".v1.AccountFieldTags\022N\n\024game_account_opt"
-    "ions\030\005 \001(\01320.bgs.protocol.account.v1.Gam"
-    "eAccountFieldOptions\022H\n\021game_account_tag"
-    "s\030\006 \001(\0132-.bgs.protocol.account.v1.GameAc"
-    "countFieldTags\022\030\n\rsubscriber_id\030\007 \001(\004:\0010"
-    "\"\334\002\n\020AccountLevelInfo\0229\n\010licenses\030\003 \003(\0132"
-    "\'.bgs.protocol.account.v1.AccountLicense"
-    "\022\030\n\020default_currency\030\004 \001(\007\022\017\n\007country\030\005 "
-    "\001(\t\022\030\n\020preferred_region\030\006 \001(\r\022\021\n\tfull_na"
-    "me\030\007 \001(\t\022\022\n\nbattle_tag\030\010 \001(\t\022\r\n\005muted\030\t "
-    "\001(\010\022\025\n\rmanual_review\030\n \001(\010\022\030\n\020account_pa"
-    "id_any\030\013 \001(\010\022R\n\025identity_check_status\030\014 "
-    "\001(\01623.bgs.protocol.account.v1.IdentityVe"
-    "rificationStatus\022\r\n\005email\030\r \001(\t\"\246\002\n\013Priv"
-    "acyInfo\022\024\n\014is_using_rid\030\003 \001(\010\022+\n#is_real"
-    "_id_visible_for_view_friends\030\004 \001(\010\022$\n\034is"
-    "_hidden_from_friend_finder\030\005 \001(\010\022`\n\021game"
-    "_info_privacy\030\006 \001(\01624.bgs.protocol.accou"
-    "nt.v1.PrivacyInfo.GameInfoPrivacy:\017PRIVA"
-    "CY_FRIENDS\"L\n\017GameInfoPrivacy\022\016\n\nPRIVACY"
-    "_ME\020\000\022\023\n\017PRIVACY_FRIENDS\020\001\022\024\n\020PRIVACY_EV"
-    "ERYONE\020\002\"\244\001\n\023ParentalControlInfo\022\020\n\010time"
-    "zone\030\003 \001(\t\022\027\n\017minutes_per_day\030\004 \001(\r\022\030\n\020m"
-    "inutes_per_week\030\005 \001(\r\022\031\n\021can_receive_voi"
-    "ce\030\006 \001(\010\022\026\n\016can_send_voice\030\007 \001(\010\022\025\n\rplay"
-    "_schedule\030\010 \003(\010\"\323\001\n\rGameLevelInfo\022\020\n\010is_"
-    "trial\030\004 \001(\010\022\023\n\013is_lifetime\030\005 \001(\010\022\025\n\ris_r"
-    "estricted\030\006 \001(\010\022\017\n\007is_beta\030\007 \001(\010\022\014\n\004name"
-    "\030\010 \001(\t\022\017\n\007program\030\t \001(\007\0229\n\010licenses\030\n \003("
-    "\0132\'.bgs.protocol.account.v1.AccountLicen"
-    "se\022\031\n\021realm_permissions\030\013 \001(\r\"\205\001\n\014GameTi"
-    "meInfo\022\036\n\026is_unlimited_play_time\030\003 \001(\010\022\031"
-    "\n\021play_time_expires\030\005 \001(\004\022\027\n\017is_subscrip"
-    "tion\030\006 \001(\010\022!\n\031is_recurring_subscription\030"
-    "\007 \001(\010\"\255\001\n\025GameTimeRemainingInfo\022\031\n\021minut"
-    "es_remaining\030\001 \001(\r\022(\n parental_daily_min"
-    "utes_remaining\030\002 \001(\r\022)\n!parental_weekly_"
-    "minutes_remaining\030\003 \001(\r\022$\n\034seconds_remai"
-    "ning_until_kick\030\004 \001(\r\"\220\001\n\nGameStatus\022\024\n\014"
-    "is_suspended\030\004 \001(\010\022\021\n\tis_banned\030\005 \001(\010\022\032\n"
-    "\022suspension_expires\030\006 \001(\004\022\017\n\007program\030\007 \001"
-    "(\007\022\021\n\tis_locked\030\010 \001(\010\022\031\n\021is_bam_unlockab"
-    "le\030\t \001(\010\"\033\n\007RAFInfo\022\020\n\010raf_info\030\001 \001(\014\"\201\002"
-    "\n\017GameSessionInfo\022\026\n\nstart_time\030\003 \001(\rB\002\030"
-    "\001\022>\n\010location\030\004 \001(\0132,.bgs.protocol.accou"
-    "nt.v1.GameSessionLocation\022\026\n\016has_benefac"
-    "tor\030\005 \001(\010\022\024\n\014is_using_igr\030\006 \001(\010\022 \n\030paren"
-    "tal_controls_active\030\007 \001(\010\022\026\n\016start_time_"
-    "sec\030\010 \001(\004\022.\n\006igr_id\030\t \001(\0132\036.bgs.protocol"
-    ".account.v1.IgrId\"D\n\025GameSessionUpdateIn"
-    "fo\022+\n\004cais\030\010 \001(\0132\035.bgs.protocol.account."
-    "v1.CAIS\"H\n\023GameSessionLocation\022\022\n\nip_add"
-    "ress\030\001 \001(\t\022\017\n\007country\030\002 \001(\r\022\014\n\004city\030\003 \001("
-    "\t\"O\n\004CAIS\022\026\n\016played_minutes\030\001 \001(\r\022\026\n\016res"
-    "ted_minutes\030\002 \001(\r\022\027\n\017last_heard_time\030\003 \001"
-    "(\004\"]\n\017GameAccountList\022\016\n\006region\030\003 \001(\r\022:\n"
-    "\006handle\030\004 \003(\0132*.bgs.protocol.account.v1."
-    "GameAccountHandle\"\232\003\n\014AccountState\022E\n\022ac"
-    "count_level_info\030\001 \001(\0132).bgs.protocol.ac"
-    "count.v1.AccountLevelInfo\022:\n\014privacy_inf"
-    "o\030\002 \001(\0132$.bgs.protocol.account.v1.Privac"
-    "yInfo\022K\n\025parental_control_info\030\003 \001(\0132,.b"
-    "gs.protocol.account.v1.ParentalControlIn"
-    "fo\022\?\n\017game_level_info\030\005 \003(\0132&.bgs.protoc"
-    "ol.account.v1.GameLevelInfo\0228\n\013game_stat"
-    "us\030\006 \003(\0132#.bgs.protocol.account.v1.GameS"
-    "tatus\022\?\n\rgame_accounts\030\007 \003(\0132(.bgs.proto"
-    "col.account.v1.GameAccountList\"\223\001\n\022Accou"
-    "ntStateTagged\022<\n\raccount_state\030\001 \001(\0132%.b"
-    "gs.protocol.account.v1.AccountState\022\?\n\014a"
-    "ccount_tags\030\002 \001(\0132).bgs.protocol.account"
-    ".v1.AccountFieldTags\"\200\002\n\020GameAccountStat"
-    "e\022\?\n\017game_level_info\030\001 \001(\0132&.bgs.protoco"
-    "l.account.v1.GameLevelInfo\022=\n\016game_time_"
-    "info\030\002 \001(\0132%.bgs.protocol.account.v1.Gam"
-    "eTimeInfo\0228\n\013game_status\030\003 \001(\0132#.bgs.pro"
-    "tocol.account.v1.GameStatus\0222\n\010raf_info\030"
-    "\004 \001(\0132 .bgs.protocol.account.v1.RAFInfo\""
-    "\251\001\n\026GameAccountStateTagged\022E\n\022game_accou"
-    "nt_state\030\001 \001(\0132).bgs.protocol.account.v1"
-    ".GameAccountState\022H\n\021game_account_tags\030\002"
-    " \001(\0132-.bgs.protocol.account.v1.GameAccou"
-    "ntFieldTags\"/\n\016AuthorizedData\022\014\n\004data\030\001 "
-    "\001(\t\022\017\n\007license\030\002 \003(\r\"8\n\021BenefactorAddres"
-    "s\022\016\n\006region\030\001 \001(\r\022\023\n\013igr_address\030\002 \001(\t\"A"
-    "\n\030ExternalBenefactorLookup\022\025\n\rbenefactor"
-    "_id\030\001 \001(\007\022\016\n\006region\030\002 \001(\r\"f\n\016AuthBenefac"
-    "tor\022\023\n\013igr_address\030\001 \001(\t\022\025\n\rbenefactor_i"
-    "d\030\002 \001(\007\022\016\n\006active\030\003 \001(\010\022\030\n\020last_update_t"
-    "ime\030\004 \001(\004\"S\n\017ApplicationInfo\022\023\n\013platform"
-    "_id\030\001 \001(\007\022\016\n\006locale\030\002 \001(\007\022\033\n\023application"
-    "_version\030\003 \001(\005\"\277\002\n\014DeductRecord\022@\n\014game_"
-    "account\030\001 \001(\0132*.bgs.protocol.account.v1."
-    "GameAccountHandle\022>\n\nbenefactor\030\002 \001(\0132*."
-    "bgs.protocol.account.v1.GameAccountHandl"
-    "e\022\022\n\nstart_time\030\003 \001(\004\022\020\n\010end_time\030\004 \001(\004\022"
-    "\026\n\016client_address\030\005 \001(\t\022B\n\020application_i"
-    "nfo\030\006 \001(\0132(.bgs.protocol.account.v1.Appl"
-    "icationInfo\022\025\n\rsession_owner\030\007 \001(\t\022\024\n\014fr"
-    "ee_session\030\010 \001(\010\"j\n\005IgrId\022B\n\014game_accoun"
-    "t\030\001 \001(\0132*.bgs.protocol.account.v1.GameAc"
-    "countHandleH\000\022\025\n\013external_id\030\002 \001(\007H\000B\006\n\004"
-    "type*\216\001\n\032IdentityVerificationStatus\022\021\n\rI"
-    "DENT_NO_DATA\020\000\022\021\n\rIDENT_PENDING\020\001\022\020\n\014IDE"
-    "NT_FAILED\020\004\022\021\n\rIDENT_SUCCESS\020\005\022\022\n\016IDENT_"
-    "SUCC_MNL\020\006\022\021\n\rIDENT_UNKNOWN\020\007B\002H\001", 7553);
+    "sId:\006\202\371+\002\020\001\"*\n\nProgramTag\022\017\n\007program\030\001 \001"
+    "(\007\022\013\n\003tag\030\002 \001(\007\"(\n\tRegionTag\022\016\n\006region\030\001"
+    " \001(\007\022\013\n\003tag\030\002 \001(\007\"\260\002\n\020AccountFieldTags\022\036"
+    "\n\026account_level_info_tag\030\002 \001(\007\022\030\n\020privac"
+    "y_info_tag\030\003 \001(\007\022!\n\031parental_control_inf"
+    "o_tag\030\004 \001(\007\022A\n\024game_level_info_tags\030\007 \003("
+    "\0132#.bgs.protocol.account.v1.ProgramTag\022="
+    "\n\020game_status_tags\030\t \003(\0132#.bgs.protocol."
+    "account.v1.ProgramTag\022=\n\021game_account_ta"
+    "gs\030\013 \003(\0132\".bgs.protocol.account.v1.Regio"
+    "nTag\"~\n\024GameAccountFieldTags\022\033\n\023game_lev"
+    "el_info_tag\030\002 \001(\007\022\032\n\022game_time_info_tag\030"
+    "\003 \001(\007\022\027\n\017game_status_tag\030\004 \001(\007\022\024\n\014raf_in"
+    "fo_tag\030\005 \001(\007\"\343\001\n\023AccountFieldOptions\022\022\n\n"
+    "all_fields\030\001 \001(\010\022 \n\030field_account_level_"
+    "info\030\002 \001(\010\022\032\n\022field_privacy_info\030\003 \001(\010\022#"
+    "\n\033field_parental_control_info\030\004 \001(\010\022\035\n\025f"
+    "ield_game_level_info\030\006 \001(\010\022\031\n\021field_game"
+    "_status\030\007 \001(\010\022\033\n\023field_game_accounts\030\010 \001"
+    "(\010\"\235\001\n\027GameAccountFieldOptions\022\022\n\nall_fi"
+    "elds\030\001 \001(\010\022\035\n\025field_game_level_info\030\002 \001("
+    "\010\022\034\n\024field_game_time_info\030\003 \001(\010\022\031\n\021field"
+    "_game_status\030\004 \001(\010\022\026\n\016field_raf_info\030\005 \001"
+    "(\010\"\222\003\n\023SubscriberReference\022\024\n\tobject_id\030"
+    "\001 \001(\004:\0010\022)\n\tentity_id\030\002 \001(\0132\026.bgs.protoc"
+    "ol.EntityId\022E\n\017account_options\030\003 \001(\0132,.b"
+    "gs.protocol.account.v1.AccountFieldOptio"
+    "ns\022\?\n\014account_tags\030\004 \001(\0132).bgs.protocol."
+    "account.v1.AccountFieldTags\022N\n\024game_acco"
+    "unt_options\030\005 \001(\01320.bgs.protocol.account"
+    ".v1.GameAccountFieldOptions\022H\n\021game_acco"
+    "unt_tags\030\006 \001(\0132-.bgs.protocol.account.v1"
+    ".GameAccountFieldTags\022\030\n\rsubscriber_id\030\007"
+    " \001(\004:\0010\"\350\003\n\020AccountLevelInfo\0229\n\010licenses"
+    "\030\003 \003(\0132\'.bgs.protocol.account.v1.Account"
+    "License\022\030\n\020default_currency\030\004 \001(\007\022\017\n\007cou"
+    "ntry\030\005 \001(\t\022\030\n\020preferred_region\030\006 \001(\r\022\021\n\t"
+    "full_name\030\007 \001(\t\022\022\n\nbattle_tag\030\010 \001(\t\022\r\n\005m"
+    "uted\030\t \001(\010\022\025\n\rmanual_review\030\n \001(\010\022\030\n\020acc"
+    "ount_paid_any\030\013 \001(\010\022R\n\025identity_check_st"
+    "atus\030\014 \001(\01623.bgs.protocol.account.v1.Ide"
+    "ntityVerificationStatus\022\r\n\005email\030\r \001(\t\022\030"
+    "\n\020headless_account\030\016 \001(\010\022\024\n\014test_account"
+    "\030\017 \001(\010\022@\n\013restriction\030\020 \003(\0132+.bgs.protoc"
+    "ol.account.v1.AccountRestriction\022\030\n\020is_s"
+    "ms_protected\030\021 \001(\010\"\302\002\n\013PrivacyInfo\022\024\n\014is"
+    "_using_rid\030\003 \001(\010\022#\n\033is_visible_for_view_"
+    "friends\030\004 \001(\010\022$\n\034is_hidden_from_friend_f"
+    "inder\030\005 \001(\010\022`\n\021game_info_privacy\030\006 \001(\01624"
+    ".bgs.protocol.account.v1.PrivacyInfo.Gam"
+    "eInfoPrivacy:\017PRIVACY_FRIENDS\022\"\n\032only_al"
+    "low_friend_whispers\030\007 \001(\010\"L\n\017GameInfoPri"
+    "vacy\022\016\n\nPRIVACY_ME\020\000\022\023\n\017PRIVACY_FRIENDS\020"
+    "\001\022\024\n\020PRIVACY_EVERYONE\020\002\"\325\001\n\023ParentalCont"
+    "rolInfo\022\020\n\010timezone\030\003 \001(\t\022\027\n\017minutes_per"
+    "_day\030\004 \001(\r\022\030\n\020minutes_per_week\030\005 \001(\r\022\031\n\021"
+    "can_receive_voice\030\006 \001(\010\022\026\n\016can_send_voic"
+    "e\030\007 \001(\010\022\025\n\rplay_schedule\030\010 \003(\010\022\026\n\016can_jo"
+    "in_group\030\t \001(\010\022\027\n\017can_use_profile\030\n \001(\010\""
+    "\323\001\n\rGameLevelInfo\022\020\n\010is_trial\030\004 \001(\010\022\023\n\013i"
+    "s_lifetime\030\005 \001(\010\022\025\n\ris_restricted\030\006 \001(\010\022"
+    "\017\n\007is_beta\030\007 \001(\010\022\014\n\004name\030\010 \001(\t\022\017\n\007progra"
+    "m\030\t \001(\007\0229\n\010licenses\030\n \003(\0132\'.bgs.protocol"
+    ".account.v1.AccountLicense\022\031\n\021realm_perm"
+    "issions\030\013 \001(\r\"\205\001\n\014GameTimeInfo\022\036\n\026is_unl"
+    "imited_play_time\030\003 \001(\010\022\031\n\021play_time_expi"
+    "res\030\005 \001(\004\022\027\n\017is_subscription\030\006 \001(\010\022!\n\031is"
+    "_recurring_subscription\030\007 \001(\010\"\261\001\n\025GameTi"
+    "meRemainingInfo\022\031\n\021minutes_remaining\030\001 \001"
+    "(\r\022(\n parental_daily_minutes_remaining\030\002"
+    " \001(\r\022)\n!parental_weekly_minutes_remainin"
+    "g\030\003 \001(\r\022(\n\034seconds_remaining_until_kick\030"
+    "\004 \001(\rB\002\030\001\"\220\001\n\nGameStatus\022\024\n\014is_suspended"
+    "\030\004 \001(\010\022\021\n\tis_banned\030\005 \001(\010\022\032\n\022suspension_"
+    "expires\030\006 \001(\004\022\017\n\007program\030\007 \001(\007\022\021\n\tis_loc"
+    "ked\030\010 \001(\010\022\031\n\021is_bam_unlockable\030\t \001(\010\"\033\n\007"
+    "RAFInfo\022\020\n\010raf_info\030\001 \001(\014\"\201\002\n\017GameSessio"
+    "nInfo\022\026\n\nstart_time\030\003 \001(\rB\002\030\001\022>\n\010locatio"
+    "n\030\004 \001(\0132,.bgs.protocol.account.v1.GameSe"
+    "ssionLocation\022\026\n\016has_benefactor\030\005 \001(\010\022\024\n"
+    "\014is_using_igr\030\006 \001(\010\022 \n\030parental_controls"
+    "_active\030\007 \001(\010\022\026\n\016start_time_sec\030\010 \001(\004\022.\n"
+    "\006igr_id\030\t \001(\0132\036.bgs.protocol.account.v1."
+    "IgrId\"D\n\025GameSessionUpdateInfo\022+\n\004cais\030\010"
+    " \001(\0132\035.bgs.protocol.account.v1.CAIS\"H\n\023G"
+    "ameSessionLocation\022\022\n\nip_address\030\001 \001(\t\022\017"
+    "\n\007country\030\002 \001(\r\022\014\n\004city\030\003 \001(\t\"O\n\004CAIS\022\026\n"
+    "\016played_minutes\030\001 \001(\r\022\026\n\016rested_minutes\030"
+    "\002 \001(\r\022\027\n\017last_heard_time\030\003 \001(\004\"]\n\017GameAc"
+    "countList\022\016\n\006region\030\003 \001(\r\022:\n\006handle\030\004 \003("
+    "\0132*.bgs.protocol.account.v1.GameAccountH"
+    "andle\"\232\003\n\014AccountState\022E\n\022account_level_"
+    "info\030\001 \001(\0132).bgs.protocol.account.v1.Acc"
+    "ountLevelInfo\022:\n\014privacy_info\030\002 \001(\0132$.bg"
+    "s.protocol.account.v1.PrivacyInfo\022K\n\025par"
+    "ental_control_info\030\003 \001(\0132,.bgs.protocol."
+    "account.v1.ParentalControlInfo\022\?\n\017game_l"
+    "evel_info\030\005 \003(\0132&.bgs.protocol.account.v"
+    "1.GameLevelInfo\0228\n\013game_status\030\006 \003(\0132#.b"
+    "gs.protocol.account.v1.GameStatus\022\?\n\rgam"
+    "e_accounts\030\007 \003(\0132(.bgs.protocol.account."
+    "v1.GameAccountList\"\223\001\n\022AccountStateTagge"
+    "d\022<\n\raccount_state\030\001 \001(\0132%.bgs.protocol."
+    "account.v1.AccountState\022\?\n\014account_tags\030"
+    "\002 \001(\0132).bgs.protocol.account.v1.AccountF"
+    "ieldTags\"\200\002\n\020GameAccountState\022\?\n\017game_le"
+    "vel_info\030\001 \001(\0132&.bgs.protocol.account.v1"
+    ".GameLevelInfo\022=\n\016game_time_info\030\002 \001(\0132%"
+    ".bgs.protocol.account.v1.GameTimeInfo\0228\n"
+    "\013game_status\030\003 \001(\0132#.bgs.protocol.accoun"
+    "t.v1.GameStatus\0222\n\010raf_info\030\004 \001(\0132 .bgs."
+    "protocol.account.v1.RAFInfo\"\251\001\n\026GameAcco"
+    "untStateTagged\022E\n\022game_account_state\030\001 \001"
+    "(\0132).bgs.protocol.account.v1.GameAccount"
+    "State\022H\n\021game_account_tags\030\002 \001(\0132-.bgs.p"
+    "rotocol.account.v1.GameAccountFieldTags\""
+    "/\n\016AuthorizedData\022\014\n\004data\030\001 \001(\t\022\017\n\007licen"
+    "se\030\002 \003(\r\"j\n\005IgrId\022B\n\014game_account\030\001 \001(\0132"
+    "*.bgs.protocol.account.v1.GameAccountHan"
+    "dleH\000\022\025\n\013external_id\030\002 \001(\007H\000B\006\n\004type\"4\n\n"
+    "IgrAddress\022\026\n\016client_address\030\001 \001(\t\022\016\n\006re"
+    "gion\030\002 \001(\r\"\262\001\n\022AccountRestriction\022\026\n\016res"
+    "triction_id\030\001 \001(\r\022\017\n\007program\030\002 \001(\007\0226\n\004ty"
+    "pe\030\003 \001(\0162(.bgs.protocol.account.v1.Restr"
+    "ictionType\022\020\n\010platform\030\004 \003(\007\022\023\n\013expire_t"
+    "ime\030\005 \001(\004\022\024\n\014created_time\030\006 \001(\004*\265\001\n\032Iden"
+    "tityVerificationStatus\022\021\n\rIDENT_NO_DATA\020"
+    "\000\022\021\n\rIDENT_PENDING\020\001\022\021\n\rIDENT_OVER_18\020\002\022"
+    "\022\n\016IDENT_UNDER_18\020\003\022\020\n\014IDENT_FAILED\020\004\022\021\n"
+    "\rIDENT_SUCCESS\020\005\022\022\n\016IDENT_SUCC_MNL\020\006\022\021\n\r"
+    "IDENT_UNKNOWN\020\007*\232\001\n\017RestrictionType\022\013\n\007U"
+    "NKNOWN\020\000\022\027\n\023GAME_ACCOUNT_BANNED\020\001\022\032\n\026GAM"
+    "E_ACCOUNT_SUSPENDED\020\002\022\022\n\016ACCOUNT_LOCKED\020"
+    "\003\022\025\n\021ACCOUNT_SQUELCHED\020\004\022\032\n\026CLUB_MEMBERS"
+    "HIP_LOCKED\020\005B\002H\001", 5976);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "account_types.proto", &protobuf_RegisterTypes);
   AccountId::default_instance_ = new AccountId();
   AccountLicense::default_instance_ = new AccountLicense();
-  AccountCredential::default_instance_ = new AccountCredential();
-  AccountBlob::default_instance_ = new AccountBlob();
-  AccountBlobList::default_instance_ = new AccountBlobList();
   GameAccountHandle::default_instance_ = new GameAccountHandle();
-  GameAccountLink::default_instance_ = new GameAccountLink();
-  GameAccountBlob::default_instance_ = new GameAccountBlob();
-  GameAccountBlobList::default_instance_ = new GameAccountBlobList();
   AccountReference::default_instance_ = new AccountReference();
   Identity::default_instance_ = new Identity();
-  AccountInfo::default_instance_ = new AccountInfo();
   ProgramTag::default_instance_ = new ProgramTag();
   RegionTag::default_instance_ = new RegionTag();
   AccountFieldTags::default_instance_ = new AccountFieldTags();
@@ -1399,25 +1092,15 @@ void protobuf_AddDesc_account_5ftypes_2eproto() {
   GameAccountState::default_instance_ = new GameAccountState();
   GameAccountStateTagged::default_instance_ = new GameAccountStateTagged();
   AuthorizedData::default_instance_ = new AuthorizedData();
-  BenefactorAddress::default_instance_ = new BenefactorAddress();
-  ExternalBenefactorLookup::default_instance_ = new ExternalBenefactorLookup();
-  AuthBenefactor::default_instance_ = new AuthBenefactor();
-  ApplicationInfo::default_instance_ = new ApplicationInfo();
-  DeductRecord::default_instance_ = new DeductRecord();
   IgrId::default_instance_ = new IgrId();
   IgrId_default_oneof_instance_ = new IgrIdOneofInstance;
+  IgrAddress::default_instance_ = new IgrAddress();
+  AccountRestriction::default_instance_ = new AccountRestriction();
   AccountId::default_instance_->InitAsDefaultInstance();
   AccountLicense::default_instance_->InitAsDefaultInstance();
-  AccountCredential::default_instance_->InitAsDefaultInstance();
-  AccountBlob::default_instance_->InitAsDefaultInstance();
-  AccountBlobList::default_instance_->InitAsDefaultInstance();
   GameAccountHandle::default_instance_->InitAsDefaultInstance();
-  GameAccountLink::default_instance_->InitAsDefaultInstance();
-  GameAccountBlob::default_instance_->InitAsDefaultInstance();
-  GameAccountBlobList::default_instance_->InitAsDefaultInstance();
   AccountReference::default_instance_->InitAsDefaultInstance();
   Identity::default_instance_->InitAsDefaultInstance();
-  AccountInfo::default_instance_->InitAsDefaultInstance();
   ProgramTag::default_instance_->InitAsDefaultInstance();
   RegionTag::default_instance_->InitAsDefaultInstance();
   AccountFieldTags::default_instance_->InitAsDefaultInstance();
@@ -1443,12 +1126,9 @@ void protobuf_AddDesc_account_5ftypes_2eproto() {
   GameAccountState::default_instance_->InitAsDefaultInstance();
   GameAccountStateTagged::default_instance_->InitAsDefaultInstance();
   AuthorizedData::default_instance_->InitAsDefaultInstance();
-  BenefactorAddress::default_instance_->InitAsDefaultInstance();
-  ExternalBenefactorLookup::default_instance_->InitAsDefaultInstance();
-  AuthBenefactor::default_instance_->InitAsDefaultInstance();
-  ApplicationInfo::default_instance_->InitAsDefaultInstance();
-  DeductRecord::default_instance_->InitAsDefaultInstance();
   IgrId::default_instance_->InitAsDefaultInstance();
+  IgrAddress::default_instance_->InitAsDefaultInstance();
+  AccountRestriction::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_account_5ftypes_2eproto);
 }
 
@@ -1466,6 +1146,8 @@ bool IdentityVerificationStatus_IsValid(int value) {
   switch(value) {
     case 0:
     case 1:
+    case 2:
+    case 3:
     case 4:
     case 5:
     case 6:
@@ -1476,6 +1158,24 @@ bool IdentityVerificationStatus_IsValid(int value) {
   }
 }
 
+const ::google::protobuf::EnumDescriptor* RestrictionType_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RestrictionType_descriptor_;
+}
+bool RestrictionType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
 
 // ===================================================================
 
@@ -1976,1624 +1676,6 @@ void AccountLicense::Swap(AccountLicense* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int AccountCredential::kIdFieldNumber;
-const int AccountCredential::kDataFieldNumber;
-#endif  // !_MSC_VER
-
-AccountCredential::AccountCredential()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountCredential)
-}
-
-void AccountCredential::InitAsDefaultInstance() {
-}
-
-AccountCredential::AccountCredential(const AccountCredential& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountCredential)
-}
-
-void AccountCredential::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  id_ = 0u;
-  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-AccountCredential::~AccountCredential() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountCredential)
-  SharedDtor();
-}
-
-void AccountCredential::SharedDtor() {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete data_;
-  }
-  if (this != default_instance_) {
-  }
-}
-
-void AccountCredential::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* AccountCredential::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return AccountCredential_descriptor_;
-}
-
-const AccountCredential& AccountCredential::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-AccountCredential* AccountCredential::default_instance_ = NULL;
-
-AccountCredential* AccountCredential::New() const {
-  return new AccountCredential;
-}
-
-void AccountCredential::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
-    id_ = 0u;
-    if (has_data()) {
-      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        data_->clear();
-      }
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool AccountCredential::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountCredential)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required uint32 id = 1;
-      case 1: {
-        if (tag == 8) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &id_)));
-          set_has_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_data;
-        break;
-      }
-
-      // optional bytes data = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_data:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
-                input, this->mutable_data()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountCredential)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountCredential)
-  return false;
-#undef DO_
-}
-
-void AccountCredential::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountCredential)
-  // required uint32 id = 1;
-  if (has_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
-  }
-
-  // optional bytes data = 2;
-  if (has_data()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
-      2, this->data(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountCredential)
-}
-
-::google::protobuf::uint8* AccountCredential::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountCredential)
-  // required uint32 id = 1;
-  if (has_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
-  }
-
-  // optional bytes data = 2;
-  if (has_data()) {
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
-        2, this->data(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountCredential)
-  return target;
-}
-
-int AccountCredential::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required uint32 id = 1;
-    if (has_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->id());
-    }
-
-    // optional bytes data = 2;
-    if (has_data()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::BytesSize(
-          this->data());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void AccountCredential::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const AccountCredential* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AccountCredential*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void AccountCredential::MergeFrom(const AccountCredential& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_id()) {
-      set_id(from.id());
-    }
-    if (from.has_data()) {
-      set_data(from.data());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void AccountCredential::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void AccountCredential::CopyFrom(const AccountCredential& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AccountCredential::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
-  return true;
-}
-
-void AccountCredential::Swap(AccountCredential* other) {
-  if (other != this) {
-    std::swap(id_, other->id_);
-    std::swap(data_, other->data_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata AccountCredential::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AccountCredential_descriptor_;
-  metadata.reflection = AccountCredential_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int AccountBlob::kIdFieldNumber;
-const int AccountBlob::kRegionFieldNumber;
-const int AccountBlob::kEmailFieldNumber;
-const int AccountBlob::kFlagsFieldNumber;
-const int AccountBlob::kSecureReleaseFieldNumber;
-const int AccountBlob::kWhitelistStartFieldNumber;
-const int AccountBlob::kWhitelistEndFieldNumber;
-const int AccountBlob::kFullNameFieldNumber;
-const int AccountBlob::kLicensesFieldNumber;
-const int AccountBlob::kCredentialsFieldNumber;
-const int AccountBlob::kAccountLinksFieldNumber;
-const int AccountBlob::kBattleTagFieldNumber;
-const int AccountBlob::kDefaultCurrencyFieldNumber;
-const int AccountBlob::kLegalRegionFieldNumber;
-const int AccountBlob::kLegalLocaleFieldNumber;
-const int AccountBlob::kCacheExpirationFieldNumber;
-const int AccountBlob::kParentalControlInfoFieldNumber;
-const int AccountBlob::kCountryFieldNumber;
-const int AccountBlob::kPreferredRegionFieldNumber;
-const int AccountBlob::kIdentityCheckStatusFieldNumber;
-const int AccountBlob::kCaisIdFieldNumber;
-#endif  // !_MSC_VER
-
-AccountBlob::AccountBlob()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountBlob)
-}
-
-void AccountBlob::InitAsDefaultInstance() {
-  parental_control_info_ = const_cast< ::bgs::protocol::account::v1::ParentalControlInfo*>(&::bgs::protocol::account::v1::ParentalControlInfo::default_instance());
-}
-
-AccountBlob::AccountBlob(const AccountBlob& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountBlob)
-}
-
-void AccountBlob::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  id_ = 0u;
-  region_ = 0u;
-  flags_ = GOOGLE_ULONGLONG(0);
-  secure_release_ = GOOGLE_ULONGLONG(0);
-  whitelist_start_ = GOOGLE_ULONGLONG(0);
-  whitelist_end_ = GOOGLE_ULONGLONG(0);
-  full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  default_currency_ = 0u;
-  legal_region_ = 0u;
-  legal_locale_ = 0u;
-  cache_expiration_ = GOOGLE_ULONGLONG(0);
-  parental_control_info_ = NULL;
-  country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  preferred_region_ = 0u;
-  identity_check_status_ = 0;
-  cais_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-AccountBlob::~AccountBlob() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountBlob)
-  SharedDtor();
-}
-
-void AccountBlob::SharedDtor() {
-  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete full_name_;
-  }
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete country_;
-  }
-  if (cais_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete cais_id_;
-  }
-  if (this != default_instance_) {
-    delete parental_control_info_;
-  }
-}
-
-void AccountBlob::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* AccountBlob::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return AccountBlob_descriptor_;
-}
-
-const AccountBlob& AccountBlob::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-AccountBlob* AccountBlob::default_instance_ = NULL;
-
-AccountBlob* AccountBlob::New() const {
-  return new AccountBlob;
-}
-
-void AccountBlob::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<AccountBlob*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 251) {
-    ZR_(id_, region_);
-    ZR_(flags_, whitelist_end_);
-    if (has_full_name()) {
-      if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        full_name_->clear();
-      }
-    }
-  }
-  if (_has_bits_[8 / 32] & 63488) {
-    ZR_(default_currency_, cache_expiration_);
-    if (has_battle_tag()) {
-      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        battle_tag_->clear();
-      }
-    }
-    legal_locale_ = 0u;
-  }
-  if (_has_bits_[16 / 32] & 2031616) {
-    if (has_parental_control_info()) {
-      if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
-    }
-    if (has_country()) {
-      if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        country_->clear();
-      }
-    }
-    preferred_region_ = 0u;
-    identity_check_status_ = 0;
-    if (has_cais_id()) {
-      if (cais_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        cais_id_->clear();
-      }
-    }
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  email_.Clear();
-  licenses_.Clear();
-  credentials_.Clear();
-  account_links_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool AccountBlob::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountBlob)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required fixed32 id = 2;
-      case 2: {
-        if (tag == 21) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &id_)));
-          set_has_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_region;
-        break;
-      }
-
-      // required uint32 region = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_region:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &region_)));
-          set_has_region();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_email;
-        break;
-      }
-
-      // repeated string email = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_email:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->add_email()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->email(this->email_size() - 1).data(),
-            this->email(this->email_size() - 1).length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "email");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_email;
-        if (input->ExpectTag(40)) goto parse_flags;
-        break;
-      }
-
-      // required uint64 flags = 5;
-      case 5: {
-        if (tag == 40) {
-         parse_flags:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &flags_)));
-          set_has_flags();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(48)) goto parse_secure_release;
-        break;
-      }
-
-      // optional uint64 secure_release = 6;
-      case 6: {
-        if (tag == 48) {
-         parse_secure_release:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &secure_release_)));
-          set_has_secure_release();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(56)) goto parse_whitelist_start;
-        break;
-      }
-
-      // optional uint64 whitelist_start = 7;
-      case 7: {
-        if (tag == 56) {
-         parse_whitelist_start:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &whitelist_start_)));
-          set_has_whitelist_start();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(64)) goto parse_whitelist_end;
-        break;
-      }
-
-      // optional uint64 whitelist_end = 8;
-      case 8: {
-        if (tag == 64) {
-         parse_whitelist_end:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &whitelist_end_)));
-          set_has_whitelist_end();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(82)) goto parse_full_name;
-        break;
-      }
-
-      // required string full_name = 10;
-      case 10: {
-        if (tag == 82) {
-         parse_full_name:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_full_name()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->full_name().data(), this->full_name().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "full_name");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(162)) goto parse_licenses;
-        break;
-      }
-
-      // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-      case 20: {
-        if (tag == 162) {
-         parse_licenses:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_licenses()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(162)) goto parse_licenses;
-        if (input->ExpectTag(170)) goto parse_credentials;
-        break;
-      }
-
-      // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
-      case 21: {
-        if (tag == 170) {
-         parse_credentials:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_credentials()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(170)) goto parse_credentials;
-        if (input->ExpectTag(178)) goto parse_account_links;
-        break;
-      }
-
-      // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
-      case 22: {
-        if (tag == 178) {
-         parse_account_links:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_account_links()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(178)) goto parse_account_links;
-        if (input->ExpectTag(186)) goto parse_battle_tag;
-        break;
-      }
-
-      // optional string battle_tag = 23;
-      case 23: {
-        if (tag == 186) {
-         parse_battle_tag:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_battle_tag()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->battle_tag().data(), this->battle_tag().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "battle_tag");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(205)) goto parse_default_currency;
-        break;
-      }
-
-      // optional fixed32 default_currency = 25;
-      case 25: {
-        if (tag == 205) {
-         parse_default_currency:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &default_currency_)));
-          set_has_default_currency();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(208)) goto parse_legal_region;
-        break;
-      }
-
-      // optional uint32 legal_region = 26;
-      case 26: {
-        if (tag == 208) {
-         parse_legal_region:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &legal_region_)));
-          set_has_legal_region();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(221)) goto parse_legal_locale;
-        break;
-      }
-
-      // optional fixed32 legal_locale = 27;
-      case 27: {
-        if (tag == 221) {
-         parse_legal_locale:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &legal_locale_)));
-          set_has_legal_locale();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(240)) goto parse_cache_expiration;
-        break;
-      }
-
-      // required uint64 cache_expiration = 30;
-      case 30: {
-        if (tag == 240) {
-         parse_cache_expiration:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &cache_expiration_)));
-          set_has_cache_expiration();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(250)) goto parse_parental_control_info;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
-      case 31: {
-        if (tag == 250) {
-         parse_parental_control_info:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_parental_control_info()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(258)) goto parse_country;
-        break;
-      }
-
-      // optional string country = 32;
-      case 32: {
-        if (tag == 258) {
-         parse_country:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_country()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->country().data(), this->country().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "country");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(264)) goto parse_preferred_region;
-        break;
-      }
-
-      // optional uint32 preferred_region = 33;
-      case 33: {
-        if (tag == 264) {
-         parse_preferred_region:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &preferred_region_)));
-          set_has_preferred_region();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(272)) goto parse_identity_check_status;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
-      case 34: {
-        if (tag == 272) {
-         parse_identity_check_status:
-          int value;
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
-                 input, &value)));
-          if (::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value)) {
-            set_identity_check_status(static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(value));
-          } else {
-            mutable_unknown_fields()->AddVarint(34, value);
-          }
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(282)) goto parse_cais_id;
-        break;
-      }
-
-      // optional string cais_id = 35;
-      case 35: {
-        if (tag == 282) {
-         parse_cais_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_cais_id()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->cais_id().data(), this->cais_id().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "cais_id");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountBlob)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountBlob)
-  return false;
-#undef DO_
-}
-
-void AccountBlob::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountBlob)
-  // required fixed32 id = 2;
-  if (has_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->id(), output);
-  }
-
-  // required uint32 region = 3;
-  if (has_region()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->region(), output);
-  }
-
-  // repeated string email = 4;
-  for (int i = 0; i < this->email_size(); i++) {
-  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-    this->email(i).data(), this->email(i).length(),
-    ::google::protobuf::internal::WireFormat::SERIALIZE,
-    "email");
-    ::google::protobuf::internal::WireFormatLite::WriteString(
-      4, this->email(i), output);
-  }
-
-  // required uint64 flags = 5;
-  if (has_flags()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->flags(), output);
-  }
-
-  // optional uint64 secure_release = 6;
-  if (has_secure_release()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->secure_release(), output);
-  }
-
-  // optional uint64 whitelist_start = 7;
-  if (has_whitelist_start()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->whitelist_start(), output);
-  }
-
-  // optional uint64 whitelist_end = 8;
-  if (has_whitelist_end()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->whitelist_end(), output);
-  }
-
-  // required string full_name = 10;
-  if (has_full_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->full_name().data(), this->full_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "full_name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      10, this->full_name(), output);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-  for (int i = 0; i < this->licenses_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      20, this->licenses(i), output);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
-  for (int i = 0; i < this->credentials_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      21, this->credentials(i), output);
-  }
-
-  // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
-  for (int i = 0; i < this->account_links_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      22, this->account_links(i), output);
-  }
-
-  // optional string battle_tag = 23;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      23, this->battle_tag(), output);
-  }
-
-  // optional fixed32 default_currency = 25;
-  if (has_default_currency()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(25, this->default_currency(), output);
-  }
-
-  // optional uint32 legal_region = 26;
-  if (has_legal_region()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(26, this->legal_region(), output);
-  }
-
-  // optional fixed32 legal_locale = 27;
-  if (has_legal_locale()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(27, this->legal_locale(), output);
-  }
-
-  // required uint64 cache_expiration = 30;
-  if (has_cache_expiration()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(30, this->cache_expiration(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
-  if (has_parental_control_info()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      31, this->parental_control_info(), output);
-  }
-
-  // optional string country = 32;
-  if (has_country()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->country().data(), this->country().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "country");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      32, this->country(), output);
-  }
-
-  // optional uint32 preferred_region = 33;
-  if (has_preferred_region()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(33, this->preferred_region(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
-  if (has_identity_check_status()) {
-    ::google::protobuf::internal::WireFormatLite::WriteEnum(
-      34, this->identity_check_status(), output);
-  }
-
-  // optional string cais_id = 35;
-  if (has_cais_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->cais_id().data(), this->cais_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "cais_id");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      35, this->cais_id(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountBlob)
-}
-
-::google::protobuf::uint8* AccountBlob::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountBlob)
-  // required fixed32 id = 2;
-  if (has_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->id(), target);
-  }
-
-  // required uint32 region = 3;
-  if (has_region()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->region(), target);
-  }
-
-  // repeated string email = 4;
-  for (int i = 0; i < this->email_size(); i++) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->email(i).data(), this->email(i).length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "email");
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteStringToArray(4, this->email(i), target);
-  }
-
-  // required uint64 flags = 5;
-  if (has_flags()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->flags(), target);
-  }
-
-  // optional uint64 secure_release = 6;
-  if (has_secure_release()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->secure_release(), target);
-  }
-
-  // optional uint64 whitelist_start = 7;
-  if (has_whitelist_start()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->whitelist_start(), target);
-  }
-
-  // optional uint64 whitelist_end = 8;
-  if (has_whitelist_end()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->whitelist_end(), target);
-  }
-
-  // required string full_name = 10;
-  if (has_full_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->full_name().data(), this->full_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "full_name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        10, this->full_name(), target);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-  for (int i = 0; i < this->licenses_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        20, this->licenses(i), target);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
-  for (int i = 0; i < this->credentials_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        21, this->credentials(i), target);
-  }
-
-  // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
-  for (int i = 0; i < this->account_links_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        22, this->account_links(i), target);
-  }
-
-  // optional string battle_tag = 23;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        23, this->battle_tag(), target);
-  }
-
-  // optional fixed32 default_currency = 25;
-  if (has_default_currency()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(25, this->default_currency(), target);
-  }
-
-  // optional uint32 legal_region = 26;
-  if (has_legal_region()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(26, this->legal_region(), target);
-  }
-
-  // optional fixed32 legal_locale = 27;
-  if (has_legal_locale()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(27, this->legal_locale(), target);
-  }
-
-  // required uint64 cache_expiration = 30;
-  if (has_cache_expiration()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(30, this->cache_expiration(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
-  if (has_parental_control_info()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        31, this->parental_control_info(), target);
-  }
-
-  // optional string country = 32;
-  if (has_country()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->country().data(), this->country().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "country");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        32, this->country(), target);
-  }
-
-  // optional uint32 preferred_region = 33;
-  if (has_preferred_region()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(33, this->preferred_region(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
-  if (has_identity_check_status()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
-      34, this->identity_check_status(), target);
-  }
-
-  // optional string cais_id = 35;
-  if (has_cais_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->cais_id().data(), this->cais_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "cais_id");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        35, this->cais_id(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountBlob)
-  return target;
-}
-
-int AccountBlob::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required fixed32 id = 2;
-    if (has_id()) {
-      total_size += 1 + 4;
-    }
-
-    // required uint32 region = 3;
-    if (has_region()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->region());
-    }
-
-    // required uint64 flags = 5;
-    if (has_flags()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->flags());
-    }
-
-    // optional uint64 secure_release = 6;
-    if (has_secure_release()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->secure_release());
-    }
-
-    // optional uint64 whitelist_start = 7;
-    if (has_whitelist_start()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->whitelist_start());
-    }
-
-    // optional uint64 whitelist_end = 8;
-    if (has_whitelist_end()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->whitelist_end());
-    }
-
-    // required string full_name = 10;
-    if (has_full_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->full_name());
-    }
-
-  }
-  if (_has_bits_[11 / 32] & (0xffu << (11 % 32))) {
-    // optional string battle_tag = 23;
-    if (has_battle_tag()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->battle_tag());
-    }
-
-    // optional fixed32 default_currency = 25;
-    if (has_default_currency()) {
-      total_size += 2 + 4;
-    }
-
-    // optional uint32 legal_region = 26;
-    if (has_legal_region()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->legal_region());
-    }
-
-    // optional fixed32 legal_locale = 27;
-    if (has_legal_locale()) {
-      total_size += 2 + 4;
-    }
-
-    // required uint64 cache_expiration = 30;
-    if (has_cache_expiration()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->cache_expiration());
-    }
-
-  }
-  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
-    // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
-    if (has_parental_control_info()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->parental_control_info());
-    }
-
-    // optional string country = 32;
-    if (has_country()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->country());
-    }
-
-    // optional uint32 preferred_region = 33;
-    if (has_preferred_region()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->preferred_region());
-    }
-
-    // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
-    if (has_identity_check_status()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::EnumSize(this->identity_check_status());
-    }
-
-    // optional string cais_id = 35;
-    if (has_cais_id()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->cais_id());
-    }
-
-  }
-  // repeated string email = 4;
-  total_size += 1 * this->email_size();
-  for (int i = 0; i < this->email_size(); i++) {
-    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
-      this->email(i));
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-  total_size += 2 * this->licenses_size();
-  for (int i = 0; i < this->licenses_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->licenses(i));
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
-  total_size += 2 * this->credentials_size();
-  for (int i = 0; i < this->credentials_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->credentials(i));
-  }
-
-  // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
-  total_size += 2 * this->account_links_size();
-  for (int i = 0; i < this->account_links_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->account_links(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void AccountBlob::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const AccountBlob* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AccountBlob*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void AccountBlob::MergeFrom(const AccountBlob& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  email_.MergeFrom(from.email_);
-  licenses_.MergeFrom(from.licenses_);
-  credentials_.MergeFrom(from.credentials_);
-  account_links_.MergeFrom(from.account_links_);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_id()) {
-      set_id(from.id());
-    }
-    if (from.has_region()) {
-      set_region(from.region());
-    }
-    if (from.has_flags()) {
-      set_flags(from.flags());
-    }
-    if (from.has_secure_release()) {
-      set_secure_release(from.secure_release());
-    }
-    if (from.has_whitelist_start()) {
-      set_whitelist_start(from.whitelist_start());
-    }
-    if (from.has_whitelist_end()) {
-      set_whitelist_end(from.whitelist_end());
-    }
-    if (from.has_full_name()) {
-      set_full_name(from.full_name());
-    }
-  }
-  if (from._has_bits_[11 / 32] & (0xffu << (11 % 32))) {
-    if (from.has_battle_tag()) {
-      set_battle_tag(from.battle_tag());
-    }
-    if (from.has_default_currency()) {
-      set_default_currency(from.default_currency());
-    }
-    if (from.has_legal_region()) {
-      set_legal_region(from.legal_region());
-    }
-    if (from.has_legal_locale()) {
-      set_legal_locale(from.legal_locale());
-    }
-    if (from.has_cache_expiration()) {
-      set_cache_expiration(from.cache_expiration());
-    }
-  }
-  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
-    if (from.has_parental_control_info()) {
-      mutable_parental_control_info()->::bgs::protocol::account::v1::ParentalControlInfo::MergeFrom(from.parental_control_info());
-    }
-    if (from.has_country()) {
-      set_country(from.country());
-    }
-    if (from.has_preferred_region()) {
-      set_preferred_region(from.preferred_region());
-    }
-    if (from.has_identity_check_status()) {
-      set_identity_check_status(from.identity_check_status());
-    }
-    if (from.has_cais_id()) {
-      set_cais_id(from.cais_id());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void AccountBlob::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void AccountBlob::CopyFrom(const AccountBlob& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AccountBlob::IsInitialized() const {
-  if ((_has_bits_[0] & 0x0000808b) != 0x0000808b) return false;
-
-  if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false;
-  if (!::google::protobuf::internal::AllAreInitialized(this->credentials())) return false;
-  if (!::google::protobuf::internal::AllAreInitialized(this->account_links())) return false;
-  return true;
-}
-
-void AccountBlob::Swap(AccountBlob* other) {
-  if (other != this) {
-    std::swap(id_, other->id_);
-    std::swap(region_, other->region_);
-    email_.Swap(&other->email_);
-    std::swap(flags_, other->flags_);
-    std::swap(secure_release_, other->secure_release_);
-    std::swap(whitelist_start_, other->whitelist_start_);
-    std::swap(whitelist_end_, other->whitelist_end_);
-    std::swap(full_name_, other->full_name_);
-    licenses_.Swap(&other->licenses_);
-    credentials_.Swap(&other->credentials_);
-    account_links_.Swap(&other->account_links_);
-    std::swap(battle_tag_, other->battle_tag_);
-    std::swap(default_currency_, other->default_currency_);
-    std::swap(legal_region_, other->legal_region_);
-    std::swap(legal_locale_, other->legal_locale_);
-    std::swap(cache_expiration_, other->cache_expiration_);
-    std::swap(parental_control_info_, other->parental_control_info_);
-    std::swap(country_, other->country_);
-    std::swap(preferred_region_, other->preferred_region_);
-    std::swap(identity_check_status_, other->identity_check_status_);
-    std::swap(cais_id_, other->cais_id_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata AccountBlob::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AccountBlob_descriptor_;
-  metadata.reflection = AccountBlob_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int AccountBlobList::kBlobFieldNumber;
-#endif  // !_MSC_VER
-
-AccountBlobList::AccountBlobList()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountBlobList)
-}
-
-void AccountBlobList::InitAsDefaultInstance() {
-}
-
-AccountBlobList::AccountBlobList(const AccountBlobList& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountBlobList)
-}
-
-void AccountBlobList::SharedCtor() {
-  _cached_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-AccountBlobList::~AccountBlobList() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountBlobList)
-  SharedDtor();
-}
-
-void AccountBlobList::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void AccountBlobList::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* AccountBlobList::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return AccountBlobList_descriptor_;
-}
-
-const AccountBlobList& AccountBlobList::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-AccountBlobList* AccountBlobList::default_instance_ = NULL;
-
-AccountBlobList* AccountBlobList::New() const {
-  return new AccountBlobList;
-}
-
-void AccountBlobList::Clear() {
-  blob_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool AccountBlobList::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountBlobList)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
-      case 1: {
-        if (tag == 10) {
-         parse_blob:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_blob()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(10)) goto parse_blob;
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountBlobList)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountBlobList)
-  return false;
-#undef DO_
-}
-
-void AccountBlobList::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountBlobList)
-  // repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
-  for (int i = 0; i < this->blob_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->blob(i), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountBlobList)
-}
-
-::google::protobuf::uint8* AccountBlobList::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountBlobList)
-  // repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
-  for (int i = 0; i < this->blob_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->blob(i), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountBlobList)
-  return target;
-}
-
-int AccountBlobList::ByteSize() const {
-  int total_size = 0;
-
-  // repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
-  total_size += 1 * this->blob_size();
-  for (int i = 0; i < this->blob_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->blob(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void AccountBlobList::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const AccountBlobList* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AccountBlobList*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void AccountBlobList::MergeFrom(const AccountBlobList& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  blob_.MergeFrom(from.blob_);
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void AccountBlobList::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void AccountBlobList::CopyFrom(const AccountBlobList& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AccountBlobList::IsInitialized() const {
-
-  if (!::google::protobuf::internal::AllAreInitialized(this->blob())) return false;
-  return true;
-}
-
-void AccountBlobList::Swap(AccountBlobList* other) {
-  if (other != this) {
-    blob_.Swap(&other->blob_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata AccountBlobList::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AccountBlobList_descriptor_;
-  metadata.reflection = AccountBlobList_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int GameAccountHandle::kIdFieldNumber;
 const int GameAccountHandle::kProgramFieldNumber;
 const int GameAccountHandle::kRegionFieldNumber;
@@ -3903,1378 +1985,6 @@ void GameAccountHandle::Swap(GameAccountHandle* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int GameAccountLink::kGameAccountFieldNumber;
-const int GameAccountLink::kNameFieldNumber;
-#endif  // !_MSC_VER
-
-GameAccountLink::GameAccountLink()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountLink)
-}
-
-void GameAccountLink::InitAsDefaultInstance() {
-  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
-}
-
-GameAccountLink::GameAccountLink(const GameAccountLink& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountLink)
-}
-
-void GameAccountLink::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  game_account_ = NULL;
-  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-GameAccountLink::~GameAccountLink() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountLink)
-  SharedDtor();
-}
-
-void GameAccountLink::SharedDtor() {
-  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete name_;
-  }
-  if (this != default_instance_) {
-    delete game_account_;
-  }
-}
-
-void GameAccountLink::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* GameAccountLink::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return GameAccountLink_descriptor_;
-}
-
-const GameAccountLink& GameAccountLink::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-GameAccountLink* GameAccountLink::default_instance_ = NULL;
-
-GameAccountLink* GameAccountLink::New() const {
-  return new GameAccountLink;
-}
-
-void GameAccountLink::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
-    if (has_game_account()) {
-      if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-    }
-    if (has_name()) {
-      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        name_->clear();
-      }
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool GameAccountLink::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountLink)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_name;
-        break;
-      }
-
-      // required string name = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_name:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_name()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->name().data(), this->name().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "name");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountLink)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountLink)
-  return false;
-#undef DO_
-}
-
-void GameAccountLink::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountLink)
-  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->game_account(), output);
-  }
-
-  // required string name = 2;
-  if (has_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->name().data(), this->name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->name(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountLink)
-}
-
-::google::protobuf::uint8* GameAccountLink::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountLink)
-  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->game_account(), target);
-  }
-
-  // required string name = 2;
-  if (has_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->name().data(), this->name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->name(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountLink)
-  return target;
-}
-
-int GameAccountLink::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-    if (has_game_account()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account());
-    }
-
-    // required string name = 2;
-    if (has_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->name());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void GameAccountLink::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const GameAccountLink* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountLink*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void GameAccountLink::MergeFrom(const GameAccountLink& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_game_account()) {
-      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
-    }
-    if (from.has_name()) {
-      set_name(from.name());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void GameAccountLink::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void GameAccountLink::CopyFrom(const GameAccountLink& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool GameAccountLink::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
-
-  if (has_game_account()) {
-    if (!this->game_account().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void GameAccountLink::Swap(GameAccountLink* other) {
-  if (other != this) {
-    std::swap(game_account_, other->game_account_);
-    std::swap(name_, other->name_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata GameAccountLink::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GameAccountLink_descriptor_;
-  metadata.reflection = GameAccountLink_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int GameAccountBlob::kGameAccountFieldNumber;
-const int GameAccountBlob::kNameFieldNumber;
-const int GameAccountBlob::kRealmPermissionsFieldNumber;
-const int GameAccountBlob::kStatusFieldNumber;
-const int GameAccountBlob::kFlagsFieldNumber;
-const int GameAccountBlob::kBillingFlagsFieldNumber;
-const int GameAccountBlob::kCacheExpirationFieldNumber;
-const int GameAccountBlob::kSubscriptionExpirationFieldNumber;
-const int GameAccountBlob::kUnitsRemainingFieldNumber;
-const int GameAccountBlob::kStatusExpirationFieldNumber;
-const int GameAccountBlob::kBoxLevelFieldNumber;
-const int GameAccountBlob::kBoxLevelExpirationFieldNumber;
-const int GameAccountBlob::kLicensesFieldNumber;
-const int GameAccountBlob::kRafAccountFieldNumber;
-const int GameAccountBlob::kRafInfoFieldNumber;
-const int GameAccountBlob::kRafExpirationFieldNumber;
-#endif  // !_MSC_VER
-
-GameAccountBlob::GameAccountBlob()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountBlob)
-}
-
-void GameAccountBlob::InitAsDefaultInstance() {
-  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
-}
-
-GameAccountBlob::GameAccountBlob(const GameAccountBlob& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountBlob)
-}
-
-void GameAccountBlob::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  game_account_ = NULL;
-  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  realm_permissions_ = 0u;
-  status_ = 0u;
-  flags_ = GOOGLE_ULONGLONG(0);
-  billing_flags_ = 0u;
-  cache_expiration_ = GOOGLE_ULONGLONG(0);
-  subscription_expiration_ = GOOGLE_ULONGLONG(0);
-  units_remaining_ = 0u;
-  status_expiration_ = GOOGLE_ULONGLONG(0);
-  box_level_ = 0u;
-  box_level_expiration_ = GOOGLE_ULONGLONG(0);
-  raf_account_ = 0u;
-  raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  raf_expiration_ = GOOGLE_ULONGLONG(0);
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-GameAccountBlob::~GameAccountBlob() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountBlob)
-  SharedDtor();
-}
-
-void GameAccountBlob::SharedDtor() {
-  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete name_;
-  }
-  if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete raf_info_;
-  }
-  if (this != default_instance_) {
-    delete game_account_;
-  }
-}
-
-void GameAccountBlob::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* GameAccountBlob::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return GameAccountBlob_descriptor_;
-}
-
-const GameAccountBlob& GameAccountBlob::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-GameAccountBlob* GameAccountBlob::default_instance_ = NULL;
-
-GameAccountBlob* GameAccountBlob::New() const {
-  return new GameAccountBlob;
-}
-
-void GameAccountBlob::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<GameAccountBlob*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 255) {
-    ZR_(realm_permissions_, billing_flags_);
-    if (has_game_account()) {
-      if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-    }
-    if (has_name()) {
-      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        name_->clear();
-      }
-    }
-    subscription_expiration_ = GOOGLE_ULONGLONG(0);
-  }
-  if (_has_bits_[8 / 32] & 61184) {
-    ZR_(status_expiration_, raf_account_);
-    units_remaining_ = 0u;
-    if (has_raf_info()) {
-      if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        raf_info_->clear();
-      }
-    }
-    raf_expiration_ = GOOGLE_ULONGLONG(0);
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  licenses_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool GameAccountBlob::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountBlob)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_name;
-        break;
-      }
-
-      // optional string name = 2 [default = ""];
-      case 2: {
-        if (tag == 18) {
-         parse_name:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_name()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->name().data(), this->name().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "name");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_realm_permissions;
-        break;
-      }
-
-      // optional uint32 realm_permissions = 3 [default = 0];
-      case 3: {
-        if (tag == 24) {
-         parse_realm_permissions:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &realm_permissions_)));
-          set_has_realm_permissions();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(32)) goto parse_status;
-        break;
-      }
-
-      // required uint32 status = 4;
-      case 4: {
-        if (tag == 32) {
-         parse_status:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &status_)));
-          set_has_status();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(40)) goto parse_flags;
-        break;
-      }
-
-      // optional uint64 flags = 5 [default = 0];
-      case 5: {
-        if (tag == 40) {
-         parse_flags:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &flags_)));
-          set_has_flags();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(48)) goto parse_billing_flags;
-        break;
-      }
-
-      // optional uint32 billing_flags = 6 [default = 0];
-      case 6: {
-        if (tag == 48) {
-         parse_billing_flags:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &billing_flags_)));
-          set_has_billing_flags();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(56)) goto parse_cache_expiration;
-        break;
-      }
-
-      // required uint64 cache_expiration = 7;
-      case 7: {
-        if (tag == 56) {
-         parse_cache_expiration:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &cache_expiration_)));
-          set_has_cache_expiration();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(80)) goto parse_subscription_expiration;
-        break;
-      }
-
-      // optional uint64 subscription_expiration = 10;
-      case 10: {
-        if (tag == 80) {
-         parse_subscription_expiration:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &subscription_expiration_)));
-          set_has_subscription_expiration();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(88)) goto parse_units_remaining;
-        break;
-      }
-
-      // optional uint32 units_remaining = 11;
-      case 11: {
-        if (tag == 88) {
-         parse_units_remaining:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &units_remaining_)));
-          set_has_units_remaining();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(96)) goto parse_status_expiration;
-        break;
-      }
-
-      // optional uint64 status_expiration = 12;
-      case 12: {
-        if (tag == 96) {
-         parse_status_expiration:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &status_expiration_)));
-          set_has_status_expiration();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(104)) goto parse_box_level;
-        break;
-      }
-
-      // optional uint32 box_level = 13;
-      case 13: {
-        if (tag == 104) {
-         parse_box_level:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &box_level_)));
-          set_has_box_level();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(112)) goto parse_box_level_expiration;
-        break;
-      }
-
-      // optional uint64 box_level_expiration = 14;
-      case 14: {
-        if (tag == 112) {
-         parse_box_level_expiration:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &box_level_expiration_)));
-          set_has_box_level_expiration();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(162)) goto parse_licenses;
-        break;
-      }
-
-      // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-      case 20: {
-        if (tag == 162) {
-         parse_licenses:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_licenses()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(162)) goto parse_licenses;
-        if (input->ExpectTag(173)) goto parse_raf_account;
-        break;
-      }
-
-      // optional fixed32 raf_account = 21;
-      case 21: {
-        if (tag == 173) {
-         parse_raf_account:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &raf_account_)));
-          set_has_raf_account();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(178)) goto parse_raf_info;
-        break;
-      }
-
-      // optional bytes raf_info = 22;
-      case 22: {
-        if (tag == 178) {
-         parse_raf_info:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
-                input, this->mutable_raf_info()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(184)) goto parse_raf_expiration;
-        break;
-      }
-
-      // optional uint64 raf_expiration = 23;
-      case 23: {
-        if (tag == 184) {
-         parse_raf_expiration:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &raf_expiration_)));
-          set_has_raf_expiration();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountBlob)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountBlob)
-  return false;
-#undef DO_
-}
-
-void GameAccountBlob::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountBlob)
-  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->game_account(), output);
-  }
-
-  // optional string name = 2 [default = ""];
-  if (has_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->name().data(), this->name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->name(), output);
-  }
-
-  // optional uint32 realm_permissions = 3 [default = 0];
-  if (has_realm_permissions()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->realm_permissions(), output);
-  }
-
-  // required uint32 status = 4;
-  if (has_status()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->status(), output);
-  }
-
-  // optional uint64 flags = 5 [default = 0];
-  if (has_flags()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->flags(), output);
-  }
-
-  // optional uint32 billing_flags = 6 [default = 0];
-  if (has_billing_flags()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->billing_flags(), output);
-  }
-
-  // required uint64 cache_expiration = 7;
-  if (has_cache_expiration()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->cache_expiration(), output);
-  }
-
-  // optional uint64 subscription_expiration = 10;
-  if (has_subscription_expiration()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(10, this->subscription_expiration(), output);
-  }
-
-  // optional uint32 units_remaining = 11;
-  if (has_units_remaining()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->units_remaining(), output);
-  }
-
-  // optional uint64 status_expiration = 12;
-  if (has_status_expiration()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(12, this->status_expiration(), output);
-  }
-
-  // optional uint32 box_level = 13;
-  if (has_box_level()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(13, this->box_level(), output);
-  }
-
-  // optional uint64 box_level_expiration = 14;
-  if (has_box_level_expiration()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(14, this->box_level_expiration(), output);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-  for (int i = 0; i < this->licenses_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      20, this->licenses(i), output);
-  }
-
-  // optional fixed32 raf_account = 21;
-  if (has_raf_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(21, this->raf_account(), output);
-  }
-
-  // optional bytes raf_info = 22;
-  if (has_raf_info()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
-      22, this->raf_info(), output);
-  }
-
-  // optional uint64 raf_expiration = 23;
-  if (has_raf_expiration()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(23, this->raf_expiration(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountBlob)
-}
-
-::google::protobuf::uint8* GameAccountBlob::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountBlob)
-  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->game_account(), target);
-  }
-
-  // optional string name = 2 [default = ""];
-  if (has_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->name().data(), this->name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->name(), target);
-  }
-
-  // optional uint32 realm_permissions = 3 [default = 0];
-  if (has_realm_permissions()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->realm_permissions(), target);
-  }
-
-  // required uint32 status = 4;
-  if (has_status()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->status(), target);
-  }
-
-  // optional uint64 flags = 5 [default = 0];
-  if (has_flags()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->flags(), target);
-  }
-
-  // optional uint32 billing_flags = 6 [default = 0];
-  if (has_billing_flags()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->billing_flags(), target);
-  }
-
-  // required uint64 cache_expiration = 7;
-  if (has_cache_expiration()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->cache_expiration(), target);
-  }
-
-  // optional uint64 subscription_expiration = 10;
-  if (has_subscription_expiration()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(10, this->subscription_expiration(), target);
-  }
-
-  // optional uint32 units_remaining = 11;
-  if (has_units_remaining()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->units_remaining(), target);
-  }
-
-  // optional uint64 status_expiration = 12;
-  if (has_status_expiration()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(12, this->status_expiration(), target);
-  }
-
-  // optional uint32 box_level = 13;
-  if (has_box_level()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(13, this->box_level(), target);
-  }
-
-  // optional uint64 box_level_expiration = 14;
-  if (has_box_level_expiration()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(14, this->box_level_expiration(), target);
-  }
-
-  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-  for (int i = 0; i < this->licenses_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        20, this->licenses(i), target);
-  }
-
-  // optional fixed32 raf_account = 21;
-  if (has_raf_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(21, this->raf_account(), target);
-  }
-
-  // optional bytes raf_info = 22;
-  if (has_raf_info()) {
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
-        22, this->raf_info(), target);
-  }
-
-  // optional uint64 raf_expiration = 23;
-  if (has_raf_expiration()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(23, this->raf_expiration(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountBlob)
-  return target;
-}
-
-int GameAccountBlob::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-    if (has_game_account()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account());
-    }
-
-    // optional string name = 2 [default = ""];
-    if (has_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->name());
-    }
-
-    // optional uint32 realm_permissions = 3 [default = 0];
-    if (has_realm_permissions()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->realm_permissions());
-    }
-
-    // required uint32 status = 4;
-    if (has_status()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->status());
-    }
-
-    // optional uint64 flags = 5 [default = 0];
-    if (has_flags()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->flags());
-    }
-
-    // optional uint32 billing_flags = 6 [default = 0];
-    if (has_billing_flags()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->billing_flags());
-    }
-
-    // required uint64 cache_expiration = 7;
-    if (has_cache_expiration()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->cache_expiration());
-    }
-
-    // optional uint64 subscription_expiration = 10;
-    if (has_subscription_expiration()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->subscription_expiration());
-    }
-
-  }
-  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
-    // optional uint32 units_remaining = 11;
-    if (has_units_remaining()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->units_remaining());
-    }
-
-    // optional uint64 status_expiration = 12;
-    if (has_status_expiration()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->status_expiration());
-    }
-
-    // optional uint32 box_level = 13;
-    if (has_box_level()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->box_level());
-    }
-
-    // optional uint64 box_level_expiration = 14;
-    if (has_box_level_expiration()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->box_level_expiration());
-    }
-
-    // optional fixed32 raf_account = 21;
-    if (has_raf_account()) {
-      total_size += 2 + 4;
-    }
-
-    // optional bytes raf_info = 22;
-    if (has_raf_info()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::BytesSize(
-          this->raf_info());
-    }
-
-    // optional uint64 raf_expiration = 23;
-    if (has_raf_expiration()) {
-      total_size += 2 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->raf_expiration());
-    }
-
-  }
-  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-  total_size += 2 * this->licenses_size();
-  for (int i = 0; i < this->licenses_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->licenses(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void GameAccountBlob::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const GameAccountBlob* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountBlob*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void GameAccountBlob::MergeFrom(const GameAccountBlob& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  licenses_.MergeFrom(from.licenses_);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_game_account()) {
-      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
-    }
-    if (from.has_name()) {
-      set_name(from.name());
-    }
-    if (from.has_realm_permissions()) {
-      set_realm_permissions(from.realm_permissions());
-    }
-    if (from.has_status()) {
-      set_status(from.status());
-    }
-    if (from.has_flags()) {
-      set_flags(from.flags());
-    }
-    if (from.has_billing_flags()) {
-      set_billing_flags(from.billing_flags());
-    }
-    if (from.has_cache_expiration()) {
-      set_cache_expiration(from.cache_expiration());
-    }
-    if (from.has_subscription_expiration()) {
-      set_subscription_expiration(from.subscription_expiration());
-    }
-  }
-  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
-    if (from.has_units_remaining()) {
-      set_units_remaining(from.units_remaining());
-    }
-    if (from.has_status_expiration()) {
-      set_status_expiration(from.status_expiration());
-    }
-    if (from.has_box_level()) {
-      set_box_level(from.box_level());
-    }
-    if (from.has_box_level_expiration()) {
-      set_box_level_expiration(from.box_level_expiration());
-    }
-    if (from.has_raf_account()) {
-      set_raf_account(from.raf_account());
-    }
-    if (from.has_raf_info()) {
-      set_raf_info(from.raf_info());
-    }
-    if (from.has_raf_expiration()) {
-      set_raf_expiration(from.raf_expiration());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void GameAccountBlob::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void GameAccountBlob::CopyFrom(const GameAccountBlob& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool GameAccountBlob::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000049) != 0x00000049) return false;
-
-  if (has_game_account()) {
-    if (!this->game_account().IsInitialized()) return false;
-  }
-  if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false;
-  return true;
-}
-
-void GameAccountBlob::Swap(GameAccountBlob* other) {
-  if (other != this) {
-    std::swap(game_account_, other->game_account_);
-    std::swap(name_, other->name_);
-    std::swap(realm_permissions_, other->realm_permissions_);
-    std::swap(status_, other->status_);
-    std::swap(flags_, other->flags_);
-    std::swap(billing_flags_, other->billing_flags_);
-    std::swap(cache_expiration_, other->cache_expiration_);
-    std::swap(subscription_expiration_, other->subscription_expiration_);
-    std::swap(units_remaining_, other->units_remaining_);
-    std::swap(status_expiration_, other->status_expiration_);
-    std::swap(box_level_, other->box_level_);
-    std::swap(box_level_expiration_, other->box_level_expiration_);
-    licenses_.Swap(&other->licenses_);
-    std::swap(raf_account_, other->raf_account_);
-    std::swap(raf_info_, other->raf_info_);
-    std::swap(raf_expiration_, other->raf_expiration_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata GameAccountBlob::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GameAccountBlob_descriptor_;
-  metadata.reflection = GameAccountBlob_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int GameAccountBlobList::kBlobFieldNumber;
-#endif  // !_MSC_VER
-
-GameAccountBlobList::GameAccountBlobList()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountBlobList)
-}
-
-void GameAccountBlobList::InitAsDefaultInstance() {
-}
-
-GameAccountBlobList::GameAccountBlobList(const GameAccountBlobList& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountBlobList)
-}
-
-void GameAccountBlobList::SharedCtor() {
-  _cached_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-GameAccountBlobList::~GameAccountBlobList() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountBlobList)
-  SharedDtor();
-}
-
-void GameAccountBlobList::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void GameAccountBlobList::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* GameAccountBlobList::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return GameAccountBlobList_descriptor_;
-}
-
-const GameAccountBlobList& GameAccountBlobList::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-GameAccountBlobList* GameAccountBlobList::default_instance_ = NULL;
-
-GameAccountBlobList* GameAccountBlobList::New() const {
-  return new GameAccountBlobList;
-}
-
-void GameAccountBlobList::Clear() {
-  blob_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool GameAccountBlobList::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountBlobList)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-      case 1: {
-        if (tag == 10) {
-         parse_blob:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_blob()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(10)) goto parse_blob;
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountBlobList)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountBlobList)
-  return false;
-#undef DO_
-}
-
-void GameAccountBlobList::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountBlobList)
-  // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-  for (int i = 0; i < this->blob_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->blob(i), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountBlobList)
-}
-
-::google::protobuf::uint8* GameAccountBlobList::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountBlobList)
-  // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-  for (int i = 0; i < this->blob_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->blob(i), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountBlobList)
-  return target;
-}
-
-int GameAccountBlobList::ByteSize() const {
-  int total_size = 0;
-
-  // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-  total_size += 1 * this->blob_size();
-  for (int i = 0; i < this->blob_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->blob(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void GameAccountBlobList::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const GameAccountBlobList* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountBlobList*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void GameAccountBlobList::MergeFrom(const GameAccountBlobList& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  blob_.MergeFrom(from.blob_);
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void GameAccountBlobList::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void GameAccountBlobList::CopyFrom(const GameAccountBlobList& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool GameAccountBlobList::IsInitialized() const {
-
-  if (!::google::protobuf::internal::AllAreInitialized(this->blob())) return false;
-  return true;
-}
-
-void GameAccountBlobList::Swap(GameAccountBlobList* other) {
-  if (other != this) {
-    blob_.Swap(&other->blob_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata GameAccountBlobList::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GameAccountBlobList_descriptor_;
-  metadata.reflection = GameAccountBlobList_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int AccountReference::kIdFieldNumber;
 const int AccountReference::kEmailFieldNumber;
 const int AccountReference::kHandleFieldNumber;
@@ -6041,457 +2751,6 @@ void Identity::Swap(Identity* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int AccountInfo::kAccountPaidFieldNumber;
-const int AccountInfo::kCountryIdFieldNumber;
-const int AccountInfo::kBattleTagFieldNumber;
-const int AccountInfo::kManualReviewFieldNumber;
-const int AccountInfo::kIdentityFieldNumber;
-const int AccountInfo::kAccountMutedFieldNumber;
-#endif  // !_MSC_VER
-
-AccountInfo::AccountInfo()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountInfo)
-}
-
-void AccountInfo::InitAsDefaultInstance() {
-  identity_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
-}
-
-AccountInfo::AccountInfo(const AccountInfo& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountInfo)
-}
-
-void AccountInfo::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  account_paid_ = false;
-  country_id_ = 0u;
-  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  manual_review_ = false;
-  identity_ = NULL;
-  account_muted_ = false;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-AccountInfo::~AccountInfo() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountInfo)
-  SharedDtor();
-}
-
-void AccountInfo::SharedDtor() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (this != default_instance_) {
-    delete identity_;
-  }
-}
-
-void AccountInfo::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* AccountInfo::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return AccountInfo_descriptor_;
-}
-
-const AccountInfo& AccountInfo::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-AccountInfo* AccountInfo::default_instance_ = NULL;
-
-AccountInfo* AccountInfo::New() const {
-  return new AccountInfo;
-}
-
-void AccountInfo::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<AccountInfo*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 63) {
-    ZR_(country_id_, account_muted_);
-    if (has_battle_tag()) {
-      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        battle_tag_->clear();
-      }
-    }
-    if (has_identity()) {
-      if (identity_ != NULL) identity_->::bgs::protocol::account::v1::Identity::Clear();
-    }
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool AccountInfo::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountInfo)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional bool account_paid = 1 [default = false];
-      case 1: {
-        if (tag == 8) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &account_paid_)));
-          set_has_account_paid();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(21)) goto parse_country_id;
-        break;
-      }
-
-      // optional fixed32 country_id = 2 [default = 0];
-      case 2: {
-        if (tag == 21) {
-         parse_country_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &country_id_)));
-          set_has_country_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_battle_tag;
-        break;
-      }
-
-      // optional string battle_tag = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_battle_tag:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_battle_tag()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->battle_tag().data(), this->battle_tag().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "battle_tag");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(32)) goto parse_manual_review;
-        break;
-      }
-
-      // optional bool manual_review = 4 [default = false];
-      case 4: {
-        if (tag == 32) {
-         parse_manual_review:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &manual_review_)));
-          set_has_manual_review();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_identity;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.Identity identity = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_identity:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_identity()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(48)) goto parse_account_muted;
-        break;
-      }
-
-      // optional bool account_muted = 6 [default = false];
-      case 6: {
-        if (tag == 48) {
-         parse_account_muted:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &account_muted_)));
-          set_has_account_muted();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountInfo)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountInfo)
-  return false;
-#undef DO_
-}
-
-void AccountInfo::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountInfo)
-  // optional bool account_paid = 1 [default = false];
-  if (has_account_paid()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->account_paid(), output);
-  }
-
-  // optional fixed32 country_id = 2 [default = 0];
-  if (has_country_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->country_id(), output);
-  }
-
-  // optional string battle_tag = 3;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      3, this->battle_tag(), output);
-  }
-
-  // optional bool manual_review = 4 [default = false];
-  if (has_manual_review()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->manual_review(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity identity = 5;
-  if (has_identity()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, this->identity(), output);
-  }
-
-  // optional bool account_muted = 6 [default = false];
-  if (has_account_muted()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->account_muted(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountInfo)
-}
-
-::google::protobuf::uint8* AccountInfo::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountInfo)
-  // optional bool account_paid = 1 [default = false];
-  if (has_account_paid()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->account_paid(), target);
-  }
-
-  // optional fixed32 country_id = 2 [default = 0];
-  if (has_country_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->country_id(), target);
-  }
-
-  // optional string battle_tag = 3;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        3, this->battle_tag(), target);
-  }
-
-  // optional bool manual_review = 4 [default = false];
-  if (has_manual_review()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->manual_review(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity identity = 5;
-  if (has_identity()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->identity(), target);
-  }
-
-  // optional bool account_muted = 6 [default = false];
-  if (has_account_muted()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->account_muted(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountInfo)
-  return target;
-}
-
-int AccountInfo::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional bool account_paid = 1 [default = false];
-    if (has_account_paid()) {
-      total_size += 1 + 1;
-    }
-
-    // optional fixed32 country_id = 2 [default = 0];
-    if (has_country_id()) {
-      total_size += 1 + 4;
-    }
-
-    // optional string battle_tag = 3;
-    if (has_battle_tag()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->battle_tag());
-    }
-
-    // optional bool manual_review = 4 [default = false];
-    if (has_manual_review()) {
-      total_size += 1 + 1;
-    }
-
-    // optional .bgs.protocol.account.v1.Identity identity = 5;
-    if (has_identity()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->identity());
-    }
-
-    // optional bool account_muted = 6 [default = false];
-    if (has_account_muted()) {
-      total_size += 1 + 1;
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void AccountInfo::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const AccountInfo* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AccountInfo*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void AccountInfo::MergeFrom(const AccountInfo& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_account_paid()) {
-      set_account_paid(from.account_paid());
-    }
-    if (from.has_country_id()) {
-      set_country_id(from.country_id());
-    }
-    if (from.has_battle_tag()) {
-      set_battle_tag(from.battle_tag());
-    }
-    if (from.has_manual_review()) {
-      set_manual_review(from.manual_review());
-    }
-    if (from.has_identity()) {
-      mutable_identity()->::bgs::protocol::account::v1::Identity::MergeFrom(from.identity());
-    }
-    if (from.has_account_muted()) {
-      set_account_muted(from.account_muted());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void AccountInfo::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void AccountInfo::CopyFrom(const AccountInfo& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AccountInfo::IsInitialized() const {
-
-  if (has_identity()) {
-    if (!this->identity().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void AccountInfo::Swap(AccountInfo* other) {
-  if (other != this) {
-    std::swap(account_paid_, other->account_paid_);
-    std::swap(country_id_, other->country_id_);
-    std::swap(battle_tag_, other->battle_tag_);
-    std::swap(manual_review_, other->manual_review_);
-    std::swap(identity_, other->identity_);
-    std::swap(account_muted_, other->account_muted_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata AccountInfo::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AccountInfo_descriptor_;
-  metadata.reflection = AccountInfo_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int ProgramTag::kProgramFieldNumber;
 const int ProgramTag::kTagFieldNumber;
 #endif  // !_MSC_VER
@@ -9129,6 +5388,10 @@ const int AccountLevelInfo::kManualReviewFieldNumber;
 const int AccountLevelInfo::kAccountPaidAnyFieldNumber;
 const int AccountLevelInfo::kIdentityCheckStatusFieldNumber;
 const int AccountLevelInfo::kEmailFieldNumber;
+const int AccountLevelInfo::kHeadlessAccountFieldNumber;
+const int AccountLevelInfo::kTestAccountFieldNumber;
+const int AccountLevelInfo::kRestrictionFieldNumber;
+const int AccountLevelInfo::kIsSmsProtectedFieldNumber;
 #endif  // !_MSC_VER
 
 AccountLevelInfo::AccountLevelInfo()
@@ -9160,6 +5423,9 @@ void AccountLevelInfo::SharedCtor() {
   account_paid_any_ = false;
   identity_check_status_ = 0;
   email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  headless_account_ = false;
+  test_account_ = false;
+  is_sms_protected_ = false;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -9236,8 +5502,9 @@ void AccountLevelInfo::Clear() {
       }
     }
   }
-  if (_has_bits_[8 / 32] & 1792) {
+  if (_has_bits_[8 / 32] & 24320) {
     ZR_(account_paid_any_, identity_check_status_);
+    ZR_(test_account_, is_sms_protected_);
     if (has_email()) {
       if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
         email_->clear();
@@ -9249,6 +5516,7 @@ void AccountLevelInfo::Clear() {
 #undef ZR_
 
   licenses_.Clear();
+  restriction_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
@@ -9259,7 +5527,7 @@ bool AccountLevelInfo::MergePartialFromCodedStream(
   ::google::protobuf::uint32 tag;
   // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountLevelInfo)
   for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
@@ -9436,6 +5704,65 @@ bool AccountLevelInfo::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(112)) goto parse_headless_account;
+        break;
+      }
+
+      // optional bool headless_account = 14;
+      case 14: {
+        if (tag == 112) {
+         parse_headless_account:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &headless_account_)));
+          set_has_headless_account();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(120)) goto parse_test_account;
+        break;
+      }
+
+      // optional bool test_account = 15;
+      case 15: {
+        if (tag == 120) {
+         parse_test_account:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &test_account_)));
+          set_has_test_account();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(130)) goto parse_restriction;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.AccountRestriction restriction = 16;
+      case 16: {
+        if (tag == 130) {
+         parse_restriction:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_restriction()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(130)) goto parse_restriction;
+        if (input->ExpectTag(136)) goto parse_is_sms_protected;
+        break;
+      }
+
+      // optional bool is_sms_protected = 17;
+      case 17: {
+        if (tag == 136) {
+         parse_is_sms_protected:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_sms_protected_)));
+          set_has_is_sms_protected();
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -9542,6 +5869,27 @@ void AccountLevelInfo::SerializeWithCachedSizes(
       13, this->email(), output);
   }
 
+  // optional bool headless_account = 14;
+  if (has_headless_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->headless_account(), output);
+  }
+
+  // optional bool test_account = 15;
+  if (has_test_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->test_account(), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountRestriction restriction = 16;
+  for (int i = 0; i < this->restriction_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      16, this->restriction(i), output);
+  }
+
+  // optional bool is_sms_protected = 17;
+  if (has_is_sms_protected()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->is_sms_protected(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -9634,6 +5982,28 @@ void AccountLevelInfo::SerializeWithCachedSizes(
         13, this->email(), target);
   }
 
+  // optional bool headless_account = 14;
+  if (has_headless_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(14, this->headless_account(), target);
+  }
+
+  // optional bool test_account = 15;
+  if (has_test_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(15, this->test_account(), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountRestriction restriction = 16;
+  for (int i = 0; i < this->restriction_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        16, this->restriction(i), target);
+  }
+
+  // optional bool is_sms_protected = 17;
+  if (has_is_sms_protected()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->is_sms_protected(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -9709,6 +6079,21 @@ int AccountLevelInfo::ByteSize() const {
           this->email());
     }
 
+    // optional bool headless_account = 14;
+    if (has_headless_account()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool test_account = 15;
+    if (has_test_account()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_sms_protected = 17;
+    if (has_is_sms_protected()) {
+      total_size += 2 + 1;
+    }
+
   }
   // repeated .bgs.protocol.account.v1.AccountLicense licenses = 3;
   total_size += 1 * this->licenses_size();
@@ -9718,6 +6103,14 @@ int AccountLevelInfo::ByteSize() const {
         this->licenses(i));
   }
 
+  // repeated .bgs.protocol.account.v1.AccountRestriction restriction = 16;
+  total_size += 2 * this->restriction_size();
+  for (int i = 0; i < this->restriction_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->restriction(i));
+  }
+
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -9744,6 +6137,7 @@ void AccountLevelInfo::MergeFrom(const ::google::protobuf::Message& from) {
 void AccountLevelInfo::MergeFrom(const AccountLevelInfo& from) {
   GOOGLE_CHECK_NE(&from, this);
   licenses_.MergeFrom(from.licenses_);
+  restriction_.MergeFrom(from.restriction_);
   if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
     if (from.has_default_currency()) {
       set_default_currency(from.default_currency());
@@ -9777,6 +6171,15 @@ void AccountLevelInfo::MergeFrom(const AccountLevelInfo& from) {
     if (from.has_email()) {
       set_email(from.email());
     }
+    if (from.has_headless_account()) {
+      set_headless_account(from.headless_account());
+    }
+    if (from.has_test_account()) {
+      set_test_account(from.test_account());
+    }
+    if (from.has_is_sms_protected()) {
+      set_is_sms_protected(from.is_sms_protected());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -9812,6 +6215,10 @@ void AccountLevelInfo::Swap(AccountLevelInfo* other) {
     std::swap(account_paid_any_, other->account_paid_any_);
     std::swap(identity_check_status_, other->identity_check_status_);
     std::swap(email_, other->email_);
+    std::swap(headless_account_, other->headless_account_);
+    std::swap(test_account_, other->test_account_);
+    restriction_.Swap(&other->restriction_);
+    std::swap(is_sms_protected_, other->is_sms_protected_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -9854,9 +6261,10 @@ const int PrivacyInfo::GameInfoPrivacy_ARRAYSIZE;
 #endif  // _MSC_VER
 #ifndef _MSC_VER
 const int PrivacyInfo::kIsUsingRidFieldNumber;
-const int PrivacyInfo::kIsRealIdVisibleForViewFriendsFieldNumber;
+const int PrivacyInfo::kIsVisibleForViewFriendsFieldNumber;
 const int PrivacyInfo::kIsHiddenFromFriendFinderFieldNumber;
 const int PrivacyInfo::kGameInfoPrivacyFieldNumber;
+const int PrivacyInfo::kOnlyAllowFriendWhispersFieldNumber;
 #endif  // !_MSC_VER
 
 PrivacyInfo::PrivacyInfo()
@@ -9878,9 +6286,10 @@ PrivacyInfo::PrivacyInfo(const PrivacyInfo& from)
 void PrivacyInfo::SharedCtor() {
   _cached_size_ = 0;
   is_using_rid_ = false;
-  is_real_id_visible_for_view_friends_ = false;
+  is_visible_for_view_friends_ = false;
   is_hidden_from_friend_finder_ = false;
   game_info_privacy_ = 1;
+  only_allow_friend_whispers_ = false;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -9926,8 +6335,8 @@ void PrivacyInfo::Clear() {
     ::memset(&first, 0, n);                                \
   } while (0)
 
-  if (_has_bits_[0 / 32] & 15) {
-    ZR_(is_using_rid_, is_hidden_from_friend_finder_);
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(is_using_rid_, only_allow_friend_whispers_);
     game_info_privacy_ = 1;
   }
 
@@ -9958,18 +6367,18 @@ bool PrivacyInfo::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(32)) goto parse_is_real_id_visible_for_view_friends;
+        if (input->ExpectTag(32)) goto parse_is_visible_for_view_friends;
         break;
       }
 
-      // optional bool is_real_id_visible_for_view_friends = 4;
+      // optional bool is_visible_for_view_friends = 4;
       case 4: {
         if (tag == 32) {
-         parse_is_real_id_visible_for_view_friends:
+         parse_is_visible_for_view_friends:
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &is_real_id_visible_for_view_friends_)));
-          set_has_is_real_id_visible_for_view_friends();
+                 input, &is_visible_for_view_friends_)));
+          set_has_is_visible_for_view_friends();
         } else {
           goto handle_unusual;
         }
@@ -10008,6 +6417,21 @@ bool PrivacyInfo::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(56)) goto parse_only_allow_friend_whispers;
+        break;
+      }
+
+      // optional bool only_allow_friend_whispers = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_only_allow_friend_whispers:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &only_allow_friend_whispers_)));
+          set_has_only_allow_friend_whispers();
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -10042,9 +6466,9 @@ void PrivacyInfo::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_using_rid(), output);
   }
 
-  // optional bool is_real_id_visible_for_view_friends = 4;
-  if (has_is_real_id_visible_for_view_friends()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_real_id_visible_for_view_friends(), output);
+  // optional bool is_visible_for_view_friends = 4;
+  if (has_is_visible_for_view_friends()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_visible_for_view_friends(), output);
   }
 
   // optional bool is_hidden_from_friend_finder = 5;
@@ -10058,6 +6482,11 @@ void PrivacyInfo::SerializeWithCachedSizes(
       6, this->game_info_privacy(), output);
   }
 
+  // optional bool only_allow_friend_whispers = 7;
+  if (has_only_allow_friend_whispers()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->only_allow_friend_whispers(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -10073,9 +6502,9 @@ void PrivacyInfo::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_using_rid(), target);
   }
 
-  // optional bool is_real_id_visible_for_view_friends = 4;
-  if (has_is_real_id_visible_for_view_friends()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_real_id_visible_for_view_friends(), target);
+  // optional bool is_visible_for_view_friends = 4;
+  if (has_is_visible_for_view_friends()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_visible_for_view_friends(), target);
   }
 
   // optional bool is_hidden_from_friend_finder = 5;
@@ -10089,6 +6518,11 @@ void PrivacyInfo::SerializeWithCachedSizes(
       6, this->game_info_privacy(), target);
   }
 
+  // optional bool only_allow_friend_whispers = 7;
+  if (has_only_allow_friend_whispers()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->only_allow_friend_whispers(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -10106,8 +6540,8 @@ int PrivacyInfo::ByteSize() const {
       total_size += 1 + 1;
     }
 
-    // optional bool is_real_id_visible_for_view_friends = 4;
-    if (has_is_real_id_visible_for_view_friends()) {
+    // optional bool is_visible_for_view_friends = 4;
+    if (has_is_visible_for_view_friends()) {
       total_size += 1 + 1;
     }
 
@@ -10122,6 +6556,11 @@ int PrivacyInfo::ByteSize() const {
         ::google::protobuf::internal::WireFormatLite::EnumSize(this->game_info_privacy());
     }
 
+    // optional bool only_allow_friend_whispers = 7;
+    if (has_only_allow_friend_whispers()) {
+      total_size += 1 + 1;
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -10152,8 +6591,8 @@ void PrivacyInfo::MergeFrom(const PrivacyInfo& from) {
     if (from.has_is_using_rid()) {
       set_is_using_rid(from.is_using_rid());
     }
-    if (from.has_is_real_id_visible_for_view_friends()) {
-      set_is_real_id_visible_for_view_friends(from.is_real_id_visible_for_view_friends());
+    if (from.has_is_visible_for_view_friends()) {
+      set_is_visible_for_view_friends(from.is_visible_for_view_friends());
     }
     if (from.has_is_hidden_from_friend_finder()) {
       set_is_hidden_from_friend_finder(from.is_hidden_from_friend_finder());
@@ -10161,6 +6600,9 @@ void PrivacyInfo::MergeFrom(const PrivacyInfo& from) {
     if (from.has_game_info_privacy()) {
       set_game_info_privacy(from.game_info_privacy());
     }
+    if (from.has_only_allow_friend_whispers()) {
+      set_only_allow_friend_whispers(from.only_allow_friend_whispers());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -10185,9 +6627,10 @@ bool PrivacyInfo::IsInitialized() const {
 void PrivacyInfo::Swap(PrivacyInfo* other) {
   if (other != this) {
     std::swap(is_using_rid_, other->is_using_rid_);
-    std::swap(is_real_id_visible_for_view_friends_, other->is_real_id_visible_for_view_friends_);
+    std::swap(is_visible_for_view_friends_, other->is_visible_for_view_friends_);
     std::swap(is_hidden_from_friend_finder_, other->is_hidden_from_friend_finder_);
     std::swap(game_info_privacy_, other->game_info_privacy_);
+    std::swap(only_allow_friend_whispers_, other->only_allow_friend_whispers_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -10212,6 +6655,8 @@ const int ParentalControlInfo::kMinutesPerWeekFieldNumber;
 const int ParentalControlInfo::kCanReceiveVoiceFieldNumber;
 const int ParentalControlInfo::kCanSendVoiceFieldNumber;
 const int ParentalControlInfo::kPlayScheduleFieldNumber;
+const int ParentalControlInfo::kCanJoinGroupFieldNumber;
+const int ParentalControlInfo::kCanUseProfileFieldNumber;
 #endif  // !_MSC_VER
 
 ParentalControlInfo::ParentalControlInfo()
@@ -10238,6 +6683,8 @@ void ParentalControlInfo::SharedCtor() {
   minutes_per_week_ = 0u;
   can_receive_voice_ = false;
   can_send_voice_ = false;
+  can_join_group_ = false;
+  can_use_profile_ = false;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -10286,9 +6733,9 @@ void ParentalControlInfo::Clear() {
     ::memset(&first, 0, n);                                \
   } while (0)
 
-  if (_has_bits_[0 / 32] & 31) {
+  if (_has_bits_[0 / 32] & 223) {
     ZR_(minutes_per_day_, minutes_per_week_);
-    ZR_(can_receive_voice_, can_send_voice_);
+    ZR_(can_receive_voice_, can_use_profile_);
     if (has_timezone()) {
       if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
         timezone_->clear();
@@ -10405,6 +6852,36 @@ bool ParentalControlInfo::MergePartialFromCodedStream(
           goto handle_unusual;
         }
         if (input->ExpectTag(64)) goto parse_play_schedule;
+        if (input->ExpectTag(72)) goto parse_can_join_group;
+        break;
+      }
+
+      // optional bool can_join_group = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_can_join_group:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_join_group_)));
+          set_has_can_join_group();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_can_use_profile;
+        break;
+      }
+
+      // optional bool can_use_profile = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_can_use_profile:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_use_profile_)));
+          set_has_can_use_profile();
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -10470,6 +6947,16 @@ void ParentalControlInfo::SerializeWithCachedSizes(
       8, this->play_schedule(i), output);
   }
 
+  // optional bool can_join_group = 9;
+  if (has_can_join_group()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->can_join_group(), output);
+  }
+
+  // optional bool can_use_profile = 10;
+  if (has_can_use_profile()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->can_use_profile(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -10517,6 +7004,16 @@ void ParentalControlInfo::SerializeWithCachedSizes(
       WriteBoolToArray(8, this->play_schedule(i), target);
   }
 
+  // optional bool can_join_group = 9;
+  if (has_can_join_group()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->can_join_group(), target);
+  }
+
+  // optional bool can_use_profile = 10;
+  if (has_can_use_profile()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->can_use_profile(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -10560,6 +7057,16 @@ int ParentalControlInfo::ByteSize() const {
       total_size += 1 + 1;
     }
 
+    // optional bool can_join_group = 9;
+    if (has_can_join_group()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_use_profile = 10;
+    if (has_can_use_profile()) {
+      total_size += 1 + 1;
+    }
+
   }
   // repeated bool play_schedule = 8;
   {
@@ -10610,6 +7117,12 @@ void ParentalControlInfo::MergeFrom(const ParentalControlInfo& from) {
     if (from.has_can_send_voice()) {
       set_can_send_voice(from.can_send_voice());
     }
+    if (from.has_can_join_group()) {
+      set_can_join_group(from.can_join_group());
+    }
+    if (from.has_can_use_profile()) {
+      set_can_use_profile(from.can_use_profile());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -10639,6 +7152,8 @@ void ParentalControlInfo::Swap(ParentalControlInfo* other) {
     std::swap(can_receive_voice_, other->can_receive_voice_);
     std::swap(can_send_voice_, other->can_send_voice_);
     play_schedule_.Swap(&other->play_schedule_);
+    std::swap(can_join_group_, other->can_join_group_);
+    std::swap(can_use_profile_, other->can_use_profile_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -11656,7 +8171,7 @@ bool GameTimeRemainingInfo::MergePartialFromCodedStream(
         break;
       }
 
-      // optional uint32 seconds_remaining_until_kick = 4;
+      // optional uint32 seconds_remaining_until_kick = 4 [deprecated = true];
       case 4: {
         if (tag == 32) {
          parse_seconds_remaining_until_kick:
@@ -11711,7 +8226,7 @@ void GameTimeRemainingInfo::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->parental_weekly_minutes_remaining(), output);
   }
 
-  // optional uint32 seconds_remaining_until_kick = 4;
+  // optional uint32 seconds_remaining_until_kick = 4 [deprecated = true];
   if (has_seconds_remaining_until_kick()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->seconds_remaining_until_kick(), output);
   }
@@ -11741,7 +8256,7 @@ void GameTimeRemainingInfo::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->parental_weekly_minutes_remaining(), target);
   }
 
-  // optional uint32 seconds_remaining_until_kick = 4;
+  // optional uint32 seconds_remaining_until_kick = 4 [deprecated = true];
   if (has_seconds_remaining_until_kick()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->seconds_remaining_until_kick(), target);
   }
@@ -11779,7 +8294,7 @@ int GameTimeRemainingInfo::ByteSize() const {
           this->parental_weekly_minutes_remaining());
     }
 
-    // optional uint32 seconds_remaining_until_kick = 4;
+    // optional uint32 seconds_remaining_until_kick = 4 [deprecated = true];
     if (has_seconds_remaining_until_kick()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt32Size(
@@ -15781,400 +12296,123 @@ void AuthorizedData::Swap(AuthorizedData* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int BenefactorAddress::kRegionFieldNumber;
-const int BenefactorAddress::kIgrAddressFieldNumber;
+const int IgrId::kGameAccountFieldNumber;
+const int IgrId::kExternalIdFieldNumber;
 #endif  // !_MSC_VER
 
-BenefactorAddress::BenefactorAddress()
+IgrId::IgrId()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.BenefactorAddress)
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.IgrId)
 }
 
-void BenefactorAddress::InitAsDefaultInstance() {
+void IgrId::InitAsDefaultInstance() {
+  IgrId_default_oneof_instance_->game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
+  IgrId_default_oneof_instance_->external_id_ = 0u;
 }
 
-BenefactorAddress::BenefactorAddress(const BenefactorAddress& from)
+IgrId::IgrId(const IgrId& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.BenefactorAddress)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.IgrId)
 }
 
-void BenefactorAddress::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
+void IgrId::SharedCtor() {
   _cached_size_ = 0;
-  region_ = 0u;
-  igr_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  clear_has_type();
 }
 
-BenefactorAddress::~BenefactorAddress() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.BenefactorAddress)
+IgrId::~IgrId() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.IgrId)
   SharedDtor();
 }
 
-void BenefactorAddress::SharedDtor() {
-  if (igr_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete igr_address_;
+void IgrId::SharedDtor() {
+  if (has_type()) {
+    clear_type();
   }
   if (this != default_instance_) {
   }
 }
 
-void BenefactorAddress::SetCachedSize(int size) const {
+void IgrId::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* BenefactorAddress::descriptor() {
+const ::google::protobuf::Descriptor* IgrId::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return BenefactorAddress_descriptor_;
+  return IgrId_descriptor_;
 }
 
-const BenefactorAddress& BenefactorAddress::default_instance() {
+const IgrId& IgrId::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
   return *default_instance_;
 }
 
-BenefactorAddress* BenefactorAddress::default_instance_ = NULL;
-
-BenefactorAddress* BenefactorAddress::New() const {
-  return new BenefactorAddress;
-}
-
-void BenefactorAddress::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
-    region_ = 0u;
-    if (has_igr_address()) {
-      if (igr_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        igr_address_->clear();
-      }
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool BenefactorAddress::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.BenefactorAddress)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional uint32 region = 1;
-      case 1: {
-        if (tag == 8) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &region_)));
-          set_has_region();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_igr_address;
-        break;
-      }
-
-      // optional string igr_address = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_igr_address:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_igr_address()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->igr_address().data(), this->igr_address().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "igr_address");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.BenefactorAddress)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.BenefactorAddress)
-  return false;
-#undef DO_
-}
-
-void BenefactorAddress::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.BenefactorAddress)
-  // optional uint32 region = 1;
-  if (has_region()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->region(), output);
-  }
-
-  // optional string igr_address = 2;
-  if (has_igr_address()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->igr_address().data(), this->igr_address().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "igr_address");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->igr_address(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.BenefactorAddress)
-}
-
-::google::protobuf::uint8* BenefactorAddress::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.BenefactorAddress)
-  // optional uint32 region = 1;
-  if (has_region()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->region(), target);
-  }
-
-  // optional string igr_address = 2;
-  if (has_igr_address()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->igr_address().data(), this->igr_address().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "igr_address");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->igr_address(), target);
-  }
+IgrId* IgrId::default_instance_ = NULL;
 
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.BenefactorAddress)
-  return target;
+IgrId* IgrId::New() const {
+  return new IgrId;
 }
 
-int BenefactorAddress::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional uint32 region = 1;
-    if (has_region()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->region());
-    }
-
-    // optional string igr_address = 2;
-    if (has_igr_address()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->igr_address());
+void IgrId::clear_type() {
+  switch(type_case()) {
+    case kGameAccount: {
+      delete type_.game_account_;
+      break;
     }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void BenefactorAddress::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const BenefactorAddress* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const BenefactorAddress*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void BenefactorAddress::MergeFrom(const BenefactorAddress& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_region()) {
-      set_region(from.region());
+    case kExternalId: {
+      // No need to clear
+      break;
     }
-    if (from.has_igr_address()) {
-      set_igr_address(from.igr_address());
+    case TYPE_NOT_SET: {
+      break;
     }
   }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void BenefactorAddress::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void BenefactorAddress::CopyFrom(const BenefactorAddress& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool BenefactorAddress::IsInitialized() const {
-
-  return true;
-}
-
-void BenefactorAddress::Swap(BenefactorAddress* other) {
-  if (other != this) {
-    std::swap(region_, other->region_);
-    std::swap(igr_address_, other->igr_address_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata BenefactorAddress::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = BenefactorAddress_descriptor_;
-  metadata.reflection = BenefactorAddress_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int ExternalBenefactorLookup::kBenefactorIdFieldNumber;
-const int ExternalBenefactorLookup::kRegionFieldNumber;
-#endif  // !_MSC_VER
-
-ExternalBenefactorLookup::ExternalBenefactorLookup()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ExternalBenefactorLookup)
-}
-
-void ExternalBenefactorLookup::InitAsDefaultInstance() {
-}
-
-ExternalBenefactorLookup::ExternalBenefactorLookup(const ExternalBenefactorLookup& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ExternalBenefactorLookup)
-}
-
-void ExternalBenefactorLookup::SharedCtor() {
-  _cached_size_ = 0;
-  benefactor_id_ = 0u;
-  region_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ExternalBenefactorLookup::~ExternalBenefactorLookup() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ExternalBenefactorLookup)
-  SharedDtor();
-}
-
-void ExternalBenefactorLookup::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void ExternalBenefactorLookup::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ExternalBenefactorLookup::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ExternalBenefactorLookup_descriptor_;
-}
-
-const ExternalBenefactorLookup& ExternalBenefactorLookup::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
+  _oneof_case_[0] = TYPE_NOT_SET;
 }
 
-ExternalBenefactorLookup* ExternalBenefactorLookup::default_instance_ = NULL;
-
-ExternalBenefactorLookup* ExternalBenefactorLookup::New() const {
-  return new ExternalBenefactorLookup;
-}
-
-void ExternalBenefactorLookup::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<ExternalBenefactorLookup*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  ZR_(benefactor_id_, region_);
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
 
+void IgrId::Clear() {
+  clear_type();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool ExternalBenefactorLookup::MergePartialFromCodedStream(
+bool IgrId::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ExternalBenefactorLookup)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.IgrId)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional fixed32 benefactor_id = 1;
+      // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
       case 1: {
-        if (tag == 13) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &benefactor_id_)));
-          set_has_benefactor_id();
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(16)) goto parse_region;
+        if (input->ExpectTag(21)) goto parse_external_id;
         break;
       }
 
-      // optional uint32 region = 2;
+      // optional fixed32 external_id = 2;
       case 2: {
-        if (tag == 16) {
-         parse_region:
+        if (tag == 21) {
+         parse_external_id:
+          clear_type();
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &region_)));
-          set_has_region();
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &type_.external_id_)));
+          set_has_external_id();
         } else {
           goto handle_unusual;
         }
@@ -16196,71 +12434,77 @@ bool ExternalBenefactorLookup::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.ExternalBenefactorLookup)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.IgrId)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ExternalBenefactorLookup)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.IgrId)
   return false;
 #undef DO_
 }
 
-void ExternalBenefactorLookup::SerializeWithCachedSizes(
+void IgrId::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ExternalBenefactorLookup)
-  // optional fixed32 benefactor_id = 1;
-  if (has_benefactor_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->benefactor_id(), output);
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.IgrId)
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account(), output);
   }
 
-  // optional uint32 region = 2;
-  if (has_region()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output);
+  // optional fixed32 external_id = 2;
+  if (has_external_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->external_id(), output);
   }
 
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ExternalBenefactorLookup)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.IgrId)
 }
 
-::google::protobuf::uint8* ExternalBenefactorLookup::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* IgrId::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ExternalBenefactorLookup)
-  // optional fixed32 benefactor_id = 1;
-  if (has_benefactor_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->benefactor_id(), target);
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.IgrId)
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account(), target);
   }
 
-  // optional uint32 region = 2;
-  if (has_region()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target);
+  // optional fixed32 external_id = 2;
+  if (has_external_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->external_id(), target);
   }
 
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ExternalBenefactorLookup)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.IgrId)
   return target;
 }
 
-int ExternalBenefactorLookup::ByteSize() const {
+int IgrId::ByteSize() const {
   int total_size = 0;
 
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional fixed32 benefactor_id = 1;
-    if (has_benefactor_id()) {
+  switch (type_case()) {
+    // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+    case kGameAccount: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account());
+      break;
+    }
+    // optional fixed32 external_id = 2;
+    case kExternalId: {
       total_size += 1 + 4;
+      break;
     }
-
-    // optional uint32 region = 2;
-    if (has_region()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->region());
+    case TYPE_NOT_SET: {
+      break;
     }
-
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -16273,10 +12517,10 @@ int ExternalBenefactorLookup::ByteSize() const {
   return total_size;
 }
 
-void ExternalBenefactorLookup::MergeFrom(const ::google::protobuf::Message& from) {
+void IgrId::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const ExternalBenefactorLookup* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ExternalBenefactorLookup*>(
+  const IgrId* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const IgrId*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -16285,51 +12529,59 @@ void ExternalBenefactorLookup::MergeFrom(const ::google::protobuf::Message& from
   }
 }
 
-void ExternalBenefactorLookup::MergeFrom(const ExternalBenefactorLookup& from) {
+void IgrId::MergeFrom(const IgrId& from) {
   GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_benefactor_id()) {
-      set_benefactor_id(from.benefactor_id());
+  switch (from.type_case()) {
+    case kGameAccount: {
+      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
+      break;
     }
-    if (from.has_region()) {
-      set_region(from.region());
+    case kExternalId: {
+      set_external_id(from.external_id());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void ExternalBenefactorLookup::CopyFrom(const ::google::protobuf::Message& from) {
+void IgrId::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void ExternalBenefactorLookup::CopyFrom(const ExternalBenefactorLookup& from) {
+void IgrId::CopyFrom(const IgrId& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool ExternalBenefactorLookup::IsInitialized() const {
+bool IgrId::IsInitialized() const {
 
+  if (has_game_account()) {
+    if (!this->game_account().IsInitialized()) return false;
+  }
   return true;
 }
 
-void ExternalBenefactorLookup::Swap(ExternalBenefactorLookup* other) {
+void IgrId::Swap(IgrId* other) {
   if (other != this) {
-    std::swap(benefactor_id_, other->benefactor_id_);
-    std::swap(region_, other->region_);
+    std::swap(type_, other->type_);
+    std::swap(_oneof_case_[0], other->_oneof_case_[0]);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata ExternalBenefactorLookup::GetMetadata() const {
+::google::protobuf::Metadata IgrId::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ExternalBenefactorLookup_descriptor_;
-  metadata.reflection = ExternalBenefactorLookup_reflection_;
+  metadata.descriptor = IgrId_descriptor_;
+  metadata.reflection = IgrId_reflection_;
   return metadata;
 }
 
@@ -16337,163 +12589,115 @@ void ExternalBenefactorLookup::Swap(ExternalBenefactorLookup* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int AuthBenefactor::kIgrAddressFieldNumber;
-const int AuthBenefactor::kBenefactorIdFieldNumber;
-const int AuthBenefactor::kActiveFieldNumber;
-const int AuthBenefactor::kLastUpdateTimeFieldNumber;
+const int IgrAddress::kClientAddressFieldNumber;
+const int IgrAddress::kRegionFieldNumber;
 #endif  // !_MSC_VER
 
-AuthBenefactor::AuthBenefactor()
+IgrAddress::IgrAddress()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AuthBenefactor)
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.IgrAddress)
 }
 
-void AuthBenefactor::InitAsDefaultInstance() {
+void IgrAddress::InitAsDefaultInstance() {
 }
 
-AuthBenefactor::AuthBenefactor(const AuthBenefactor& from)
+IgrAddress::IgrAddress(const IgrAddress& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AuthBenefactor)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.IgrAddress)
 }
 
-void AuthBenefactor::SharedCtor() {
+void IgrAddress::SharedCtor() {
   ::google::protobuf::internal::GetEmptyString();
   _cached_size_ = 0;
-  igr_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  benefactor_id_ = 0u;
-  active_ = false;
-  last_update_time_ = GOOGLE_ULONGLONG(0);
+  client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  region_ = 0u;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-AuthBenefactor::~AuthBenefactor() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AuthBenefactor)
+IgrAddress::~IgrAddress() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.IgrAddress)
   SharedDtor();
 }
 
-void AuthBenefactor::SharedDtor() {
-  if (igr_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete igr_address_;
+void IgrAddress::SharedDtor() {
+  if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_address_;
   }
   if (this != default_instance_) {
   }
 }
 
-void AuthBenefactor::SetCachedSize(int size) const {
+void IgrAddress::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* AuthBenefactor::descriptor() {
+const ::google::protobuf::Descriptor* IgrAddress::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return AuthBenefactor_descriptor_;
+  return IgrAddress_descriptor_;
 }
 
-const AuthBenefactor& AuthBenefactor::default_instance() {
+const IgrAddress& IgrAddress::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
   return *default_instance_;
 }
 
-AuthBenefactor* AuthBenefactor::default_instance_ = NULL;
+IgrAddress* IgrAddress::default_instance_ = NULL;
 
-AuthBenefactor* AuthBenefactor::New() const {
-  return new AuthBenefactor;
+IgrAddress* IgrAddress::New() const {
+  return new IgrAddress;
 }
 
-void AuthBenefactor::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<AuthBenefactor*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 15) {
-    ZR_(benefactor_id_, last_update_time_);
-    if (has_igr_address()) {
-      if (igr_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        igr_address_->clear();
+void IgrAddress::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_client_address()) {
+      if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        client_address_->clear();
       }
     }
+    region_ = 0u;
   }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool AuthBenefactor::MergePartialFromCodedStream(
+bool IgrAddress::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AuthBenefactor)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.IgrAddress)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string igr_address = 1;
+      // optional string client_address = 1;
       case 1: {
         if (tag == 10) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_igr_address()));
+                input, this->mutable_client_address()));
           ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->igr_address().data(), this->igr_address().length(),
+            this->client_address().data(), this->client_address().length(),
             ::google::protobuf::internal::WireFormat::PARSE,
-            "igr_address");
+            "client_address");
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(21)) goto parse_benefactor_id;
+        if (input->ExpectTag(16)) goto parse_region;
         break;
       }
 
-      // optional fixed32 benefactor_id = 2;
+      // optional uint32 region = 2;
       case 2: {
-        if (tag == 21) {
-         parse_benefactor_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &benefactor_id_)));
-          set_has_benefactor_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_active;
-        break;
-      }
-
-      // optional bool active = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_active:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &active_)));
-          set_has_active();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(32)) goto parse_last_update_time;
-        break;
-      }
-
-      // optional uint64 last_update_time = 4;
-      case 4: {
-        if (tag == 32) {
-         parse_last_update_time:
+        if (tag == 16) {
+         parse_region:
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &last_update_time_)));
-          set_has_last_update_time();
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
         } else {
           goto handle_unusual;
         }
@@ -16515,112 +12719,82 @@ bool AuthBenefactor::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AuthBenefactor)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.IgrAddress)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AuthBenefactor)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.IgrAddress)
   return false;
 #undef DO_
 }
 
-void AuthBenefactor::SerializeWithCachedSizes(
+void IgrAddress::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AuthBenefactor)
-  // optional string igr_address = 1;
-  if (has_igr_address()) {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.IgrAddress)
+  // optional string client_address = 1;
+  if (has_client_address()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->igr_address().data(), this->igr_address().length(),
+      this->client_address().data(), this->client_address().length(),
       ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "igr_address");
+      "client_address");
     ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->igr_address(), output);
+      1, this->client_address(), output);
   }
 
-  // optional fixed32 benefactor_id = 2;
-  if (has_benefactor_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->benefactor_id(), output);
-  }
-
-  // optional bool active = 3;
-  if (has_active()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->active(), output);
-  }
-
-  // optional uint64 last_update_time = 4;
-  if (has_last_update_time()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->last_update_time(), output);
+  // optional uint32 region = 2;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output);
   }
 
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AuthBenefactor)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.IgrAddress)
 }
 
-::google::protobuf::uint8* AuthBenefactor::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* IgrAddress::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AuthBenefactor)
-  // optional string igr_address = 1;
-  if (has_igr_address()) {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.IgrAddress)
+  // optional string client_address = 1;
+  if (has_client_address()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->igr_address().data(), this->igr_address().length(),
+      this->client_address().data(), this->client_address().length(),
       ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "igr_address");
+      "client_address");
     target =
       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->igr_address(), target);
-  }
-
-  // optional fixed32 benefactor_id = 2;
-  if (has_benefactor_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->benefactor_id(), target);
-  }
-
-  // optional bool active = 3;
-  if (has_active()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->active(), target);
+        1, this->client_address(), target);
   }
 
-  // optional uint64 last_update_time = 4;
-  if (has_last_update_time()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->last_update_time(), target);
+  // optional uint32 region = 2;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target);
   }
 
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AuthBenefactor)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.IgrAddress)
   return target;
 }
 
-int AuthBenefactor::ByteSize() const {
+int IgrAddress::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional string igr_address = 1;
-    if (has_igr_address()) {
+    // optional string client_address = 1;
+    if (has_client_address()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->igr_address());
-    }
-
-    // optional fixed32 benefactor_id = 2;
-    if (has_benefactor_id()) {
-      total_size += 1 + 4;
-    }
-
-    // optional bool active = 3;
-    if (has_active()) {
-      total_size += 1 + 1;
+          this->client_address());
     }
 
-    // optional uint64 last_update_time = 4;
-    if (has_last_update_time()) {
+    // optional uint32 region = 2;
+    if (has_region()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->last_update_time());
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
     }
 
   }
@@ -16635,10 +12809,10 @@ int AuthBenefactor::ByteSize() const {
   return total_size;
 }
 
-void AuthBenefactor::MergeFrom(const ::google::protobuf::Message& from) {
+void IgrAddress::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const AuthBenefactor* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AuthBenefactor*>(
+  const IgrAddress* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const IgrAddress*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -16647,59 +12821,51 @@ void AuthBenefactor::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void AuthBenefactor::MergeFrom(const AuthBenefactor& from) {
+void IgrAddress::MergeFrom(const IgrAddress& from) {
   GOOGLE_CHECK_NE(&from, this);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_igr_address()) {
-      set_igr_address(from.igr_address());
-    }
-    if (from.has_benefactor_id()) {
-      set_benefactor_id(from.benefactor_id());
-    }
-    if (from.has_active()) {
-      set_active(from.active());
+    if (from.has_client_address()) {
+      set_client_address(from.client_address());
     }
-    if (from.has_last_update_time()) {
-      set_last_update_time(from.last_update_time());
+    if (from.has_region()) {
+      set_region(from.region());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void AuthBenefactor::CopyFrom(const ::google::protobuf::Message& from) {
+void IgrAddress::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void AuthBenefactor::CopyFrom(const AuthBenefactor& from) {
+void IgrAddress::CopyFrom(const IgrAddress& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool AuthBenefactor::IsInitialized() const {
+bool IgrAddress::IsInitialized() const {
 
   return true;
 }
 
-void AuthBenefactor::Swap(AuthBenefactor* other) {
+void IgrAddress::Swap(IgrAddress* other) {
   if (other != this) {
-    std::swap(igr_address_, other->igr_address_);
-    std::swap(benefactor_id_, other->benefactor_id_);
-    std::swap(active_, other->active_);
-    std::swap(last_update_time_, other->last_update_time_);
+    std::swap(client_address_, other->client_address_);
+    std::swap(region_, other->region_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata AuthBenefactor::GetMetadata() const {
+::google::protobuf::Metadata IgrAddress::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AuthBenefactor_descriptor_;
-  metadata.reflection = AuthBenefactor_reflection_;
+  metadata.descriptor = IgrAddress_descriptor_;
+  metadata.reflection = IgrAddress_reflection_;
   return metadata;
 }
 
@@ -16707,69 +12873,74 @@ void AuthBenefactor::Swap(AuthBenefactor* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int ApplicationInfo::kPlatformIdFieldNumber;
-const int ApplicationInfo::kLocaleFieldNumber;
-const int ApplicationInfo::kApplicationVersionFieldNumber;
+const int AccountRestriction::kRestrictionIdFieldNumber;
+const int AccountRestriction::kProgramFieldNumber;
+const int AccountRestriction::kTypeFieldNumber;
+const int AccountRestriction::kPlatformFieldNumber;
+const int AccountRestriction::kExpireTimeFieldNumber;
+const int AccountRestriction::kCreatedTimeFieldNumber;
 #endif  // !_MSC_VER
 
-ApplicationInfo::ApplicationInfo()
+AccountRestriction::AccountRestriction()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ApplicationInfo)
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountRestriction)
 }
 
-void ApplicationInfo::InitAsDefaultInstance() {
+void AccountRestriction::InitAsDefaultInstance() {
 }
 
-ApplicationInfo::ApplicationInfo(const ApplicationInfo& from)
+AccountRestriction::AccountRestriction(const AccountRestriction& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ApplicationInfo)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountRestriction)
 }
 
-void ApplicationInfo::SharedCtor() {
+void AccountRestriction::SharedCtor() {
   _cached_size_ = 0;
-  platform_id_ = 0u;
-  locale_ = 0u;
-  application_version_ = 0;
+  restriction_id_ = 0u;
+  program_ = 0u;
+  type_ = 0;
+  expire_time_ = GOOGLE_ULONGLONG(0);
+  created_time_ = GOOGLE_ULONGLONG(0);
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-ApplicationInfo::~ApplicationInfo() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ApplicationInfo)
+AccountRestriction::~AccountRestriction() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountRestriction)
   SharedDtor();
 }
 
-void ApplicationInfo::SharedDtor() {
+void AccountRestriction::SharedDtor() {
   if (this != default_instance_) {
   }
 }
 
-void ApplicationInfo::SetCachedSize(int size) const {
+void AccountRestriction::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* ApplicationInfo::descriptor() {
+const ::google::protobuf::Descriptor* AccountRestriction::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return ApplicationInfo_descriptor_;
+  return AccountRestriction_descriptor_;
 }
 
-const ApplicationInfo& ApplicationInfo::default_instance() {
+const AccountRestriction& AccountRestriction::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
   return *default_instance_;
 }
 
-ApplicationInfo* ApplicationInfo::default_instance_ = NULL;
+AccountRestriction* AccountRestriction::default_instance_ = NULL;
 
-ApplicationInfo* ApplicationInfo::New() const {
-  return new ApplicationInfo;
+AccountRestriction* AccountRestriction::New() const {
+  return new AccountRestriction;
 }
 
-void ApplicationInfo::Clear() {
+void AccountRestriction::Clear() {
 #define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<ApplicationInfo*>(16)->f) - \
+  &reinterpret_cast<AccountRestriction*>(16)->f) - \
    reinterpret_cast<char*>(16))
 
 #define ZR_(first, last) do {                              \
@@ -16778,488 +12949,120 @@ void ApplicationInfo::Clear() {
     ::memset(&first, 0, n);                                \
   } while (0)
 
-  ZR_(platform_id_, application_version_);
+  if (_has_bits_[0 / 32] & 55) {
+    ZR_(restriction_id_, program_);
+    ZR_(expire_time_, type_);
+  }
 
 #undef OFFSET_OF_FIELD_
 #undef ZR_
 
+  platform_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool ApplicationInfo::MergePartialFromCodedStream(
+bool AccountRestriction::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ApplicationInfo)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountRestriction)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional fixed32 platform_id = 1;
+      // optional uint32 restriction_id = 1;
       case 1: {
-        if (tag == 13) {
+        if (tag == 8) {
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &platform_id_)));
-          set_has_platform_id();
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &restriction_id_)));
+          set_has_restriction_id();
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(21)) goto parse_locale;
+        if (input->ExpectTag(21)) goto parse_program;
         break;
       }
 
-      // optional fixed32 locale = 2;
+      // optional fixed32 program = 2;
       case 2: {
         if (tag == 21) {
-         parse_locale:
+         parse_program:
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &locale_)));
-          set_has_locale();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_application_version;
-        break;
-      }
-
-      // optional int32 application_version = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_application_version:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, &application_version_)));
-          set_has_application_version();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.ApplicationInfo)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ApplicationInfo)
-  return false;
-#undef DO_
-}
-
-void ApplicationInfo::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ApplicationInfo)
-  // optional fixed32 platform_id = 1;
-  if (has_platform_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->platform_id(), output);
-  }
-
-  // optional fixed32 locale = 2;
-  if (has_locale()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->locale(), output);
-  }
-
-  // optional int32 application_version = 3;
-  if (has_application_version()) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->application_version(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ApplicationInfo)
-}
-
-::google::protobuf::uint8* ApplicationInfo::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ApplicationInfo)
-  // optional fixed32 platform_id = 1;
-  if (has_platform_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->platform_id(), target);
-  }
-
-  // optional fixed32 locale = 2;
-  if (has_locale()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->locale(), target);
-  }
-
-  // optional int32 application_version = 3;
-  if (has_application_version()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->application_version(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ApplicationInfo)
-  return target;
-}
-
-int ApplicationInfo::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional fixed32 platform_id = 1;
-    if (has_platform_id()) {
-      total_size += 1 + 4;
-    }
-
-    // optional fixed32 locale = 2;
-    if (has_locale()) {
-      total_size += 1 + 4;
-    }
-
-    // optional int32 application_version = 3;
-    if (has_application_version()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::Int32Size(
-          this->application_version());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ApplicationInfo::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ApplicationInfo* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ApplicationInfo*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ApplicationInfo::MergeFrom(const ApplicationInfo& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_platform_id()) {
-      set_platform_id(from.platform_id());
-    }
-    if (from.has_locale()) {
-      set_locale(from.locale());
-    }
-    if (from.has_application_version()) {
-      set_application_version(from.application_version());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ApplicationInfo::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ApplicationInfo::CopyFrom(const ApplicationInfo& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ApplicationInfo::IsInitialized() const {
-
-  return true;
-}
-
-void ApplicationInfo::Swap(ApplicationInfo* other) {
-  if (other != this) {
-    std::swap(platform_id_, other->platform_id_);
-    std::swap(locale_, other->locale_);
-    std::swap(application_version_, other->application_version_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ApplicationInfo::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ApplicationInfo_descriptor_;
-  metadata.reflection = ApplicationInfo_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int DeductRecord::kGameAccountFieldNumber;
-const int DeductRecord::kBenefactorFieldNumber;
-const int DeductRecord::kStartTimeFieldNumber;
-const int DeductRecord::kEndTimeFieldNumber;
-const int DeductRecord::kClientAddressFieldNumber;
-const int DeductRecord::kApplicationInfoFieldNumber;
-const int DeductRecord::kSessionOwnerFieldNumber;
-const int DeductRecord::kFreeSessionFieldNumber;
-#endif  // !_MSC_VER
-
-DeductRecord::DeductRecord()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.DeductRecord)
-}
-
-void DeductRecord::InitAsDefaultInstance() {
-  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
-  benefactor_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
-  application_info_ = const_cast< ::bgs::protocol::account::v1::ApplicationInfo*>(&::bgs::protocol::account::v1::ApplicationInfo::default_instance());
-}
-
-DeductRecord::DeductRecord(const DeductRecord& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.DeductRecord)
-}
-
-void DeductRecord::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  game_account_ = NULL;
-  benefactor_ = NULL;
-  start_time_ = GOOGLE_ULONGLONG(0);
-  end_time_ = GOOGLE_ULONGLONG(0);
-  client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  application_info_ = NULL;
-  session_owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  free_session_ = false;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-DeductRecord::~DeductRecord() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.DeductRecord)
-  SharedDtor();
-}
-
-void DeductRecord::SharedDtor() {
-  if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete client_address_;
-  }
-  if (session_owner_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete session_owner_;
-  }
-  if (this != default_instance_) {
-    delete game_account_;
-    delete benefactor_;
-    delete application_info_;
-  }
-}
-
-void DeductRecord::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* DeductRecord::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return DeductRecord_descriptor_;
-}
-
-const DeductRecord& DeductRecord::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-DeductRecord* DeductRecord::default_instance_ = NULL;
-
-DeductRecord* DeductRecord::New() const {
-  return new DeductRecord;
-}
-
-void DeductRecord::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<DeductRecord*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 255) {
-    ZR_(start_time_, end_time_);
-    if (has_game_account()) {
-      if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-    }
-    if (has_benefactor()) {
-      if (benefactor_ != NULL) benefactor_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-    }
-    if (has_client_address()) {
-      if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        client_address_->clear();
-      }
-    }
-    if (has_application_info()) {
-      if (application_info_ != NULL) application_info_->::bgs::protocol::account::v1::ApplicationInfo::Clear();
-    }
-    if (has_session_owner()) {
-      if (session_owner_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        session_owner_->clear();
-      }
-    }
-    free_session_ = false;
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool DeductRecord::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.DeductRecord)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_benefactor;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.GameAccountHandle benefactor = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_benefactor:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_benefactor()));
+                 input, &program_)));
+          set_has_program();
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(24)) goto parse_start_time;
+        if (input->ExpectTag(24)) goto parse_type;
         break;
       }
 
-      // optional uint64 start_time = 3;
+      // optional .bgs.protocol.account.v1.RestrictionType type = 3;
       case 3: {
         if (tag == 24) {
-         parse_start_time:
+         parse_type:
+          int value;
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &start_time_)));
-          set_has_start_time();
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::account::v1::RestrictionType_IsValid(value)) {
+            set_type(static_cast< ::bgs::protocol::account::v1::RestrictionType >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(3, value);
+          }
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(32)) goto parse_end_time;
+        if (input->ExpectTag(37)) goto parse_platform;
         break;
       }
 
-      // optional uint64 end_time = 4;
+      // repeated fixed32 platform = 4;
       case 4: {
-        if (tag == 32) {
-         parse_end_time:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &end_time_)));
-          set_has_end_time();
+        if (tag == 37) {
+         parse_platform:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 1, 37, input, this->mutable_platform())));
+        } else if (tag == 34) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, this->mutable_platform())));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(42)) goto parse_client_address;
+        if (input->ExpectTag(37)) goto parse_platform;
+        if (input->ExpectTag(40)) goto parse_expire_time;
         break;
       }
 
-      // optional string client_address = 5;
+      // optional uint64 expire_time = 5;
       case 5: {
-        if (tag == 42) {
-         parse_client_address:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_client_address()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->client_address().data(), this->client_address().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "client_address");
+        if (tag == 40) {
+         parse_expire_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &expire_time_)));
+          set_has_expire_time();
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(50)) goto parse_application_info;
+        if (input->ExpectTag(48)) goto parse_created_time;
         break;
       }
 
-      // optional .bgs.protocol.account.v1.ApplicationInfo application_info = 6;
+      // optional uint64 created_time = 6;
       case 6: {
-        if (tag == 50) {
-         parse_application_info:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_application_info()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(58)) goto parse_session_owner;
-        break;
-      }
-
-      // optional string session_owner = 7;
-      case 7: {
-        if (tag == 58) {
-         parse_session_owner:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_session_owner()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->session_owner().data(), this->session_owner().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "session_owner");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(64)) goto parse_free_session;
-        break;
-      }
-
-      // optional bool free_session = 8;
-      case 8: {
-        if (tag == 64) {
-         parse_free_session:
+        if (tag == 48) {
+         parse_created_time:
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &free_session_)));
-          set_has_free_session();
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &created_time_)));
+          set_has_created_time();
         } else {
           goto handle_unusual;
         }
@@ -17281,205 +13084,143 @@ bool DeductRecord::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.DeductRecord)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountRestriction)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.DeductRecord)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountRestriction)
   return false;
 #undef DO_
 }
 
-void DeductRecord::SerializeWithCachedSizes(
+void AccountRestriction::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.DeductRecord)
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->game_account(), output);
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountRestriction)
+  // optional uint32 restriction_id = 1;
+  if (has_restriction_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->restriction_id(), output);
   }
 
-  // optional .bgs.protocol.account.v1.GameAccountHandle benefactor = 2;
-  if (has_benefactor()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->benefactor(), output);
-  }
-
-  // optional uint64 start_time = 3;
-  if (has_start_time()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->start_time(), output);
-  }
-
-  // optional uint64 end_time = 4;
-  if (has_end_time()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->end_time(), output);
+  // optional fixed32 program = 2;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->program(), output);
   }
 
-  // optional string client_address = 5;
-  if (has_client_address()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->client_address().data(), this->client_address().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "client_address");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      5, this->client_address(), output);
+  // optional .bgs.protocol.account.v1.RestrictionType type = 3;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->type(), output);
   }
 
-  // optional .bgs.protocol.account.v1.ApplicationInfo application_info = 6;
-  if (has_application_info()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      6, this->application_info(), output);
+  // repeated fixed32 platform = 4;
+  for (int i = 0; i < this->platform_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(
+      4, this->platform(i), output);
   }
 
-  // optional string session_owner = 7;
-  if (has_session_owner()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->session_owner().data(), this->session_owner().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "session_owner");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      7, this->session_owner(), output);
+  // optional uint64 expire_time = 5;
+  if (has_expire_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->expire_time(), output);
   }
 
-  // optional bool free_session = 8;
-  if (has_free_session()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->free_session(), output);
+  // optional uint64 created_time = 6;
+  if (has_created_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->created_time(), output);
   }
 
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.DeductRecord)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountRestriction)
 }
 
-::google::protobuf::uint8* DeductRecord::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* AccountRestriction::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.DeductRecord)
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->game_account(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.GameAccountHandle benefactor = 2;
-  if (has_benefactor()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->benefactor(), target);
-  }
-
-  // optional uint64 start_time = 3;
-  if (has_start_time()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->start_time(), target);
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountRestriction)
+  // optional uint32 restriction_id = 1;
+  if (has_restriction_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->restriction_id(), target);
   }
 
-  // optional uint64 end_time = 4;
-  if (has_end_time()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->end_time(), target);
+  // optional fixed32 program = 2;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->program(), target);
   }
 
-  // optional string client_address = 5;
-  if (has_client_address()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->client_address().data(), this->client_address().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "client_address");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        5, this->client_address(), target);
+  // optional .bgs.protocol.account.v1.RestrictionType type = 3;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      3, this->type(), target);
   }
 
-  // optional .bgs.protocol.account.v1.ApplicationInfo application_info = 6;
-  if (has_application_info()) {
+  // repeated fixed32 platform = 4;
+  for (int i = 0; i < this->platform_size(); i++) {
     target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        6, this->application_info(), target);
+      WriteFixed32ToArray(4, this->platform(i), target);
   }
 
-  // optional string session_owner = 7;
-  if (has_session_owner()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->session_owner().data(), this->session_owner().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "session_owner");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        7, this->session_owner(), target);
+  // optional uint64 expire_time = 5;
+  if (has_expire_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->expire_time(), target);
   }
 
-  // optional bool free_session = 8;
-  if (has_free_session()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->free_session(), target);
+  // optional uint64 created_time = 6;
+  if (has_created_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->created_time(), target);
   }
 
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.DeductRecord)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountRestriction)
   return target;
 }
 
-int DeductRecord::ByteSize() const {
+int AccountRestriction::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-    if (has_game_account()) {
+    // optional uint32 restriction_id = 1;
+    if (has_restriction_id()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account());
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->restriction_id());
     }
 
-    // optional .bgs.protocol.account.v1.GameAccountHandle benefactor = 2;
-    if (has_benefactor()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->benefactor());
+    // optional fixed32 program = 2;
+    if (has_program()) {
+      total_size += 1 + 4;
     }
 
-    // optional uint64 start_time = 3;
-    if (has_start_time()) {
+    // optional .bgs.protocol.account.v1.RestrictionType type = 3;
+    if (has_type()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->start_time());
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
     }
 
-    // optional uint64 end_time = 4;
-    if (has_end_time()) {
+    // optional uint64 expire_time = 5;
+    if (has_expire_time()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->end_time());
+          this->expire_time());
     }
 
-    // optional string client_address = 5;
-    if (has_client_address()) {
+    // optional uint64 created_time = 6;
+    if (has_created_time()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->client_address());
-    }
-
-    // optional .bgs.protocol.account.v1.ApplicationInfo application_info = 6;
-    if (has_application_info()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->application_info());
-    }
-
-    // optional string session_owner = 7;
-    if (has_session_owner()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->session_owner());
-    }
-
-    // optional bool free_session = 8;
-    if (has_free_session()) {
-      total_size += 1 + 1;
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->created_time());
     }
 
   }
+  // repeated fixed32 platform = 4;
+  {
+    int data_size = 0;
+    data_size = 4 * this->platform_size();
+    total_size += 1 * this->platform_size() + data_size;
+  }
+
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -17491,10 +13232,10 @@ int DeductRecord::ByteSize() const {
   return total_size;
 }
 
-void DeductRecord::MergeFrom(const ::google::protobuf::Message& from) {
+void AccountRestriction::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const DeductRecord* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const DeductRecord*>(
+  const AccountRestriction* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountRestriction*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -17503,374 +13244,65 @@ void DeductRecord::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void DeductRecord::MergeFrom(const DeductRecord& from) {
+void AccountRestriction::MergeFrom(const AccountRestriction& from) {
   GOOGLE_CHECK_NE(&from, this);
+  platform_.MergeFrom(from.platform_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_game_account()) {
-      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
-    }
-    if (from.has_benefactor()) {
-      mutable_benefactor()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.benefactor());
-    }
-    if (from.has_start_time()) {
-      set_start_time(from.start_time());
-    }
-    if (from.has_end_time()) {
-      set_end_time(from.end_time());
-    }
-    if (from.has_client_address()) {
-      set_client_address(from.client_address());
-    }
-    if (from.has_application_info()) {
-      mutable_application_info()->::bgs::protocol::account::v1::ApplicationInfo::MergeFrom(from.application_info());
-    }
-    if (from.has_session_owner()) {
-      set_session_owner(from.session_owner());
-    }
-    if (from.has_free_session()) {
-      set_free_session(from.free_session());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void DeductRecord::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void DeductRecord::CopyFrom(const DeductRecord& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool DeductRecord::IsInitialized() const {
-
-  if (has_game_account()) {
-    if (!this->game_account().IsInitialized()) return false;
-  }
-  if (has_benefactor()) {
-    if (!this->benefactor().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void DeductRecord::Swap(DeductRecord* other) {
-  if (other != this) {
-    std::swap(game_account_, other->game_account_);
-    std::swap(benefactor_, other->benefactor_);
-    std::swap(start_time_, other->start_time_);
-    std::swap(end_time_, other->end_time_);
-    std::swap(client_address_, other->client_address_);
-    std::swap(application_info_, other->application_info_);
-    std::swap(session_owner_, other->session_owner_);
-    std::swap(free_session_, other->free_session_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata DeductRecord::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = DeductRecord_descriptor_;
-  metadata.reflection = DeductRecord_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int IgrId::kGameAccountFieldNumber;
-const int IgrId::kExternalIdFieldNumber;
-#endif  // !_MSC_VER
-
-IgrId::IgrId()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.IgrId)
-}
-
-void IgrId::InitAsDefaultInstance() {
-  IgrId_default_oneof_instance_->game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
-  IgrId_default_oneof_instance_->external_id_ = 0u;
-}
-
-IgrId::IgrId(const IgrId& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.IgrId)
-}
-
-void IgrId::SharedCtor() {
-  _cached_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  clear_has_type();
-}
-
-IgrId::~IgrId() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.IgrId)
-  SharedDtor();
-}
-
-void IgrId::SharedDtor() {
-  if (has_type()) {
-    clear_type();
-  }
-  if (this != default_instance_) {
-  }
-}
-
-void IgrId::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* IgrId::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return IgrId_descriptor_;
-}
-
-const IgrId& IgrId::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-IgrId* IgrId::default_instance_ = NULL;
-
-IgrId* IgrId::New() const {
-  return new IgrId;
-}
-
-void IgrId::clear_type() {
-  switch(type_case()) {
-    case kGameAccount: {
-      delete type_.game_account_;
-      break;
-    }
-    case kExternalId: {
-      // No need to clear
-      break;
-    }
-    case TYPE_NOT_SET: {
-      break;
-    }
-  }
-  _oneof_case_[0] = TYPE_NOT_SET;
-}
-
-
-void IgrId::Clear() {
-  clear_type();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool IgrId::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.IgrId)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(21)) goto parse_external_id;
-        break;
-      }
-
-      // optional fixed32 external_id = 2;
-      case 2: {
-        if (tag == 21) {
-         parse_external_id:
-          clear_type();
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &type_.external_id_)));
-          set_has_external_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
+    if (from.has_restriction_id()) {
+      set_restriction_id(from.restriction_id());
     }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.IgrId)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.IgrId)
-  return false;
-#undef DO_
-}
-
-void IgrId::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.IgrId)
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->game_account(), output);
-  }
-
-  // optional fixed32 external_id = 2;
-  if (has_external_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->external_id(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.IgrId)
-}
-
-::google::protobuf::uint8* IgrId::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.IgrId)
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  if (has_game_account()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->game_account(), target);
-  }
-
-  // optional fixed32 external_id = 2;
-  if (has_external_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->external_id(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.IgrId)
-  return target;
-}
-
-int IgrId::ByteSize() const {
-  int total_size = 0;
-
-  switch (type_case()) {
-    // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-    case kGameAccount: {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account());
-      break;
-    }
-    // optional fixed32 external_id = 2;
-    case kExternalId: {
-      total_size += 1 + 4;
-      break;
-    }
-    case TYPE_NOT_SET: {
-      break;
+    if (from.has_program()) {
+      set_program(from.program());
     }
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void IgrId::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const IgrId* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const IgrId*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void IgrId::MergeFrom(const IgrId& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  switch (from.type_case()) {
-    case kGameAccount: {
-      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
-      break;
+    if (from.has_type()) {
+      set_type(from.type());
     }
-    case kExternalId: {
-      set_external_id(from.external_id());
-      break;
+    if (from.has_expire_time()) {
+      set_expire_time(from.expire_time());
     }
-    case TYPE_NOT_SET: {
-      break;
+    if (from.has_created_time()) {
+      set_created_time(from.created_time());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void IgrId::CopyFrom(const ::google::protobuf::Message& from) {
+void AccountRestriction::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void IgrId::CopyFrom(const IgrId& from) {
+void AccountRestriction::CopyFrom(const AccountRestriction& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool IgrId::IsInitialized() const {
+bool AccountRestriction::IsInitialized() const {
 
-  if (has_game_account()) {
-    if (!this->game_account().IsInitialized()) return false;
-  }
   return true;
 }
 
-void IgrId::Swap(IgrId* other) {
+void AccountRestriction::Swap(AccountRestriction* other) {
   if (other != this) {
+    std::swap(restriction_id_, other->restriction_id_);
+    std::swap(program_, other->program_);
     std::swap(type_, other->type_);
-    std::swap(_oneof_case_[0], other->_oneof_case_[0]);
+    platform_.Swap(&other->platform_);
+    std::swap(expire_time_, other->expire_time_);
+    std::swap(created_time_, other->created_time_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata IgrId::GetMetadata() const {
+::google::protobuf::Metadata AccountRestriction::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = IgrId_descriptor_;
-  metadata.reflection = IgrId_reflection_;
+  metadata.descriptor = AccountRestriction_descriptor_;
+  metadata.reflection = AccountRestriction_reflection_;
   return metadata;
 }
 
diff --git a/src/server/proto/Client/account_types.pb.h b/src/server/proto/Client/account_types.pb.h
index 86bdbbff15a..28f71f9dce4 100644
--- a/src/server/proto/Client/account_types.pb.h
+++ b/src/server/proto/Client/account_types.pb.h
@@ -42,16 +42,9 @@ void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 class AccountId;
 class AccountLicense;
-class AccountCredential;
-class AccountBlob;
-class AccountBlobList;
 class GameAccountHandle;
-class GameAccountLink;
-class GameAccountBlob;
-class GameAccountBlobList;
 class AccountReference;
 class Identity;
-class AccountInfo;
 class ProgramTag;
 class RegionTag;
 class AccountFieldTags;
@@ -77,12 +70,9 @@ class AccountStateTagged;
 class GameAccountState;
 class GameAccountStateTagged;
 class AuthorizedData;
-class BenefactorAddress;
-class ExternalBenefactorLookup;
-class AuthBenefactor;
-class ApplicationInfo;
-class DeductRecord;
 class IgrId;
+class IgrAddress;
+class AccountRestriction;
 
 enum PrivacyInfo_GameInfoPrivacy {
   PrivacyInfo_GameInfoPrivacy_PRIVACY_ME = 0,
@@ -107,6 +97,8 @@ inline bool PrivacyInfo_GameInfoPrivacy_Parse(
 enum IdentityVerificationStatus {
   IDENT_NO_DATA = 0,
   IDENT_PENDING = 1,
+  IDENT_OVER_18 = 2,
+  IDENT_UNDER_18 = 3,
   IDENT_FAILED = 4,
   IDENT_SUCCESS = 5,
   IDENT_SUCC_MNL = 6,
@@ -127,6 +119,29 @@ inline bool IdentityVerificationStatus_Parse(
   return ::google::protobuf::internal::ParseNamedEnum<IdentityVerificationStatus>(
     IdentityVerificationStatus_descriptor(), name, value);
 }
+enum RestrictionType {
+  UNKNOWN = 0,
+  GAME_ACCOUNT_BANNED = 1,
+  GAME_ACCOUNT_SUSPENDED = 2,
+  ACCOUNT_LOCKED = 3,
+  ACCOUNT_SQUELCHED = 4,
+  CLUB_MEMBERSHIP_LOCKED = 5
+};
+TC_PROTO_API bool RestrictionType_IsValid(int value);
+const RestrictionType RestrictionType_MIN = UNKNOWN;
+const RestrictionType RestrictionType_MAX = CLUB_MEMBERSHIP_LOCKED;
+const int RestrictionType_ARRAYSIZE = RestrictionType_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* RestrictionType_descriptor();
+inline const ::std::string& RestrictionType_Name(RestrictionType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    RestrictionType_descriptor(), value);
+}
+inline bool RestrictionType_Parse(
+    const ::std::string& name, RestrictionType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<RestrictionType>(
+    RestrictionType_descriptor(), name, value);
+}
 // ===================================================================
 
 class TC_PROTO_API AccountId : public ::google::protobuf::Message {
@@ -297,499 +312,6 @@ class TC_PROTO_API AccountLicense : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API AccountCredential : public ::google::protobuf::Message {
- public:
-  AccountCredential();
-  virtual ~AccountCredential();
-
-  AccountCredential(const AccountCredential& from);
-
-  inline AccountCredential& operator=(const AccountCredential& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const AccountCredential& default_instance();
-
-  void Swap(AccountCredential* other);
-
-  // implements Message ----------------------------------------------
-
-  AccountCredential* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AccountCredential& from);
-  void MergeFrom(const AccountCredential& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // required uint32 id = 1;
-  inline bool has_id() const;
-  inline void clear_id();
-  static const int kIdFieldNumber = 1;
-  inline ::google::protobuf::uint32 id() const;
-  inline void set_id(::google::protobuf::uint32 value);
-
-  // optional bytes data = 2;
-  inline bool has_data() const;
-  inline void clear_data();
-  static const int kDataFieldNumber = 2;
-  inline const ::std::string& data() const;
-  inline void set_data(const ::std::string& value);
-  inline void set_data(const char* value);
-  inline void set_data(const void* value, size_t size);
-  inline ::std::string* mutable_data();
-  inline ::std::string* release_data();
-  inline void set_allocated_data(::std::string* data);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountCredential)
- private:
-  inline void set_has_id();
-  inline void clear_has_id();
-  inline void set_has_data();
-  inline void clear_has_data();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::std::string* data_;
-  ::google::protobuf::uint32 id_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static AccountCredential* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API AccountBlob : public ::google::protobuf::Message {
- public:
-  AccountBlob();
-  virtual ~AccountBlob();
-
-  AccountBlob(const AccountBlob& from);
-
-  inline AccountBlob& operator=(const AccountBlob& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const AccountBlob& default_instance();
-
-  void Swap(AccountBlob* other);
-
-  // implements Message ----------------------------------------------
-
-  AccountBlob* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AccountBlob& from);
-  void MergeFrom(const AccountBlob& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // required fixed32 id = 2;
-  inline bool has_id() const;
-  inline void clear_id();
-  static const int kIdFieldNumber = 2;
-  inline ::google::protobuf::uint32 id() const;
-  inline void set_id(::google::protobuf::uint32 value);
-
-  // required uint32 region = 3;
-  inline bool has_region() const;
-  inline void clear_region();
-  static const int kRegionFieldNumber = 3;
-  inline ::google::protobuf::uint32 region() const;
-  inline void set_region(::google::protobuf::uint32 value);
-
-  // repeated string email = 4;
-  inline int email_size() const;
-  inline void clear_email();
-  static const int kEmailFieldNumber = 4;
-  inline const ::std::string& email(int index) const;
-  inline ::std::string* mutable_email(int index);
-  inline void set_email(int index, const ::std::string& value);
-  inline void set_email(int index, const char* value);
-  inline void set_email(int index, const char* value, size_t size);
-  inline ::std::string* add_email();
-  inline void add_email(const ::std::string& value);
-  inline void add_email(const char* value);
-  inline void add_email(const char* value, size_t size);
-  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& email() const;
-  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_email();
-
-  // required uint64 flags = 5;
-  inline bool has_flags() const;
-  inline void clear_flags();
-  static const int kFlagsFieldNumber = 5;
-  inline ::google::protobuf::uint64 flags() const;
-  inline void set_flags(::google::protobuf::uint64 value);
-
-  // optional uint64 secure_release = 6;
-  inline bool has_secure_release() const;
-  inline void clear_secure_release();
-  static const int kSecureReleaseFieldNumber = 6;
-  inline ::google::protobuf::uint64 secure_release() const;
-  inline void set_secure_release(::google::protobuf::uint64 value);
-
-  // optional uint64 whitelist_start = 7;
-  inline bool has_whitelist_start() const;
-  inline void clear_whitelist_start();
-  static const int kWhitelistStartFieldNumber = 7;
-  inline ::google::protobuf::uint64 whitelist_start() const;
-  inline void set_whitelist_start(::google::protobuf::uint64 value);
-
-  // optional uint64 whitelist_end = 8;
-  inline bool has_whitelist_end() const;
-  inline void clear_whitelist_end();
-  static const int kWhitelistEndFieldNumber = 8;
-  inline ::google::protobuf::uint64 whitelist_end() const;
-  inline void set_whitelist_end(::google::protobuf::uint64 value);
-
-  // required string full_name = 10;
-  inline bool has_full_name() const;
-  inline void clear_full_name();
-  static const int kFullNameFieldNumber = 10;
-  inline const ::std::string& full_name() const;
-  inline void set_full_name(const ::std::string& value);
-  inline void set_full_name(const char* value);
-  inline void set_full_name(const char* value, size_t size);
-  inline ::std::string* mutable_full_name();
-  inline ::std::string* release_full_name();
-  inline void set_allocated_full_name(::std::string* full_name);
-
-  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-  inline int licenses_size() const;
-  inline void clear_licenses();
-  static const int kLicensesFieldNumber = 20;
-  inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const;
-  inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index);
-  inline ::bgs::protocol::account::v1::AccountLicense* add_licenses();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
-      licenses() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
-      mutable_licenses();
-
-  // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
-  inline int credentials_size() const;
-  inline void clear_credentials();
-  static const int kCredentialsFieldNumber = 21;
-  inline const ::bgs::protocol::account::v1::AccountCredential& credentials(int index) const;
-  inline ::bgs::protocol::account::v1::AccountCredential* mutable_credentials(int index);
-  inline ::bgs::protocol::account::v1::AccountCredential* add_credentials();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
-      credentials() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
-      mutable_credentials();
-
-  // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
-  inline int account_links_size() const;
-  inline void clear_account_links();
-  static const int kAccountLinksFieldNumber = 22;
-  inline const ::bgs::protocol::account::v1::GameAccountLink& account_links(int index) const;
-  inline ::bgs::protocol::account::v1::GameAccountLink* mutable_account_links(int index);
-  inline ::bgs::protocol::account::v1::GameAccountLink* add_account_links();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >&
-      account_links() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >*
-      mutable_account_links();
-
-  // optional string battle_tag = 23;
-  inline bool has_battle_tag() const;
-  inline void clear_battle_tag();
-  static const int kBattleTagFieldNumber = 23;
-  inline const ::std::string& battle_tag() const;
-  inline void set_battle_tag(const ::std::string& value);
-  inline void set_battle_tag(const char* value);
-  inline void set_battle_tag(const char* value, size_t size);
-  inline ::std::string* mutable_battle_tag();
-  inline ::std::string* release_battle_tag();
-  inline void set_allocated_battle_tag(::std::string* battle_tag);
-
-  // optional fixed32 default_currency = 25;
-  inline bool has_default_currency() const;
-  inline void clear_default_currency();
-  static const int kDefaultCurrencyFieldNumber = 25;
-  inline ::google::protobuf::uint32 default_currency() const;
-  inline void set_default_currency(::google::protobuf::uint32 value);
-
-  // optional uint32 legal_region = 26;
-  inline bool has_legal_region() const;
-  inline void clear_legal_region();
-  static const int kLegalRegionFieldNumber = 26;
-  inline ::google::protobuf::uint32 legal_region() const;
-  inline void set_legal_region(::google::protobuf::uint32 value);
-
-  // optional fixed32 legal_locale = 27;
-  inline bool has_legal_locale() const;
-  inline void clear_legal_locale();
-  static const int kLegalLocaleFieldNumber = 27;
-  inline ::google::protobuf::uint32 legal_locale() const;
-  inline void set_legal_locale(::google::protobuf::uint32 value);
-
-  // required uint64 cache_expiration = 30;
-  inline bool has_cache_expiration() const;
-  inline void clear_cache_expiration();
-  static const int kCacheExpirationFieldNumber = 30;
-  inline ::google::protobuf::uint64 cache_expiration() const;
-  inline void set_cache_expiration(::google::protobuf::uint64 value);
-
-  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
-  inline bool has_parental_control_info() const;
-  inline void clear_parental_control_info();
-  static const int kParentalControlInfoFieldNumber = 31;
-  inline const ::bgs::protocol::account::v1::ParentalControlInfo& parental_control_info() const;
-  inline ::bgs::protocol::account::v1::ParentalControlInfo* mutable_parental_control_info();
-  inline ::bgs::protocol::account::v1::ParentalControlInfo* release_parental_control_info();
-  inline void set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info);
-
-  // optional string country = 32;
-  inline bool has_country() const;
-  inline void clear_country();
-  static const int kCountryFieldNumber = 32;
-  inline const ::std::string& country() const;
-  inline void set_country(const ::std::string& value);
-  inline void set_country(const char* value);
-  inline void set_country(const char* value, size_t size);
-  inline ::std::string* mutable_country();
-  inline ::std::string* release_country();
-  inline void set_allocated_country(::std::string* country);
-
-  // optional uint32 preferred_region = 33;
-  inline bool has_preferred_region() const;
-  inline void clear_preferred_region();
-  static const int kPreferredRegionFieldNumber = 33;
-  inline ::google::protobuf::uint32 preferred_region() const;
-  inline void set_preferred_region(::google::protobuf::uint32 value);
-
-  // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
-  inline bool has_identity_check_status() const;
-  inline void clear_identity_check_status();
-  static const int kIdentityCheckStatusFieldNumber = 34;
-  inline ::bgs::protocol::account::v1::IdentityVerificationStatus identity_check_status() const;
-  inline void set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value);
-
-  // optional string cais_id = 35;
-  inline bool has_cais_id() const;
-  inline void clear_cais_id();
-  static const int kCaisIdFieldNumber = 35;
-  inline const ::std::string& cais_id() const;
-  inline void set_cais_id(const ::std::string& value);
-  inline void set_cais_id(const char* value);
-  inline void set_cais_id(const char* value, size_t size);
-  inline ::std::string* mutable_cais_id();
-  inline ::std::string* release_cais_id();
-  inline void set_allocated_cais_id(::std::string* cais_id);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountBlob)
- private:
-  inline void set_has_id();
-  inline void clear_has_id();
-  inline void set_has_region();
-  inline void clear_has_region();
-  inline void set_has_flags();
-  inline void clear_has_flags();
-  inline void set_has_secure_release();
-  inline void clear_has_secure_release();
-  inline void set_has_whitelist_start();
-  inline void clear_has_whitelist_start();
-  inline void set_has_whitelist_end();
-  inline void clear_has_whitelist_end();
-  inline void set_has_full_name();
-  inline void clear_has_full_name();
-  inline void set_has_battle_tag();
-  inline void clear_has_battle_tag();
-  inline void set_has_default_currency();
-  inline void clear_has_default_currency();
-  inline void set_has_legal_region();
-  inline void clear_has_legal_region();
-  inline void set_has_legal_locale();
-  inline void clear_has_legal_locale();
-  inline void set_has_cache_expiration();
-  inline void clear_has_cache_expiration();
-  inline void set_has_parental_control_info();
-  inline void clear_has_parental_control_info();
-  inline void set_has_country();
-  inline void clear_has_country();
-  inline void set_has_preferred_region();
-  inline void clear_has_preferred_region();
-  inline void set_has_identity_check_status();
-  inline void clear_has_identity_check_status();
-  inline void set_has_cais_id();
-  inline void clear_has_cais_id();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 id_;
-  ::google::protobuf::uint32 region_;
-  ::google::protobuf::RepeatedPtrField< ::std::string> email_;
-  ::google::protobuf::uint64 flags_;
-  ::google::protobuf::uint64 secure_release_;
-  ::google::protobuf::uint64 whitelist_start_;
-  ::google::protobuf::uint64 whitelist_end_;
-  ::std::string* full_name_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential > credentials_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink > account_links_;
-  ::std::string* battle_tag_;
-  ::google::protobuf::uint32 default_currency_;
-  ::google::protobuf::uint32 legal_region_;
-  ::google::protobuf::uint64 cache_expiration_;
-  ::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info_;
-  ::google::protobuf::uint32 legal_locale_;
-  ::google::protobuf::uint32 preferred_region_;
-  ::std::string* country_;
-  ::std::string* cais_id_;
-  int identity_check_status_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static AccountBlob* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API AccountBlobList : public ::google::protobuf::Message {
- public:
-  AccountBlobList();
-  virtual ~AccountBlobList();
-
-  AccountBlobList(const AccountBlobList& from);
-
-  inline AccountBlobList& operator=(const AccountBlobList& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const AccountBlobList& default_instance();
-
-  void Swap(AccountBlobList* other);
-
-  // implements Message ----------------------------------------------
-
-  AccountBlobList* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AccountBlobList& from);
-  void MergeFrom(const AccountBlobList& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
-  inline int blob_size() const;
-  inline void clear_blob();
-  static const int kBlobFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::AccountBlob& blob(int index) const;
-  inline ::bgs::protocol::account::v1::AccountBlob* mutable_blob(int index);
-  inline ::bgs::protocol::account::v1::AccountBlob* add_blob();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >&
-      blob() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >*
-      mutable_blob();
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountBlobList)
- private:
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob > blob_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static AccountBlobList* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API GameAccountHandle : public ::google::protobuf::Message {
  public:
   GameAccountHandle();
@@ -889,428 +411,6 @@ class TC_PROTO_API GameAccountHandle : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API GameAccountLink : public ::google::protobuf::Message {
- public:
-  GameAccountLink();
-  virtual ~GameAccountLink();
-
-  GameAccountLink(const GameAccountLink& from);
-
-  inline GameAccountLink& operator=(const GameAccountLink& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const GameAccountLink& default_instance();
-
-  void Swap(GameAccountLink* other);
-
-  // implements Message ----------------------------------------------
-
-  GameAccountLink* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GameAccountLink& from);
-  void MergeFrom(const GameAccountLink& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  inline bool has_game_account() const;
-  inline void clear_game_account();
-  static const int kGameAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
-  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
-  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
-  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
-
-  // required string name = 2;
-  inline bool has_name() const;
-  inline void clear_name();
-  static const int kNameFieldNumber = 2;
-  inline const ::std::string& name() const;
-  inline void set_name(const ::std::string& value);
-  inline void set_name(const char* value);
-  inline void set_name(const char* value, size_t size);
-  inline ::std::string* mutable_name();
-  inline ::std::string* release_name();
-  inline void set_allocated_name(::std::string* name);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountLink)
- private:
-  inline void set_has_game_account();
-  inline void clear_has_game_account();
-  inline void set_has_name();
-  inline void clear_has_name();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
-  ::std::string* name_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static GameAccountLink* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API GameAccountBlob : public ::google::protobuf::Message {
- public:
-  GameAccountBlob();
-  virtual ~GameAccountBlob();
-
-  GameAccountBlob(const GameAccountBlob& from);
-
-  inline GameAccountBlob& operator=(const GameAccountBlob& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const GameAccountBlob& default_instance();
-
-  void Swap(GameAccountBlob* other);
-
-  // implements Message ----------------------------------------------
-
-  GameAccountBlob* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GameAccountBlob& from);
-  void MergeFrom(const GameAccountBlob& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  inline bool has_game_account() const;
-  inline void clear_game_account();
-  static const int kGameAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
-  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
-  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
-  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
-
-  // optional string name = 2 [default = ""];
-  inline bool has_name() const;
-  inline void clear_name();
-  static const int kNameFieldNumber = 2;
-  inline const ::std::string& name() const;
-  inline void set_name(const ::std::string& value);
-  inline void set_name(const char* value);
-  inline void set_name(const char* value, size_t size);
-  inline ::std::string* mutable_name();
-  inline ::std::string* release_name();
-  inline void set_allocated_name(::std::string* name);
-
-  // optional uint32 realm_permissions = 3 [default = 0];
-  inline bool has_realm_permissions() const;
-  inline void clear_realm_permissions();
-  static const int kRealmPermissionsFieldNumber = 3;
-  inline ::google::protobuf::uint32 realm_permissions() const;
-  inline void set_realm_permissions(::google::protobuf::uint32 value);
-
-  // required uint32 status = 4;
-  inline bool has_status() const;
-  inline void clear_status();
-  static const int kStatusFieldNumber = 4;
-  inline ::google::protobuf::uint32 status() const;
-  inline void set_status(::google::protobuf::uint32 value);
-
-  // optional uint64 flags = 5 [default = 0];
-  inline bool has_flags() const;
-  inline void clear_flags();
-  static const int kFlagsFieldNumber = 5;
-  inline ::google::protobuf::uint64 flags() const;
-  inline void set_flags(::google::protobuf::uint64 value);
-
-  // optional uint32 billing_flags = 6 [default = 0];
-  inline bool has_billing_flags() const;
-  inline void clear_billing_flags();
-  static const int kBillingFlagsFieldNumber = 6;
-  inline ::google::protobuf::uint32 billing_flags() const;
-  inline void set_billing_flags(::google::protobuf::uint32 value);
-
-  // required uint64 cache_expiration = 7;
-  inline bool has_cache_expiration() const;
-  inline void clear_cache_expiration();
-  static const int kCacheExpirationFieldNumber = 7;
-  inline ::google::protobuf::uint64 cache_expiration() const;
-  inline void set_cache_expiration(::google::protobuf::uint64 value);
-
-  // optional uint64 subscription_expiration = 10;
-  inline bool has_subscription_expiration() const;
-  inline void clear_subscription_expiration();
-  static const int kSubscriptionExpirationFieldNumber = 10;
-  inline ::google::protobuf::uint64 subscription_expiration() const;
-  inline void set_subscription_expiration(::google::protobuf::uint64 value);
-
-  // optional uint32 units_remaining = 11;
-  inline bool has_units_remaining() const;
-  inline void clear_units_remaining();
-  static const int kUnitsRemainingFieldNumber = 11;
-  inline ::google::protobuf::uint32 units_remaining() const;
-  inline void set_units_remaining(::google::protobuf::uint32 value);
-
-  // optional uint64 status_expiration = 12;
-  inline bool has_status_expiration() const;
-  inline void clear_status_expiration();
-  static const int kStatusExpirationFieldNumber = 12;
-  inline ::google::protobuf::uint64 status_expiration() const;
-  inline void set_status_expiration(::google::protobuf::uint64 value);
-
-  // optional uint32 box_level = 13;
-  inline bool has_box_level() const;
-  inline void clear_box_level();
-  static const int kBoxLevelFieldNumber = 13;
-  inline ::google::protobuf::uint32 box_level() const;
-  inline void set_box_level(::google::protobuf::uint32 value);
-
-  // optional uint64 box_level_expiration = 14;
-  inline bool has_box_level_expiration() const;
-  inline void clear_box_level_expiration();
-  static const int kBoxLevelExpirationFieldNumber = 14;
-  inline ::google::protobuf::uint64 box_level_expiration() const;
-  inline void set_box_level_expiration(::google::protobuf::uint64 value);
-
-  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-  inline int licenses_size() const;
-  inline void clear_licenses();
-  static const int kLicensesFieldNumber = 20;
-  inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const;
-  inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index);
-  inline ::bgs::protocol::account::v1::AccountLicense* add_licenses();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
-      licenses() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
-      mutable_licenses();
-
-  // optional fixed32 raf_account = 21;
-  inline bool has_raf_account() const;
-  inline void clear_raf_account();
-  static const int kRafAccountFieldNumber = 21;
-  inline ::google::protobuf::uint32 raf_account() const;
-  inline void set_raf_account(::google::protobuf::uint32 value);
-
-  // optional bytes raf_info = 22;
-  inline bool has_raf_info() const;
-  inline void clear_raf_info();
-  static const int kRafInfoFieldNumber = 22;
-  inline const ::std::string& raf_info() const;
-  inline void set_raf_info(const ::std::string& value);
-  inline void set_raf_info(const char* value);
-  inline void set_raf_info(const void* value, size_t size);
-  inline ::std::string* mutable_raf_info();
-  inline ::std::string* release_raf_info();
-  inline void set_allocated_raf_info(::std::string* raf_info);
-
-  // optional uint64 raf_expiration = 23;
-  inline bool has_raf_expiration() const;
-  inline void clear_raf_expiration();
-  static const int kRafExpirationFieldNumber = 23;
-  inline ::google::protobuf::uint64 raf_expiration() const;
-  inline void set_raf_expiration(::google::protobuf::uint64 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountBlob)
- private:
-  inline void set_has_game_account();
-  inline void clear_has_game_account();
-  inline void set_has_name();
-  inline void clear_has_name();
-  inline void set_has_realm_permissions();
-  inline void clear_has_realm_permissions();
-  inline void set_has_status();
-  inline void clear_has_status();
-  inline void set_has_flags();
-  inline void clear_has_flags();
-  inline void set_has_billing_flags();
-  inline void clear_has_billing_flags();
-  inline void set_has_cache_expiration();
-  inline void clear_has_cache_expiration();
-  inline void set_has_subscription_expiration();
-  inline void clear_has_subscription_expiration();
-  inline void set_has_units_remaining();
-  inline void clear_has_units_remaining();
-  inline void set_has_status_expiration();
-  inline void clear_has_status_expiration();
-  inline void set_has_box_level();
-  inline void clear_has_box_level();
-  inline void set_has_box_level_expiration();
-  inline void clear_has_box_level_expiration();
-  inline void set_has_raf_account();
-  inline void clear_has_raf_account();
-  inline void set_has_raf_info();
-  inline void clear_has_raf_info();
-  inline void set_has_raf_expiration();
-  inline void clear_has_raf_expiration();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
-  ::std::string* name_;
-  ::google::protobuf::uint32 realm_permissions_;
-  ::google::protobuf::uint32 status_;
-  ::google::protobuf::uint64 flags_;
-  ::google::protobuf::uint64 cache_expiration_;
-  ::google::protobuf::uint32 billing_flags_;
-  ::google::protobuf::uint32 units_remaining_;
-  ::google::protobuf::uint64 subscription_expiration_;
-  ::google::protobuf::uint64 status_expiration_;
-  ::google::protobuf::uint64 box_level_expiration_;
-  ::google::protobuf::uint32 box_level_;
-  ::google::protobuf::uint32 raf_account_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_;
-  ::std::string* raf_info_;
-  ::google::protobuf::uint64 raf_expiration_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static GameAccountBlob* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API GameAccountBlobList : public ::google::protobuf::Message {
- public:
-  GameAccountBlobList();
-  virtual ~GameAccountBlobList();
-
-  GameAccountBlobList(const GameAccountBlobList& from);
-
-  inline GameAccountBlobList& operator=(const GameAccountBlobList& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const GameAccountBlobList& default_instance();
-
-  void Swap(GameAccountBlobList* other);
-
-  // implements Message ----------------------------------------------
-
-  GameAccountBlobList* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GameAccountBlobList& from);
-  void MergeFrom(const GameAccountBlobList& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-  inline int blob_size() const;
-  inline void clear_blob();
-  static const int kBlobFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::GameAccountBlob& blob(int index) const;
-  inline ::bgs::protocol::account::v1::GameAccountBlob* mutable_blob(int index);
-  inline ::bgs::protocol::account::v1::GameAccountBlob* add_blob();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >&
-      blob() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >*
-      mutable_blob();
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountBlobList)
- private:
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob > blob_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static GameAccountBlobList* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API AccountReference : public ::google::protobuf::Message {
  public:
   AccountReference();
@@ -1547,142 +647,6 @@ class TC_PROTO_API Identity : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API AccountInfo : public ::google::protobuf::Message {
- public:
-  AccountInfo();
-  virtual ~AccountInfo();
-
-  AccountInfo(const AccountInfo& from);
-
-  inline AccountInfo& operator=(const AccountInfo& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const AccountInfo& default_instance();
-
-  void Swap(AccountInfo* other);
-
-  // implements Message ----------------------------------------------
-
-  AccountInfo* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AccountInfo& from);
-  void MergeFrom(const AccountInfo& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional bool account_paid = 1 [default = false];
-  inline bool has_account_paid() const;
-  inline void clear_account_paid();
-  static const int kAccountPaidFieldNumber = 1;
-  inline bool account_paid() const;
-  inline void set_account_paid(bool value);
-
-  // optional fixed32 country_id = 2 [default = 0];
-  inline bool has_country_id() const;
-  inline void clear_country_id();
-  static const int kCountryIdFieldNumber = 2;
-  inline ::google::protobuf::uint32 country_id() const;
-  inline void set_country_id(::google::protobuf::uint32 value);
-
-  // optional string battle_tag = 3;
-  inline bool has_battle_tag() const;
-  inline void clear_battle_tag();
-  static const int kBattleTagFieldNumber = 3;
-  inline const ::std::string& battle_tag() const;
-  inline void set_battle_tag(const ::std::string& value);
-  inline void set_battle_tag(const char* value);
-  inline void set_battle_tag(const char* value, size_t size);
-  inline ::std::string* mutable_battle_tag();
-  inline ::std::string* release_battle_tag();
-  inline void set_allocated_battle_tag(::std::string* battle_tag);
-
-  // optional bool manual_review = 4 [default = false];
-  inline bool has_manual_review() const;
-  inline void clear_manual_review();
-  static const int kManualReviewFieldNumber = 4;
-  inline bool manual_review() const;
-  inline void set_manual_review(bool value);
-
-  // optional .bgs.protocol.account.v1.Identity identity = 5;
-  inline bool has_identity() const;
-  inline void clear_identity();
-  static const int kIdentityFieldNumber = 5;
-  inline const ::bgs::protocol::account::v1::Identity& identity() const;
-  inline ::bgs::protocol::account::v1::Identity* mutable_identity();
-  inline ::bgs::protocol::account::v1::Identity* release_identity();
-  inline void set_allocated_identity(::bgs::protocol::account::v1::Identity* identity);
-
-  // optional bool account_muted = 6 [default = false];
-  inline bool has_account_muted() const;
-  inline void clear_account_muted();
-  static const int kAccountMutedFieldNumber = 6;
-  inline bool account_muted() const;
-  inline void set_account_muted(bool value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountInfo)
- private:
-  inline void set_has_account_paid();
-  inline void clear_has_account_paid();
-  inline void set_has_country_id();
-  inline void clear_has_country_id();
-  inline void set_has_battle_tag();
-  inline void clear_has_battle_tag();
-  inline void set_has_manual_review();
-  inline void clear_has_manual_review();
-  inline void set_has_identity();
-  inline void clear_has_identity();
-  inline void set_has_account_muted();
-  inline void clear_has_account_muted();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::std::string* battle_tag_;
-  ::google::protobuf::uint32 country_id_;
-  bool account_paid_;
-  bool manual_review_;
-  bool account_muted_;
-  ::bgs::protocol::account::v1::Identity* identity_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static AccountInfo* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API ProgramTag : public ::google::protobuf::Message {
  public:
   ProgramTag();
@@ -2670,6 +1634,39 @@ class TC_PROTO_API AccountLevelInfo : public ::google::protobuf::Message {
   inline ::std::string* release_email();
   inline void set_allocated_email(::std::string* email);
 
+  // optional bool headless_account = 14;
+  inline bool has_headless_account() const;
+  inline void clear_headless_account();
+  static const int kHeadlessAccountFieldNumber = 14;
+  inline bool headless_account() const;
+  inline void set_headless_account(bool value);
+
+  // optional bool test_account = 15;
+  inline bool has_test_account() const;
+  inline void clear_test_account();
+  static const int kTestAccountFieldNumber = 15;
+  inline bool test_account() const;
+  inline void set_test_account(bool value);
+
+  // repeated .bgs.protocol.account.v1.AccountRestriction restriction = 16;
+  inline int restriction_size() const;
+  inline void clear_restriction();
+  static const int kRestrictionFieldNumber = 16;
+  inline const ::bgs::protocol::account::v1::AccountRestriction& restriction(int index) const;
+  inline ::bgs::protocol::account::v1::AccountRestriction* mutable_restriction(int index);
+  inline ::bgs::protocol::account::v1::AccountRestriction* add_restriction();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountRestriction >&
+      restriction() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountRestriction >*
+      mutable_restriction();
+
+  // optional bool is_sms_protected = 17;
+  inline bool has_is_sms_protected() const;
+  inline void clear_is_sms_protected();
+  static const int kIsSmsProtectedFieldNumber = 17;
+  inline bool is_sms_protected() const;
+  inline void set_is_sms_protected(bool value);
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountLevelInfo)
  private:
   inline void set_has_default_currency();
@@ -2692,6 +1689,12 @@ class TC_PROTO_API AccountLevelInfo : public ::google::protobuf::Message {
   inline void clear_has_identity_check_status();
   inline void set_has_email();
   inline void clear_has_email();
+  inline void set_has_headless_account();
+  inline void clear_has_headless_account();
+  inline void set_has_test_account();
+  inline void clear_has_test_account();
+  inline void set_has_is_sms_protected();
+  inline void clear_has_is_sms_protected();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -2706,8 +1709,12 @@ class TC_PROTO_API AccountLevelInfo : public ::google::protobuf::Message {
   bool muted_;
   bool manual_review_;
   bool account_paid_any_;
+  bool headless_account_;
   int identity_check_status_;
   ::std::string* email_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountRestriction > restriction_;
+  bool test_account_;
+  bool is_sms_protected_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
   friend void protobuf_AssignDesc_account_5ftypes_2eproto();
   friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
@@ -2802,12 +1809,12 @@ class TC_PROTO_API PrivacyInfo : public ::google::protobuf::Message {
   inline bool is_using_rid() const;
   inline void set_is_using_rid(bool value);
 
-  // optional bool is_real_id_visible_for_view_friends = 4;
-  inline bool has_is_real_id_visible_for_view_friends() const;
-  inline void clear_is_real_id_visible_for_view_friends();
-  static const int kIsRealIdVisibleForViewFriendsFieldNumber = 4;
-  inline bool is_real_id_visible_for_view_friends() const;
-  inline void set_is_real_id_visible_for_view_friends(bool value);
+  // optional bool is_visible_for_view_friends = 4;
+  inline bool has_is_visible_for_view_friends() const;
+  inline void clear_is_visible_for_view_friends();
+  static const int kIsVisibleForViewFriendsFieldNumber = 4;
+  inline bool is_visible_for_view_friends() const;
+  inline void set_is_visible_for_view_friends(bool value);
 
   // optional bool is_hidden_from_friend_finder = 5;
   inline bool has_is_hidden_from_friend_finder() const;
@@ -2823,24 +1830,34 @@ class TC_PROTO_API PrivacyInfo : public ::google::protobuf::Message {
   inline ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy game_info_privacy() const;
   inline void set_game_info_privacy(::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy value);
 
+  // optional bool only_allow_friend_whispers = 7;
+  inline bool has_only_allow_friend_whispers() const;
+  inline void clear_only_allow_friend_whispers();
+  static const int kOnlyAllowFriendWhispersFieldNumber = 7;
+  inline bool only_allow_friend_whispers() const;
+  inline void set_only_allow_friend_whispers(bool value);
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.PrivacyInfo)
  private:
   inline void set_has_is_using_rid();
   inline void clear_has_is_using_rid();
-  inline void set_has_is_real_id_visible_for_view_friends();
-  inline void clear_has_is_real_id_visible_for_view_friends();
+  inline void set_has_is_visible_for_view_friends();
+  inline void clear_has_is_visible_for_view_friends();
   inline void set_has_is_hidden_from_friend_finder();
   inline void clear_has_is_hidden_from_friend_finder();
   inline void set_has_game_info_privacy();
   inline void clear_has_game_info_privacy();
+  inline void set_has_only_allow_friend_whispers();
+  inline void clear_has_only_allow_friend_whispers();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
   bool is_using_rid_;
-  bool is_real_id_visible_for_view_friends_;
+  bool is_visible_for_view_friends_;
   bool is_hidden_from_friend_finder_;
+  bool only_allow_friend_whispers_;
   int game_info_privacy_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
   friend void protobuf_AssignDesc_account_5ftypes_2eproto();
@@ -2956,6 +1973,20 @@ class TC_PROTO_API ParentalControlInfo : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedField< bool >*
       mutable_play_schedule();
 
+  // optional bool can_join_group = 9;
+  inline bool has_can_join_group() const;
+  inline void clear_can_join_group();
+  static const int kCanJoinGroupFieldNumber = 9;
+  inline bool can_join_group() const;
+  inline void set_can_join_group(bool value);
+
+  // optional bool can_use_profile = 10;
+  inline bool has_can_use_profile() const;
+  inline void clear_can_use_profile();
+  static const int kCanUseProfileFieldNumber = 10;
+  inline bool can_use_profile() const;
+  inline void set_can_use_profile(bool value);
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ParentalControlInfo)
  private:
   inline void set_has_timezone();
@@ -2968,6 +1999,10 @@ class TC_PROTO_API ParentalControlInfo : public ::google::protobuf::Message {
   inline void clear_has_can_receive_voice();
   inline void set_has_can_send_voice();
   inline void clear_has_can_send_voice();
+  inline void set_has_can_join_group();
+  inline void clear_has_can_join_group();
+  inline void set_has_can_use_profile();
+  inline void clear_has_can_use_profile();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -2979,6 +2014,8 @@ class TC_PROTO_API ParentalControlInfo : public ::google::protobuf::Message {
   ::google::protobuf::RepeatedField< bool > play_schedule_;
   bool can_receive_voice_;
   bool can_send_voice_;
+  bool can_join_group_;
+  bool can_use_profile_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
   friend void protobuf_AssignDesc_account_5ftypes_2eproto();
   friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
@@ -3328,12 +2365,12 @@ class TC_PROTO_API GameTimeRemainingInfo : public ::google::protobuf::Message {
   inline ::google::protobuf::uint32 parental_weekly_minutes_remaining() const;
   inline void set_parental_weekly_minutes_remaining(::google::protobuf::uint32 value);
 
-  // optional uint32 seconds_remaining_until_kick = 4;
-  inline bool has_seconds_remaining_until_kick() const;
-  inline void clear_seconds_remaining_until_kick();
+  // optional uint32 seconds_remaining_until_kick = 4 [deprecated = true];
+  inline bool has_seconds_remaining_until_kick() const PROTOBUF_DEPRECATED;
+  inline void clear_seconds_remaining_until_kick() PROTOBUF_DEPRECATED;
   static const int kSecondsRemainingUntilKickFieldNumber = 4;
-  inline ::google::protobuf::uint32 seconds_remaining_until_kick() const;
-  inline void set_seconds_remaining_until_kick(::google::protobuf::uint32 value);
+  inline ::google::protobuf::uint32 seconds_remaining_until_kick() const PROTOBUF_DEPRECATED;
+  inline void set_seconds_remaining_until_kick(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
 
   // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameTimeRemainingInfo)
  private:
@@ -4644,14 +3681,14 @@ class TC_PROTO_API AuthorizedData : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API BenefactorAddress : public ::google::protobuf::Message {
+class TC_PROTO_API IgrId : public ::google::protobuf::Message {
  public:
-  BenefactorAddress();
-  virtual ~BenefactorAddress();
+  IgrId();
+  virtual ~IgrId();
 
-  BenefactorAddress(const BenefactorAddress& from);
+  IgrId(const IgrId& from);
 
-  inline BenefactorAddress& operator=(const BenefactorAddress& from) {
+  inline IgrId& operator=(const IgrId& from) {
     CopyFrom(from);
     return *this;
   }
@@ -4665,111 +3702,23 @@ class TC_PROTO_API BenefactorAddress : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const BenefactorAddress& default_instance();
-
-  void Swap(BenefactorAddress* other);
-
-  // implements Message ----------------------------------------------
-
-  BenefactorAddress* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const BenefactorAddress& from);
-  void MergeFrom(const BenefactorAddress& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional uint32 region = 1;
-  inline bool has_region() const;
-  inline void clear_region();
-  static const int kRegionFieldNumber = 1;
-  inline ::google::protobuf::uint32 region() const;
-  inline void set_region(::google::protobuf::uint32 value);
-
-  // optional string igr_address = 2;
-  inline bool has_igr_address() const;
-  inline void clear_igr_address();
-  static const int kIgrAddressFieldNumber = 2;
-  inline const ::std::string& igr_address() const;
-  inline void set_igr_address(const ::std::string& value);
-  inline void set_igr_address(const char* value);
-  inline void set_igr_address(const char* value, size_t size);
-  inline ::std::string* mutable_igr_address();
-  inline ::std::string* release_igr_address();
-  inline void set_allocated_igr_address(::std::string* igr_address);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.BenefactorAddress)
- private:
-  inline void set_has_region();
-  inline void clear_has_region();
-  inline void set_has_igr_address();
-  inline void clear_has_igr_address();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::std::string* igr_address_;
-  ::google::protobuf::uint32 region_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static BenefactorAddress* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ExternalBenefactorLookup : public ::google::protobuf::Message {
- public:
-  ExternalBenefactorLookup();
-  virtual ~ExternalBenefactorLookup();
-
-  ExternalBenefactorLookup(const ExternalBenefactorLookup& from);
-
-  inline ExternalBenefactorLookup& operator=(const ExternalBenefactorLookup& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
+  static const IgrId& default_instance();
 
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ExternalBenefactorLookup& default_instance();
+  enum TypeCase {
+    kGameAccount = 1,
+    kExternalId = 2,
+    TYPE_NOT_SET = 0,
+  };
 
-  void Swap(ExternalBenefactorLookup* other);
+  void Swap(IgrId* other);
 
   // implements Message ----------------------------------------------
 
-  ExternalBenefactorLookup* New() const;
+  IgrId* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ExternalBenefactorLookup& from);
-  void MergeFrom(const ExternalBenefactorLookup& from);
+  void CopyFrom(const IgrId& from);
+  void MergeFrom(const IgrId& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -4791,263 +3740,59 @@ class TC_PROTO_API ExternalBenefactorLookup : public ::google::protobuf::Message
 
   // accessors -------------------------------------------------------
 
-  // optional fixed32 benefactor_id = 1;
-  inline bool has_benefactor_id() const;
-  inline void clear_benefactor_id();
-  static const int kBenefactorIdFieldNumber = 1;
-  inline ::google::protobuf::uint32 benefactor_id() const;
-  inline void set_benefactor_id(::google::protobuf::uint32 value);
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  inline bool has_game_account() const;
+  inline void clear_game_account();
+  static const int kGameAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
+  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
+  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
+  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
 
-  // optional uint32 region = 2;
-  inline bool has_region() const;
-  inline void clear_region();
-  static const int kRegionFieldNumber = 2;
-  inline ::google::protobuf::uint32 region() const;
-  inline void set_region(::google::protobuf::uint32 value);
+  // optional fixed32 external_id = 2;
+  inline bool has_external_id() const;
+  inline void clear_external_id();
+  static const int kExternalIdFieldNumber = 2;
+  inline ::google::protobuf::uint32 external_id() const;
+  inline void set_external_id(::google::protobuf::uint32 value);
 
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ExternalBenefactorLookup)
+  inline TypeCase type_case() const;
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.IgrId)
  private:
-  inline void set_has_benefactor_id();
-  inline void clear_has_benefactor_id();
-  inline void set_has_region();
-  inline void clear_has_region();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 benefactor_id_;
-  ::google::protobuf::uint32 region_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static ExternalBenefactorLookup* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API AuthBenefactor : public ::google::protobuf::Message {
- public:
-  AuthBenefactor();
-  virtual ~AuthBenefactor();
-
-  AuthBenefactor(const AuthBenefactor& from);
-
-  inline AuthBenefactor& operator=(const AuthBenefactor& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const AuthBenefactor& default_instance();
-
-  void Swap(AuthBenefactor* other);
-
-  // implements Message ----------------------------------------------
-
-  AuthBenefactor* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AuthBenefactor& from);
-  void MergeFrom(const AuthBenefactor& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
+  inline void set_has_game_account();
+  inline void set_has_external_id();
 
-  // optional string igr_address = 1;
-  inline bool has_igr_address() const;
-  inline void clear_igr_address();
-  static const int kIgrAddressFieldNumber = 1;
-  inline const ::std::string& igr_address() const;
-  inline void set_igr_address(const ::std::string& value);
-  inline void set_igr_address(const char* value);
-  inline void set_igr_address(const char* value, size_t size);
-  inline ::std::string* mutable_igr_address();
-  inline ::std::string* release_igr_address();
-  inline void set_allocated_igr_address(::std::string* igr_address);
-
-  // optional fixed32 benefactor_id = 2;
-  inline bool has_benefactor_id() const;
-  inline void clear_benefactor_id();
-  static const int kBenefactorIdFieldNumber = 2;
-  inline ::google::protobuf::uint32 benefactor_id() const;
-  inline void set_benefactor_id(::google::protobuf::uint32 value);
-
-  // optional bool active = 3;
-  inline bool has_active() const;
-  inline void clear_active();
-  static const int kActiveFieldNumber = 3;
-  inline bool active() const;
-  inline void set_active(bool value);
-
-  // optional uint64 last_update_time = 4;
-  inline bool has_last_update_time() const;
-  inline void clear_last_update_time();
-  static const int kLastUpdateTimeFieldNumber = 4;
-  inline ::google::protobuf::uint64 last_update_time() const;
-  inline void set_last_update_time(::google::protobuf::uint64 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AuthBenefactor)
- private:
-  inline void set_has_igr_address();
-  inline void clear_has_igr_address();
-  inline void set_has_benefactor_id();
-  inline void clear_has_benefactor_id();
-  inline void set_has_active();
-  inline void clear_has_active();
-  inline void set_has_last_update_time();
-  inline void clear_has_last_update_time();
+  inline bool has_type();
+  void clear_type();
+  inline void clear_has_type();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::std::string* igr_address_;
-  ::google::protobuf::uint32 benefactor_id_;
-  bool active_;
-  ::google::protobuf::uint64 last_update_time_;
-  friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static AuthBenefactor* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ApplicationInfo : public ::google::protobuf::Message {
- public:
-  ApplicationInfo();
-  virtual ~ApplicationInfo();
-
-  ApplicationInfo(const ApplicationInfo& from);
-
-  inline ApplicationInfo& operator=(const ApplicationInfo& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ApplicationInfo& default_instance();
-
-  void Swap(ApplicationInfo* other);
-
-  // implements Message ----------------------------------------------
-
-  ApplicationInfo* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ApplicationInfo& from);
-  void MergeFrom(const ApplicationInfo& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional fixed32 platform_id = 1;
-  inline bool has_platform_id() const;
-  inline void clear_platform_id();
-  static const int kPlatformIdFieldNumber = 1;
-  inline ::google::protobuf::uint32 platform_id() const;
-  inline void set_platform_id(::google::protobuf::uint32 value);
-
-  // optional fixed32 locale = 2;
-  inline bool has_locale() const;
-  inline void clear_locale();
-  static const int kLocaleFieldNumber = 2;
-  inline ::google::protobuf::uint32 locale() const;
-  inline void set_locale(::google::protobuf::uint32 value);
-
-  // optional int32 application_version = 3;
-  inline bool has_application_version() const;
-  inline void clear_application_version();
-  static const int kApplicationVersionFieldNumber = 3;
-  inline ::google::protobuf::int32 application_version() const;
-  inline void set_application_version(::google::protobuf::int32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ApplicationInfo)
- private:
-  inline void set_has_platform_id();
-  inline void clear_has_platform_id();
-  inline void set_has_locale();
-  inline void clear_has_locale();
-  inline void set_has_application_version();
-  inline void clear_has_application_version();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  union TypeUnion {
+    ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
+    ::google::protobuf::uint32 external_id_;
+  } type_;
+  ::google::protobuf::uint32 _oneof_case_[1];
 
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 platform_id_;
-  ::google::protobuf::uint32 locale_;
-  ::google::protobuf::int32 application_version_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
   friend void protobuf_AssignDesc_account_5ftypes_2eproto();
   friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
   void InitAsDefaultInstance();
-  static ApplicationInfo* default_instance_;
+  static IgrId* default_instance_;
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API DeductRecord : public ::google::protobuf::Message {
+class TC_PROTO_API IgrAddress : public ::google::protobuf::Message {
  public:
-  DeductRecord();
-  virtual ~DeductRecord();
+  IgrAddress();
+  virtual ~IgrAddress();
 
-  DeductRecord(const DeductRecord& from);
+  IgrAddress(const IgrAddress& from);
 
-  inline DeductRecord& operator=(const DeductRecord& from) {
+  inline IgrAddress& operator=(const IgrAddress& from) {
     CopyFrom(from);
     return *this;
   }
@@ -5061,17 +3806,17 @@ class TC_PROTO_API DeductRecord : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const DeductRecord& default_instance();
+  static const IgrAddress& default_instance();
 
-  void Swap(DeductRecord* other);
+  void Swap(IgrAddress* other);
 
   // implements Message ----------------------------------------------
 
-  DeductRecord* New() const;
+  IgrAddress* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const DeductRecord& from);
-  void MergeFrom(const DeductRecord& from);
+  void CopyFrom(const IgrAddress& from);
+  void MergeFrom(const IgrAddress& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -5093,42 +3838,10 @@ class TC_PROTO_API DeductRecord : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  inline bool has_game_account() const;
-  inline void clear_game_account();
-  static const int kGameAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
-  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
-  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
-  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
-
-  // optional .bgs.protocol.account.v1.GameAccountHandle benefactor = 2;
-  inline bool has_benefactor() const;
-  inline void clear_benefactor();
-  static const int kBenefactorFieldNumber = 2;
-  inline const ::bgs::protocol::account::v1::GameAccountHandle& benefactor() const;
-  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_benefactor();
-  inline ::bgs::protocol::account::v1::GameAccountHandle* release_benefactor();
-  inline void set_allocated_benefactor(::bgs::protocol::account::v1::GameAccountHandle* benefactor);
-
-  // optional uint64 start_time = 3;
-  inline bool has_start_time() const;
-  inline void clear_start_time();
-  static const int kStartTimeFieldNumber = 3;
-  inline ::google::protobuf::uint64 start_time() const;
-  inline void set_start_time(::google::protobuf::uint64 value);
-
-  // optional uint64 end_time = 4;
-  inline bool has_end_time() const;
-  inline void clear_end_time();
-  static const int kEndTimeFieldNumber = 4;
-  inline ::google::protobuf::uint64 end_time() const;
-  inline void set_end_time(::google::protobuf::uint64 value);
-
-  // optional string client_address = 5;
+  // optional string client_address = 1;
   inline bool has_client_address() const;
   inline void clear_client_address();
-  static const int kClientAddressFieldNumber = 5;
+  static const int kClientAddressFieldNumber = 1;
   inline const ::std::string& client_address() const;
   inline void set_client_address(const ::std::string& value);
   inline void set_client_address(const char* value);
@@ -5137,82 +3850,43 @@ class TC_PROTO_API DeductRecord : public ::google::protobuf::Message {
   inline ::std::string* release_client_address();
   inline void set_allocated_client_address(::std::string* client_address);
 
-  // optional .bgs.protocol.account.v1.ApplicationInfo application_info = 6;
-  inline bool has_application_info() const;
-  inline void clear_application_info();
-  static const int kApplicationInfoFieldNumber = 6;
-  inline const ::bgs::protocol::account::v1::ApplicationInfo& application_info() const;
-  inline ::bgs::protocol::account::v1::ApplicationInfo* mutable_application_info();
-  inline ::bgs::protocol::account::v1::ApplicationInfo* release_application_info();
-  inline void set_allocated_application_info(::bgs::protocol::account::v1::ApplicationInfo* application_info);
-
-  // optional string session_owner = 7;
-  inline bool has_session_owner() const;
-  inline void clear_session_owner();
-  static const int kSessionOwnerFieldNumber = 7;
-  inline const ::std::string& session_owner() const;
-  inline void set_session_owner(const ::std::string& value);
-  inline void set_session_owner(const char* value);
-  inline void set_session_owner(const char* value, size_t size);
-  inline ::std::string* mutable_session_owner();
-  inline ::std::string* release_session_owner();
-  inline void set_allocated_session_owner(::std::string* session_owner);
-
-  // optional bool free_session = 8;
-  inline bool has_free_session() const;
-  inline void clear_free_session();
-  static const int kFreeSessionFieldNumber = 8;
-  inline bool free_session() const;
-  inline void set_free_session(bool value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.DeductRecord)
+  // optional uint32 region = 2;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 2;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.IgrAddress)
  private:
-  inline void set_has_game_account();
-  inline void clear_has_game_account();
-  inline void set_has_benefactor();
-  inline void clear_has_benefactor();
-  inline void set_has_start_time();
-  inline void clear_has_start_time();
-  inline void set_has_end_time();
-  inline void clear_has_end_time();
   inline void set_has_client_address();
   inline void clear_has_client_address();
-  inline void set_has_application_info();
-  inline void clear_has_application_info();
-  inline void set_has_session_owner();
-  inline void clear_has_session_owner();
-  inline void set_has_free_session();
-  inline void clear_has_free_session();
+  inline void set_has_region();
+  inline void clear_has_region();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
-  ::bgs::protocol::account::v1::GameAccountHandle* benefactor_;
-  ::google::protobuf::uint64 start_time_;
-  ::google::protobuf::uint64 end_time_;
   ::std::string* client_address_;
-  ::bgs::protocol::account::v1::ApplicationInfo* application_info_;
-  ::std::string* session_owner_;
-  bool free_session_;
+  ::google::protobuf::uint32 region_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
   friend void protobuf_AssignDesc_account_5ftypes_2eproto();
   friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
   void InitAsDefaultInstance();
-  static DeductRecord* default_instance_;
+  static IgrAddress* default_instance_;
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API IgrId : public ::google::protobuf::Message {
+class TC_PROTO_API AccountRestriction : public ::google::protobuf::Message {
  public:
-  IgrId();
-  virtual ~IgrId();
+  AccountRestriction();
+  virtual ~AccountRestriction();
 
-  IgrId(const IgrId& from);
+  AccountRestriction(const AccountRestriction& from);
 
-  inline IgrId& operator=(const IgrId& from) {
+  inline AccountRestriction& operator=(const AccountRestriction& from) {
     CopyFrom(from);
     return *this;
   }
@@ -5226,23 +3900,17 @@ class TC_PROTO_API IgrId : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const IgrId& default_instance();
+  static const AccountRestriction& default_instance();
 
-  enum TypeCase {
-    kGameAccount = 1,
-    kExternalId = 2,
-    TYPE_NOT_SET = 0,
-  };
-
-  void Swap(IgrId* other);
+  void Swap(AccountRestriction* other);
 
   // implements Message ----------------------------------------------
 
-  IgrId* New() const;
+  AccountRestriction* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const IgrId& from);
-  void MergeFrom(const IgrId& from);
+  void CopyFrom(const AccountRestriction& from);
+  void MergeFrom(const AccountRestriction& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -5264,48 +3932,82 @@ class TC_PROTO_API IgrId : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-  inline bool has_game_account() const;
-  inline void clear_game_account();
-  static const int kGameAccountFieldNumber = 1;
-  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
-  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
-  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
-  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
+  // optional uint32 restriction_id = 1;
+  inline bool has_restriction_id() const;
+  inline void clear_restriction_id();
+  static const int kRestrictionIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 restriction_id() const;
+  inline void set_restriction_id(::google::protobuf::uint32 value);
 
-  // optional fixed32 external_id = 2;
-  inline bool has_external_id() const;
-  inline void clear_external_id();
-  static const int kExternalIdFieldNumber = 2;
-  inline ::google::protobuf::uint32 external_id() const;
-  inline void set_external_id(::google::protobuf::uint32 value);
+  // optional fixed32 program = 2;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 2;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
 
-  inline TypeCase type_case() const;
-  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.IgrId)
+  // optional .bgs.protocol.account.v1.RestrictionType type = 3;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 3;
+  inline ::bgs::protocol::account::v1::RestrictionType type() const;
+  inline void set_type(::bgs::protocol::account::v1::RestrictionType value);
+
+  // repeated fixed32 platform = 4;
+  inline int platform_size() const;
+  inline void clear_platform();
+  static const int kPlatformFieldNumber = 4;
+  inline ::google::protobuf::uint32 platform(int index) const;
+  inline void set_platform(int index, ::google::protobuf::uint32 value);
+  inline void add_platform(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      platform() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_platform();
+
+  // optional uint64 expire_time = 5;
+  inline bool has_expire_time() const;
+  inline void clear_expire_time();
+  static const int kExpireTimeFieldNumber = 5;
+  inline ::google::protobuf::uint64 expire_time() const;
+  inline void set_expire_time(::google::protobuf::uint64 value);
+
+  // optional uint64 created_time = 6;
+  inline bool has_created_time() const;
+  inline void clear_created_time();
+  static const int kCreatedTimeFieldNumber = 6;
+  inline ::google::protobuf::uint64 created_time() const;
+  inline void set_created_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountRestriction)
  private:
-  inline void set_has_game_account();
-  inline void set_has_external_id();
-
-  inline bool has_type();
-  void clear_type();
+  inline void set_has_restriction_id();
+  inline void clear_has_restriction_id();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_type();
   inline void clear_has_type();
+  inline void set_has_expire_time();
+  inline void clear_has_expire_time();
+  inline void set_has_created_time();
+  inline void clear_has_created_time();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  union TypeUnion {
-    ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
-    ::google::protobuf::uint32 external_id_;
-  } type_;
-  ::google::protobuf::uint32 _oneof_case_[1];
-
+  ::google::protobuf::uint32 restriction_id_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > platform_;
+  ::google::protobuf::uint64 expire_time_;
+  ::google::protobuf::uint64 created_time_;
+  int type_;
   friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
   friend void protobuf_AssignDesc_account_5ftypes_2eproto();
   friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
   void InitAsDefaultInstance();
-  static IgrId* default_instance_;
+  static AccountRestriction* default_instance_;
 };
 // ===================================================================
 
@@ -5395,926 +4097,6 @@ inline void AccountLicense::set_expires(::google::protobuf::uint64 value) {
 
 // -------------------------------------------------------------------
 
-// AccountCredential
-
-// required uint32 id = 1;
-inline bool AccountCredential::has_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void AccountCredential::set_has_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void AccountCredential::clear_has_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void AccountCredential::clear_id() {
-  id_ = 0u;
-  clear_has_id();
-}
-inline ::google::protobuf::uint32 AccountCredential::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountCredential.id)
-  return id_;
-}
-inline void AccountCredential::set_id(::google::protobuf::uint32 value) {
-  set_has_id();
-  id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountCredential.id)
-}
-
-// optional bytes data = 2;
-inline bool AccountCredential::has_data() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void AccountCredential::set_has_data() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void AccountCredential::clear_has_data() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void AccountCredential::clear_data() {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_->clear();
-  }
-  clear_has_data();
-}
-inline const ::std::string& AccountCredential::data() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountCredential.data)
-  return *data_;
-}
-inline void AccountCredential::set_data(const ::std::string& value) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountCredential.data)
-}
-inline void AccountCredential::set_data(const char* value) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountCredential.data)
-}
-inline void AccountCredential::set_data(const void* value, size_t size) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountCredential.data)
-}
-inline ::std::string* AccountCredential::mutable_data() {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountCredential.data)
-  return data_;
-}
-inline ::std::string* AccountCredential::release_data() {
-  clear_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = data_;
-    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void AccountCredential::set_allocated_data(::std::string* data) {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete data_;
-  }
-  if (data) {
-    set_has_data();
-    data_ = data;
-  } else {
-    clear_has_data();
-    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountCredential.data)
-}
-
-// -------------------------------------------------------------------
-
-// AccountBlob
-
-// required fixed32 id = 2;
-inline bool AccountBlob::has_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void AccountBlob::set_has_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void AccountBlob::clear_has_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void AccountBlob::clear_id() {
-  id_ = 0u;
-  clear_has_id();
-}
-inline ::google::protobuf::uint32 AccountBlob::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.id)
-  return id_;
-}
-inline void AccountBlob::set_id(::google::protobuf::uint32 value) {
-  set_has_id();
-  id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.id)
-}
-
-// required uint32 region = 3;
-inline bool AccountBlob::has_region() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void AccountBlob::set_has_region() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void AccountBlob::clear_has_region() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void AccountBlob::clear_region() {
-  region_ = 0u;
-  clear_has_region();
-}
-inline ::google::protobuf::uint32 AccountBlob::region() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.region)
-  return region_;
-}
-inline void AccountBlob::set_region(::google::protobuf::uint32 value) {
-  set_has_region();
-  region_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.region)
-}
-
-// repeated string email = 4;
-inline int AccountBlob::email_size() const {
-  return email_.size();
-}
-inline void AccountBlob::clear_email() {
-  email_.Clear();
-}
-inline const ::std::string& AccountBlob::email(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.email)
-  return email_.Get(index);
-}
-inline ::std::string* AccountBlob::mutable_email(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.email)
-  return email_.Mutable(index);
-}
-inline void AccountBlob::set_email(int index, const ::std::string& value) {
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.email)
-  email_.Mutable(index)->assign(value);
-}
-inline void AccountBlob::set_email(int index, const char* value) {
-  email_.Mutable(index)->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.email)
-}
-inline void AccountBlob::set_email(int index, const char* value, size_t size) {
-  email_.Mutable(index)->assign(
-    reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.email)
-}
-inline ::std::string* AccountBlob::add_email() {
-  return email_.Add();
-}
-inline void AccountBlob::add_email(const ::std::string& value) {
-  email_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.email)
-}
-inline void AccountBlob::add_email(const char* value) {
-  email_.Add()->assign(value);
-  // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.AccountBlob.email)
-}
-inline void AccountBlob::add_email(const char* value, size_t size) {
-  email_.Add()->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.AccountBlob.email)
-}
-inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
-AccountBlob::email() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.email)
-  return email_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::std::string>*
-AccountBlob::mutable_email() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.email)
-  return &email_;
-}
-
-// required uint64 flags = 5;
-inline bool AccountBlob::has_flags() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void AccountBlob::set_has_flags() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void AccountBlob::clear_has_flags() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void AccountBlob::clear_flags() {
-  flags_ = GOOGLE_ULONGLONG(0);
-  clear_has_flags();
-}
-inline ::google::protobuf::uint64 AccountBlob::flags() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.flags)
-  return flags_;
-}
-inline void AccountBlob::set_flags(::google::protobuf::uint64 value) {
-  set_has_flags();
-  flags_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.flags)
-}
-
-// optional uint64 secure_release = 6;
-inline bool AccountBlob::has_secure_release() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void AccountBlob::set_has_secure_release() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void AccountBlob::clear_has_secure_release() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void AccountBlob::clear_secure_release() {
-  secure_release_ = GOOGLE_ULONGLONG(0);
-  clear_has_secure_release();
-}
-inline ::google::protobuf::uint64 AccountBlob::secure_release() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.secure_release)
-  return secure_release_;
-}
-inline void AccountBlob::set_secure_release(::google::protobuf::uint64 value) {
-  set_has_secure_release();
-  secure_release_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.secure_release)
-}
-
-// optional uint64 whitelist_start = 7;
-inline bool AccountBlob::has_whitelist_start() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
-}
-inline void AccountBlob::set_has_whitelist_start() {
-  _has_bits_[0] |= 0x00000020u;
-}
-inline void AccountBlob::clear_has_whitelist_start() {
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline void AccountBlob::clear_whitelist_start() {
-  whitelist_start_ = GOOGLE_ULONGLONG(0);
-  clear_has_whitelist_start();
-}
-inline ::google::protobuf::uint64 AccountBlob::whitelist_start() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.whitelist_start)
-  return whitelist_start_;
-}
-inline void AccountBlob::set_whitelist_start(::google::protobuf::uint64 value) {
-  set_has_whitelist_start();
-  whitelist_start_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.whitelist_start)
-}
-
-// optional uint64 whitelist_end = 8;
-inline bool AccountBlob::has_whitelist_end() const {
-  return (_has_bits_[0] & 0x00000040u) != 0;
-}
-inline void AccountBlob::set_has_whitelist_end() {
-  _has_bits_[0] |= 0x00000040u;
-}
-inline void AccountBlob::clear_has_whitelist_end() {
-  _has_bits_[0] &= ~0x00000040u;
-}
-inline void AccountBlob::clear_whitelist_end() {
-  whitelist_end_ = GOOGLE_ULONGLONG(0);
-  clear_has_whitelist_end();
-}
-inline ::google::protobuf::uint64 AccountBlob::whitelist_end() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.whitelist_end)
-  return whitelist_end_;
-}
-inline void AccountBlob::set_whitelist_end(::google::protobuf::uint64 value) {
-  set_has_whitelist_end();
-  whitelist_end_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.whitelist_end)
-}
-
-// required string full_name = 10;
-inline bool AccountBlob::has_full_name() const {
-  return (_has_bits_[0] & 0x00000080u) != 0;
-}
-inline void AccountBlob::set_has_full_name() {
-  _has_bits_[0] |= 0x00000080u;
-}
-inline void AccountBlob::clear_has_full_name() {
-  _has_bits_[0] &= ~0x00000080u;
-}
-inline void AccountBlob::clear_full_name() {
-  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_->clear();
-  }
-  clear_has_full_name();
-}
-inline const ::std::string& AccountBlob::full_name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.full_name)
-  return *full_name_;
-}
-inline void AccountBlob::set_full_name(const ::std::string& value) {
-  set_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_ = new ::std::string;
-  }
-  full_name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.full_name)
-}
-inline void AccountBlob::set_full_name(const char* value) {
-  set_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_ = new ::std::string;
-  }
-  full_name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.full_name)
-}
-inline void AccountBlob::set_full_name(const char* value, size_t size) {
-  set_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_ = new ::std::string;
-  }
-  full_name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.full_name)
-}
-inline ::std::string* AccountBlob::mutable_full_name() {
-  set_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    full_name_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.full_name)
-  return full_name_;
-}
-inline ::std::string* AccountBlob::release_full_name() {
-  clear_has_full_name();
-  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = full_name_;
-    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void AccountBlob::set_allocated_full_name(::std::string* full_name) {
-  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete full_name_;
-  }
-  if (full_name) {
-    set_has_full_name();
-    full_name_ = full_name;
-  } else {
-    clear_has_full_name();
-    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.full_name)
-}
-
-// repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-inline int AccountBlob::licenses_size() const {
-  return licenses_.size();
-}
-inline void AccountBlob::clear_licenses() {
-  licenses_.Clear();
-}
-inline const ::bgs::protocol::account::v1::AccountLicense& AccountBlob::licenses(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.licenses)
-  return licenses_.Get(index);
-}
-inline ::bgs::protocol::account::v1::AccountLicense* AccountBlob::mutable_licenses(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.licenses)
-  return licenses_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::AccountLicense* AccountBlob::add_licenses() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.licenses)
-  return licenses_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
-AccountBlob::licenses() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.licenses)
-  return licenses_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
-AccountBlob::mutable_licenses() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.licenses)
-  return &licenses_;
-}
-
-// repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
-inline int AccountBlob::credentials_size() const {
-  return credentials_.size();
-}
-inline void AccountBlob::clear_credentials() {
-  credentials_.Clear();
-}
-inline const ::bgs::protocol::account::v1::AccountCredential& AccountBlob::credentials(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.credentials)
-  return credentials_.Get(index);
-}
-inline ::bgs::protocol::account::v1::AccountCredential* AccountBlob::mutable_credentials(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.credentials)
-  return credentials_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::AccountCredential* AccountBlob::add_credentials() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.credentials)
-  return credentials_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
-AccountBlob::credentials() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.credentials)
-  return credentials_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
-AccountBlob::mutable_credentials() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.credentials)
-  return &credentials_;
-}
-
-// repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
-inline int AccountBlob::account_links_size() const {
-  return account_links_.size();
-}
-inline void AccountBlob::clear_account_links() {
-  account_links_.Clear();
-}
-inline const ::bgs::protocol::account::v1::GameAccountLink& AccountBlob::account_links(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.account_links)
-  return account_links_.Get(index);
-}
-inline ::bgs::protocol::account::v1::GameAccountLink* AccountBlob::mutable_account_links(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.account_links)
-  return account_links_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::GameAccountLink* AccountBlob::add_account_links() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.account_links)
-  return account_links_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >&
-AccountBlob::account_links() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.account_links)
-  return account_links_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >*
-AccountBlob::mutable_account_links() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.account_links)
-  return &account_links_;
-}
-
-// optional string battle_tag = 23;
-inline bool AccountBlob::has_battle_tag() const {
-  return (_has_bits_[0] & 0x00000800u) != 0;
-}
-inline void AccountBlob::set_has_battle_tag() {
-  _has_bits_[0] |= 0x00000800u;
-}
-inline void AccountBlob::clear_has_battle_tag() {
-  _has_bits_[0] &= ~0x00000800u;
-}
-inline void AccountBlob::clear_battle_tag() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_->clear();
-  }
-  clear_has_battle_tag();
-}
-inline const ::std::string& AccountBlob::battle_tag() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.battle_tag)
-  return *battle_tag_;
-}
-inline void AccountBlob::set_battle_tag(const ::std::string& value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.battle_tag)
-}
-inline void AccountBlob::set_battle_tag(const char* value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.battle_tag)
-}
-inline void AccountBlob::set_battle_tag(const char* value, size_t size) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.battle_tag)
-}
-inline ::std::string* AccountBlob::mutable_battle_tag() {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.battle_tag)
-  return battle_tag_;
-}
-inline ::std::string* AccountBlob::release_battle_tag() {
-  clear_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = battle_tag_;
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void AccountBlob::set_allocated_battle_tag(::std::string* battle_tag) {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (battle_tag) {
-    set_has_battle_tag();
-    battle_tag_ = battle_tag;
-  } else {
-    clear_has_battle_tag();
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.battle_tag)
-}
-
-// optional fixed32 default_currency = 25;
-inline bool AccountBlob::has_default_currency() const {
-  return (_has_bits_[0] & 0x00001000u) != 0;
-}
-inline void AccountBlob::set_has_default_currency() {
-  _has_bits_[0] |= 0x00001000u;
-}
-inline void AccountBlob::clear_has_default_currency() {
-  _has_bits_[0] &= ~0x00001000u;
-}
-inline void AccountBlob::clear_default_currency() {
-  default_currency_ = 0u;
-  clear_has_default_currency();
-}
-inline ::google::protobuf::uint32 AccountBlob::default_currency() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.default_currency)
-  return default_currency_;
-}
-inline void AccountBlob::set_default_currency(::google::protobuf::uint32 value) {
-  set_has_default_currency();
-  default_currency_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.default_currency)
-}
-
-// optional uint32 legal_region = 26;
-inline bool AccountBlob::has_legal_region() const {
-  return (_has_bits_[0] & 0x00002000u) != 0;
-}
-inline void AccountBlob::set_has_legal_region() {
-  _has_bits_[0] |= 0x00002000u;
-}
-inline void AccountBlob::clear_has_legal_region() {
-  _has_bits_[0] &= ~0x00002000u;
-}
-inline void AccountBlob::clear_legal_region() {
-  legal_region_ = 0u;
-  clear_has_legal_region();
-}
-inline ::google::protobuf::uint32 AccountBlob::legal_region() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.legal_region)
-  return legal_region_;
-}
-inline void AccountBlob::set_legal_region(::google::protobuf::uint32 value) {
-  set_has_legal_region();
-  legal_region_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.legal_region)
-}
-
-// optional fixed32 legal_locale = 27;
-inline bool AccountBlob::has_legal_locale() const {
-  return (_has_bits_[0] & 0x00004000u) != 0;
-}
-inline void AccountBlob::set_has_legal_locale() {
-  _has_bits_[0] |= 0x00004000u;
-}
-inline void AccountBlob::clear_has_legal_locale() {
-  _has_bits_[0] &= ~0x00004000u;
-}
-inline void AccountBlob::clear_legal_locale() {
-  legal_locale_ = 0u;
-  clear_has_legal_locale();
-}
-inline ::google::protobuf::uint32 AccountBlob::legal_locale() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.legal_locale)
-  return legal_locale_;
-}
-inline void AccountBlob::set_legal_locale(::google::protobuf::uint32 value) {
-  set_has_legal_locale();
-  legal_locale_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.legal_locale)
-}
-
-// required uint64 cache_expiration = 30;
-inline bool AccountBlob::has_cache_expiration() const {
-  return (_has_bits_[0] & 0x00008000u) != 0;
-}
-inline void AccountBlob::set_has_cache_expiration() {
-  _has_bits_[0] |= 0x00008000u;
-}
-inline void AccountBlob::clear_has_cache_expiration() {
-  _has_bits_[0] &= ~0x00008000u;
-}
-inline void AccountBlob::clear_cache_expiration() {
-  cache_expiration_ = GOOGLE_ULONGLONG(0);
-  clear_has_cache_expiration();
-}
-inline ::google::protobuf::uint64 AccountBlob::cache_expiration() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.cache_expiration)
-  return cache_expiration_;
-}
-inline void AccountBlob::set_cache_expiration(::google::protobuf::uint64 value) {
-  set_has_cache_expiration();
-  cache_expiration_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.cache_expiration)
-}
-
-// optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
-inline bool AccountBlob::has_parental_control_info() const {
-  return (_has_bits_[0] & 0x00010000u) != 0;
-}
-inline void AccountBlob::set_has_parental_control_info() {
-  _has_bits_[0] |= 0x00010000u;
-}
-inline void AccountBlob::clear_has_parental_control_info() {
-  _has_bits_[0] &= ~0x00010000u;
-}
-inline void AccountBlob::clear_parental_control_info() {
-  if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
-  clear_has_parental_control_info();
-}
-inline const ::bgs::protocol::account::v1::ParentalControlInfo& AccountBlob::parental_control_info() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.parental_control_info)
-  return parental_control_info_ != NULL ? *parental_control_info_ : *default_instance_->parental_control_info_;
-}
-inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountBlob::mutable_parental_control_info() {
-  set_has_parental_control_info();
-  if (parental_control_info_ == NULL) parental_control_info_ = new ::bgs::protocol::account::v1::ParentalControlInfo;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.parental_control_info)
-  return parental_control_info_;
-}
-inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountBlob::release_parental_control_info() {
-  clear_has_parental_control_info();
-  ::bgs::protocol::account::v1::ParentalControlInfo* temp = parental_control_info_;
-  parental_control_info_ = NULL;
-  return temp;
-}
-inline void AccountBlob::set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info) {
-  delete parental_control_info_;
-  parental_control_info_ = parental_control_info;
-  if (parental_control_info) {
-    set_has_parental_control_info();
-  } else {
-    clear_has_parental_control_info();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.parental_control_info)
-}
-
-// optional string country = 32;
-inline bool AccountBlob::has_country() const {
-  return (_has_bits_[0] & 0x00020000u) != 0;
-}
-inline void AccountBlob::set_has_country() {
-  _has_bits_[0] |= 0x00020000u;
-}
-inline void AccountBlob::clear_has_country() {
-  _has_bits_[0] &= ~0x00020000u;
-}
-inline void AccountBlob::clear_country() {
-  if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    country_->clear();
-  }
-  clear_has_country();
-}
-inline const ::std::string& AccountBlob::country() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.country)
-  return *country_;
-}
-inline void AccountBlob::set_country(const ::std::string& value) {
-  set_has_country();
-  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    country_ = new ::std::string;
-  }
-  country_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.country)
-}
-inline void AccountBlob::set_country(const char* value) {
-  set_has_country();
-  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    country_ = new ::std::string;
-  }
-  country_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.country)
-}
-inline void AccountBlob::set_country(const char* value, size_t size) {
-  set_has_country();
-  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    country_ = new ::std::string;
-  }
-  country_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.country)
-}
-inline ::std::string* AccountBlob::mutable_country() {
-  set_has_country();
-  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    country_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.country)
-  return country_;
-}
-inline ::std::string* AccountBlob::release_country() {
-  clear_has_country();
-  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = country_;
-    country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void AccountBlob::set_allocated_country(::std::string* country) {
-  if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete country_;
-  }
-  if (country) {
-    set_has_country();
-    country_ = country;
-  } else {
-    clear_has_country();
-    country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.country)
-}
-
-// optional uint32 preferred_region = 33;
-inline bool AccountBlob::has_preferred_region() const {
-  return (_has_bits_[0] & 0x00040000u) != 0;
-}
-inline void AccountBlob::set_has_preferred_region() {
-  _has_bits_[0] |= 0x00040000u;
-}
-inline void AccountBlob::clear_has_preferred_region() {
-  _has_bits_[0] &= ~0x00040000u;
-}
-inline void AccountBlob::clear_preferred_region() {
-  preferred_region_ = 0u;
-  clear_has_preferred_region();
-}
-inline ::google::protobuf::uint32 AccountBlob::preferred_region() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.preferred_region)
-  return preferred_region_;
-}
-inline void AccountBlob::set_preferred_region(::google::protobuf::uint32 value) {
-  set_has_preferred_region();
-  preferred_region_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.preferred_region)
-}
-
-// optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
-inline bool AccountBlob::has_identity_check_status() const {
-  return (_has_bits_[0] & 0x00080000u) != 0;
-}
-inline void AccountBlob::set_has_identity_check_status() {
-  _has_bits_[0] |= 0x00080000u;
-}
-inline void AccountBlob::clear_has_identity_check_status() {
-  _has_bits_[0] &= ~0x00080000u;
-}
-inline void AccountBlob::clear_identity_check_status() {
-  identity_check_status_ = 0;
-  clear_has_identity_check_status();
-}
-inline ::bgs::protocol::account::v1::IdentityVerificationStatus AccountBlob::identity_check_status() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.identity_check_status)
-  return static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(identity_check_status_);
-}
-inline void AccountBlob::set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value) {
-  assert(::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value));
-  set_has_identity_check_status();
-  identity_check_status_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.identity_check_status)
-}
-
-// optional string cais_id = 35;
-inline bool AccountBlob::has_cais_id() const {
-  return (_has_bits_[0] & 0x00100000u) != 0;
-}
-inline void AccountBlob::set_has_cais_id() {
-  _has_bits_[0] |= 0x00100000u;
-}
-inline void AccountBlob::clear_has_cais_id() {
-  _has_bits_[0] &= ~0x00100000u;
-}
-inline void AccountBlob::clear_cais_id() {
-  if (cais_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_->clear();
-  }
-  clear_has_cais_id();
-}
-inline const ::std::string& AccountBlob::cais_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.cais_id)
-  return *cais_id_;
-}
-inline void AccountBlob::set_cais_id(const ::std::string& value) {
-  set_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_ = new ::std::string;
-  }
-  cais_id_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.cais_id)
-}
-inline void AccountBlob::set_cais_id(const char* value) {
-  set_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_ = new ::std::string;
-  }
-  cais_id_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.cais_id)
-}
-inline void AccountBlob::set_cais_id(const char* value, size_t size) {
-  set_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_ = new ::std::string;
-  }
-  cais_id_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.cais_id)
-}
-inline ::std::string* AccountBlob::mutable_cais_id() {
-  set_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    cais_id_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.cais_id)
-  return cais_id_;
-}
-inline ::std::string* AccountBlob::release_cais_id() {
-  clear_has_cais_id();
-  if (cais_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = cais_id_;
-    cais_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void AccountBlob::set_allocated_cais_id(::std::string* cais_id) {
-  if (cais_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete cais_id_;
-  }
-  if (cais_id) {
-    set_has_cais_id();
-    cais_id_ = cais_id;
-  } else {
-    clear_has_cais_id();
-    cais_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.cais_id)
-}
-
-// -------------------------------------------------------------------
-
-// AccountBlobList
-
-// repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
-inline int AccountBlobList::blob_size() const {
-  return blob_.size();
-}
-inline void AccountBlobList::clear_blob() {
-  blob_.Clear();
-}
-inline const ::bgs::protocol::account::v1::AccountBlob& AccountBlobList::blob(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlobList.blob)
-  return blob_.Get(index);
-}
-inline ::bgs::protocol::account::v1::AccountBlob* AccountBlobList::mutable_blob(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlobList.blob)
-  return blob_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::AccountBlob* AccountBlobList::add_blob() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlobList.blob)
-  return blob_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >&
-AccountBlobList::blob() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlobList.blob)
-  return blob_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >*
-AccountBlobList::mutable_blob() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlobList.blob)
-  return &blob_;
-}
-
-// -------------------------------------------------------------------
-
 // GameAccountHandle
 
 // required fixed32 id = 1;
@@ -6391,676 +4173,6 @@ inline void GameAccountHandle::set_region(::google::protobuf::uint32 value) {
 
 // -------------------------------------------------------------------
 
-// GameAccountLink
-
-// required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-inline bool GameAccountLink::has_game_account() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void GameAccountLink::set_has_game_account() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void GameAccountLink::clear_has_game_account() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void GameAccountLink::clear_game_account() {
-  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-  clear_has_game_account();
-}
-inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountLink::game_account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountLink.game_account)
-  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountLink::mutable_game_account() {
-  set_has_game_account();
-  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountLink.game_account)
-  return game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountLink::release_game_account() {
-  clear_has_game_account();
-  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
-  game_account_ = NULL;
-  return temp;
-}
-inline void GameAccountLink::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
-  delete game_account_;
-  game_account_ = game_account;
-  if (game_account) {
-    set_has_game_account();
-  } else {
-    clear_has_game_account();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountLink.game_account)
-}
-
-// required string name = 2;
-inline bool GameAccountLink::has_name() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void GameAccountLink::set_has_name() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void GameAccountLink::clear_has_name() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void GameAccountLink::clear_name() {
-  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_->clear();
-  }
-  clear_has_name();
-}
-inline const ::std::string& GameAccountLink::name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountLink.name)
-  return *name_;
-}
-inline void GameAccountLink::set_name(const ::std::string& value) {
-  set_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_ = new ::std::string;
-  }
-  name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountLink.name)
-}
-inline void GameAccountLink::set_name(const char* value) {
-  set_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_ = new ::std::string;
-  }
-  name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameAccountLink.name)
-}
-inline void GameAccountLink::set_name(const char* value, size_t size) {
-  set_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_ = new ::std::string;
-  }
-  name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameAccountLink.name)
-}
-inline ::std::string* GameAccountLink::mutable_name() {
-  set_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountLink.name)
-  return name_;
-}
-inline ::std::string* GameAccountLink::release_name() {
-  clear_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = name_;
-    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void GameAccountLink::set_allocated_name(::std::string* name) {
-  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete name_;
-  }
-  if (name) {
-    set_has_name();
-    name_ = name;
-  } else {
-    clear_has_name();
-    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountLink.name)
-}
-
-// -------------------------------------------------------------------
-
-// GameAccountBlob
-
-// required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-inline bool GameAccountBlob::has_game_account() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void GameAccountBlob::set_has_game_account() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void GameAccountBlob::clear_has_game_account() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void GameAccountBlob::clear_game_account() {
-  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-  clear_has_game_account();
-}
-inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountBlob::game_account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.game_account)
-  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountBlob::mutable_game_account() {
-  set_has_game_account();
-  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.game_account)
-  return game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountBlob::release_game_account() {
-  clear_has_game_account();
-  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
-  game_account_ = NULL;
-  return temp;
-}
-inline void GameAccountBlob::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
-  delete game_account_;
-  game_account_ = game_account;
-  if (game_account) {
-    set_has_game_account();
-  } else {
-    clear_has_game_account();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountBlob.game_account)
-}
-
-// optional string name = 2 [default = ""];
-inline bool GameAccountBlob::has_name() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void GameAccountBlob::set_has_name() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void GameAccountBlob::clear_has_name() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void GameAccountBlob::clear_name() {
-  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_->clear();
-  }
-  clear_has_name();
-}
-inline const ::std::string& GameAccountBlob::name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.name)
-  return *name_;
-}
-inline void GameAccountBlob::set_name(const ::std::string& value) {
-  set_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_ = new ::std::string;
-  }
-  name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.name)
-}
-inline void GameAccountBlob::set_name(const char* value) {
-  set_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_ = new ::std::string;
-  }
-  name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameAccountBlob.name)
-}
-inline void GameAccountBlob::set_name(const char* value, size_t size) {
-  set_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_ = new ::std::string;
-  }
-  name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameAccountBlob.name)
-}
-inline ::std::string* GameAccountBlob::mutable_name() {
-  set_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    name_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.name)
-  return name_;
-}
-inline ::std::string* GameAccountBlob::release_name() {
-  clear_has_name();
-  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = name_;
-    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void GameAccountBlob::set_allocated_name(::std::string* name) {
-  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete name_;
-  }
-  if (name) {
-    set_has_name();
-    name_ = name;
-  } else {
-    clear_has_name();
-    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountBlob.name)
-}
-
-// optional uint32 realm_permissions = 3 [default = 0];
-inline bool GameAccountBlob::has_realm_permissions() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void GameAccountBlob::set_has_realm_permissions() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void GameAccountBlob::clear_has_realm_permissions() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void GameAccountBlob::clear_realm_permissions() {
-  realm_permissions_ = 0u;
-  clear_has_realm_permissions();
-}
-inline ::google::protobuf::uint32 GameAccountBlob::realm_permissions() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.realm_permissions)
-  return realm_permissions_;
-}
-inline void GameAccountBlob::set_realm_permissions(::google::protobuf::uint32 value) {
-  set_has_realm_permissions();
-  realm_permissions_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.realm_permissions)
-}
-
-// required uint32 status = 4;
-inline bool GameAccountBlob::has_status() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void GameAccountBlob::set_has_status() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void GameAccountBlob::clear_has_status() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void GameAccountBlob::clear_status() {
-  status_ = 0u;
-  clear_has_status();
-}
-inline ::google::protobuf::uint32 GameAccountBlob::status() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.status)
-  return status_;
-}
-inline void GameAccountBlob::set_status(::google::protobuf::uint32 value) {
-  set_has_status();
-  status_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.status)
-}
-
-// optional uint64 flags = 5 [default = 0];
-inline bool GameAccountBlob::has_flags() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void GameAccountBlob::set_has_flags() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void GameAccountBlob::clear_has_flags() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void GameAccountBlob::clear_flags() {
-  flags_ = GOOGLE_ULONGLONG(0);
-  clear_has_flags();
-}
-inline ::google::protobuf::uint64 GameAccountBlob::flags() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.flags)
-  return flags_;
-}
-inline void GameAccountBlob::set_flags(::google::protobuf::uint64 value) {
-  set_has_flags();
-  flags_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.flags)
-}
-
-// optional uint32 billing_flags = 6 [default = 0];
-inline bool GameAccountBlob::has_billing_flags() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
-}
-inline void GameAccountBlob::set_has_billing_flags() {
-  _has_bits_[0] |= 0x00000020u;
-}
-inline void GameAccountBlob::clear_has_billing_flags() {
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline void GameAccountBlob::clear_billing_flags() {
-  billing_flags_ = 0u;
-  clear_has_billing_flags();
-}
-inline ::google::protobuf::uint32 GameAccountBlob::billing_flags() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.billing_flags)
-  return billing_flags_;
-}
-inline void GameAccountBlob::set_billing_flags(::google::protobuf::uint32 value) {
-  set_has_billing_flags();
-  billing_flags_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.billing_flags)
-}
-
-// required uint64 cache_expiration = 7;
-inline bool GameAccountBlob::has_cache_expiration() const {
-  return (_has_bits_[0] & 0x00000040u) != 0;
-}
-inline void GameAccountBlob::set_has_cache_expiration() {
-  _has_bits_[0] |= 0x00000040u;
-}
-inline void GameAccountBlob::clear_has_cache_expiration() {
-  _has_bits_[0] &= ~0x00000040u;
-}
-inline void GameAccountBlob::clear_cache_expiration() {
-  cache_expiration_ = GOOGLE_ULONGLONG(0);
-  clear_has_cache_expiration();
-}
-inline ::google::protobuf::uint64 GameAccountBlob::cache_expiration() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.cache_expiration)
-  return cache_expiration_;
-}
-inline void GameAccountBlob::set_cache_expiration(::google::protobuf::uint64 value) {
-  set_has_cache_expiration();
-  cache_expiration_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.cache_expiration)
-}
-
-// optional uint64 subscription_expiration = 10;
-inline bool GameAccountBlob::has_subscription_expiration() const {
-  return (_has_bits_[0] & 0x00000080u) != 0;
-}
-inline void GameAccountBlob::set_has_subscription_expiration() {
-  _has_bits_[0] |= 0x00000080u;
-}
-inline void GameAccountBlob::clear_has_subscription_expiration() {
-  _has_bits_[0] &= ~0x00000080u;
-}
-inline void GameAccountBlob::clear_subscription_expiration() {
-  subscription_expiration_ = GOOGLE_ULONGLONG(0);
-  clear_has_subscription_expiration();
-}
-inline ::google::protobuf::uint64 GameAccountBlob::subscription_expiration() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.subscription_expiration)
-  return subscription_expiration_;
-}
-inline void GameAccountBlob::set_subscription_expiration(::google::protobuf::uint64 value) {
-  set_has_subscription_expiration();
-  subscription_expiration_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.subscription_expiration)
-}
-
-// optional uint32 units_remaining = 11;
-inline bool GameAccountBlob::has_units_remaining() const {
-  return (_has_bits_[0] & 0x00000100u) != 0;
-}
-inline void GameAccountBlob::set_has_units_remaining() {
-  _has_bits_[0] |= 0x00000100u;
-}
-inline void GameAccountBlob::clear_has_units_remaining() {
-  _has_bits_[0] &= ~0x00000100u;
-}
-inline void GameAccountBlob::clear_units_remaining() {
-  units_remaining_ = 0u;
-  clear_has_units_remaining();
-}
-inline ::google::protobuf::uint32 GameAccountBlob::units_remaining() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.units_remaining)
-  return units_remaining_;
-}
-inline void GameAccountBlob::set_units_remaining(::google::protobuf::uint32 value) {
-  set_has_units_remaining();
-  units_remaining_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.units_remaining)
-}
-
-// optional uint64 status_expiration = 12;
-inline bool GameAccountBlob::has_status_expiration() const {
-  return (_has_bits_[0] & 0x00000200u) != 0;
-}
-inline void GameAccountBlob::set_has_status_expiration() {
-  _has_bits_[0] |= 0x00000200u;
-}
-inline void GameAccountBlob::clear_has_status_expiration() {
-  _has_bits_[0] &= ~0x00000200u;
-}
-inline void GameAccountBlob::clear_status_expiration() {
-  status_expiration_ = GOOGLE_ULONGLONG(0);
-  clear_has_status_expiration();
-}
-inline ::google::protobuf::uint64 GameAccountBlob::status_expiration() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.status_expiration)
-  return status_expiration_;
-}
-inline void GameAccountBlob::set_status_expiration(::google::protobuf::uint64 value) {
-  set_has_status_expiration();
-  status_expiration_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.status_expiration)
-}
-
-// optional uint32 box_level = 13;
-inline bool GameAccountBlob::has_box_level() const {
-  return (_has_bits_[0] & 0x00000400u) != 0;
-}
-inline void GameAccountBlob::set_has_box_level() {
-  _has_bits_[0] |= 0x00000400u;
-}
-inline void GameAccountBlob::clear_has_box_level() {
-  _has_bits_[0] &= ~0x00000400u;
-}
-inline void GameAccountBlob::clear_box_level() {
-  box_level_ = 0u;
-  clear_has_box_level();
-}
-inline ::google::protobuf::uint32 GameAccountBlob::box_level() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.box_level)
-  return box_level_;
-}
-inline void GameAccountBlob::set_box_level(::google::protobuf::uint32 value) {
-  set_has_box_level();
-  box_level_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.box_level)
-}
-
-// optional uint64 box_level_expiration = 14;
-inline bool GameAccountBlob::has_box_level_expiration() const {
-  return (_has_bits_[0] & 0x00000800u) != 0;
-}
-inline void GameAccountBlob::set_has_box_level_expiration() {
-  _has_bits_[0] |= 0x00000800u;
-}
-inline void GameAccountBlob::clear_has_box_level_expiration() {
-  _has_bits_[0] &= ~0x00000800u;
-}
-inline void GameAccountBlob::clear_box_level_expiration() {
-  box_level_expiration_ = GOOGLE_ULONGLONG(0);
-  clear_has_box_level_expiration();
-}
-inline ::google::protobuf::uint64 GameAccountBlob::box_level_expiration() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.box_level_expiration)
-  return box_level_expiration_;
-}
-inline void GameAccountBlob::set_box_level_expiration(::google::protobuf::uint64 value) {
-  set_has_box_level_expiration();
-  box_level_expiration_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.box_level_expiration)
-}
-
-// repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
-inline int GameAccountBlob::licenses_size() const {
-  return licenses_.size();
-}
-inline void GameAccountBlob::clear_licenses() {
-  licenses_.Clear();
-}
-inline const ::bgs::protocol::account::v1::AccountLicense& GameAccountBlob::licenses(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.licenses)
-  return licenses_.Get(index);
-}
-inline ::bgs::protocol::account::v1::AccountLicense* GameAccountBlob::mutable_licenses(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.licenses)
-  return licenses_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::AccountLicense* GameAccountBlob::add_licenses() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountBlob.licenses)
-  return licenses_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
-GameAccountBlob::licenses() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountBlob.licenses)
-  return licenses_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
-GameAccountBlob::mutable_licenses() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountBlob.licenses)
-  return &licenses_;
-}
-
-// optional fixed32 raf_account = 21;
-inline bool GameAccountBlob::has_raf_account() const {
-  return (_has_bits_[0] & 0x00002000u) != 0;
-}
-inline void GameAccountBlob::set_has_raf_account() {
-  _has_bits_[0] |= 0x00002000u;
-}
-inline void GameAccountBlob::clear_has_raf_account() {
-  _has_bits_[0] &= ~0x00002000u;
-}
-inline void GameAccountBlob::clear_raf_account() {
-  raf_account_ = 0u;
-  clear_has_raf_account();
-}
-inline ::google::protobuf::uint32 GameAccountBlob::raf_account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.raf_account)
-  return raf_account_;
-}
-inline void GameAccountBlob::set_raf_account(::google::protobuf::uint32 value) {
-  set_has_raf_account();
-  raf_account_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.raf_account)
-}
-
-// optional bytes raf_info = 22;
-inline bool GameAccountBlob::has_raf_info() const {
-  return (_has_bits_[0] & 0x00004000u) != 0;
-}
-inline void GameAccountBlob::set_has_raf_info() {
-  _has_bits_[0] |= 0x00004000u;
-}
-inline void GameAccountBlob::clear_has_raf_info() {
-  _has_bits_[0] &= ~0x00004000u;
-}
-inline void GameAccountBlob::clear_raf_info() {
-  if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    raf_info_->clear();
-  }
-  clear_has_raf_info();
-}
-inline const ::std::string& GameAccountBlob::raf_info() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.raf_info)
-  return *raf_info_;
-}
-inline void GameAccountBlob::set_raf_info(const ::std::string& value) {
-  set_has_raf_info();
-  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    raf_info_ = new ::std::string;
-  }
-  raf_info_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.raf_info)
-}
-inline void GameAccountBlob::set_raf_info(const char* value) {
-  set_has_raf_info();
-  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    raf_info_ = new ::std::string;
-  }
-  raf_info_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameAccountBlob.raf_info)
-}
-inline void GameAccountBlob::set_raf_info(const void* value, size_t size) {
-  set_has_raf_info();
-  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    raf_info_ = new ::std::string;
-  }
-  raf_info_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameAccountBlob.raf_info)
-}
-inline ::std::string* GameAccountBlob::mutable_raf_info() {
-  set_has_raf_info();
-  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    raf_info_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.raf_info)
-  return raf_info_;
-}
-inline ::std::string* GameAccountBlob::release_raf_info() {
-  clear_has_raf_info();
-  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = raf_info_;
-    raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void GameAccountBlob::set_allocated_raf_info(::std::string* raf_info) {
-  if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete raf_info_;
-  }
-  if (raf_info) {
-    set_has_raf_info();
-    raf_info_ = raf_info;
-  } else {
-    clear_has_raf_info();
-    raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountBlob.raf_info)
-}
-
-// optional uint64 raf_expiration = 23;
-inline bool GameAccountBlob::has_raf_expiration() const {
-  return (_has_bits_[0] & 0x00008000u) != 0;
-}
-inline void GameAccountBlob::set_has_raf_expiration() {
-  _has_bits_[0] |= 0x00008000u;
-}
-inline void GameAccountBlob::clear_has_raf_expiration() {
-  _has_bits_[0] &= ~0x00008000u;
-}
-inline void GameAccountBlob::clear_raf_expiration() {
-  raf_expiration_ = GOOGLE_ULONGLONG(0);
-  clear_has_raf_expiration();
-}
-inline ::google::protobuf::uint64 GameAccountBlob::raf_expiration() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.raf_expiration)
-  return raf_expiration_;
-}
-inline void GameAccountBlob::set_raf_expiration(::google::protobuf::uint64 value) {
-  set_has_raf_expiration();
-  raf_expiration_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.raf_expiration)
-}
-
-// -------------------------------------------------------------------
-
-// GameAccountBlobList
-
-// repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
-inline int GameAccountBlobList::blob_size() const {
-  return blob_.size();
-}
-inline void GameAccountBlobList::clear_blob() {
-  blob_.Clear();
-}
-inline const ::bgs::protocol::account::v1::GameAccountBlob& GameAccountBlobList::blob(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlobList.blob)
-  return blob_.Get(index);
-}
-inline ::bgs::protocol::account::v1::GameAccountBlob* GameAccountBlobList::mutable_blob(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlobList.blob)
-  return blob_.Mutable(index);
-}
-inline ::bgs::protocol::account::v1::GameAccountBlob* GameAccountBlobList::add_blob() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountBlobList.blob)
-  return blob_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >&
-GameAccountBlobList::blob() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountBlobList.blob)
-  return blob_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >*
-GameAccountBlobList::mutable_blob() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountBlobList.blob)
-  return &blob_;
-}
-
-// -------------------------------------------------------------------
-
 // AccountReference
 
 // optional fixed32 id = 1;
@@ -7433,223 +4545,6 @@ inline void Identity::set_allocated_process(::bgs::protocol::ProcessId* process)
 
 // -------------------------------------------------------------------
 
-// AccountInfo
-
-// optional bool account_paid = 1 [default = false];
-inline bool AccountInfo::has_account_paid() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void AccountInfo::set_has_account_paid() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void AccountInfo::clear_has_account_paid() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void AccountInfo::clear_account_paid() {
-  account_paid_ = false;
-  clear_has_account_paid();
-}
-inline bool AccountInfo::account_paid() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.account_paid)
-  return account_paid_;
-}
-inline void AccountInfo::set_account_paid(bool value) {
-  set_has_account_paid();
-  account_paid_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.account_paid)
-}
-
-// optional fixed32 country_id = 2 [default = 0];
-inline bool AccountInfo::has_country_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void AccountInfo::set_has_country_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void AccountInfo::clear_has_country_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void AccountInfo::clear_country_id() {
-  country_id_ = 0u;
-  clear_has_country_id();
-}
-inline ::google::protobuf::uint32 AccountInfo::country_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.country_id)
-  return country_id_;
-}
-inline void AccountInfo::set_country_id(::google::protobuf::uint32 value) {
-  set_has_country_id();
-  country_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.country_id)
-}
-
-// optional string battle_tag = 3;
-inline bool AccountInfo::has_battle_tag() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void AccountInfo::set_has_battle_tag() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void AccountInfo::clear_has_battle_tag() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void AccountInfo::clear_battle_tag() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_->clear();
-  }
-  clear_has_battle_tag();
-}
-inline const ::std::string& AccountInfo::battle_tag() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.battle_tag)
-  return *battle_tag_;
-}
-inline void AccountInfo::set_battle_tag(const ::std::string& value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.battle_tag)
-}
-inline void AccountInfo::set_battle_tag(const char* value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountInfo.battle_tag)
-}
-inline void AccountInfo::set_battle_tag(const char* value, size_t size) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountInfo.battle_tag)
-}
-inline ::std::string* AccountInfo::mutable_battle_tag() {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountInfo.battle_tag)
-  return battle_tag_;
-}
-inline ::std::string* AccountInfo::release_battle_tag() {
-  clear_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = battle_tag_;
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void AccountInfo::set_allocated_battle_tag(::std::string* battle_tag) {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (battle_tag) {
-    set_has_battle_tag();
-    battle_tag_ = battle_tag;
-  } else {
-    clear_has_battle_tag();
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountInfo.battle_tag)
-}
-
-// optional bool manual_review = 4 [default = false];
-inline bool AccountInfo::has_manual_review() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void AccountInfo::set_has_manual_review() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void AccountInfo::clear_has_manual_review() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void AccountInfo::clear_manual_review() {
-  manual_review_ = false;
-  clear_has_manual_review();
-}
-inline bool AccountInfo::manual_review() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.manual_review)
-  return manual_review_;
-}
-inline void AccountInfo::set_manual_review(bool value) {
-  set_has_manual_review();
-  manual_review_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.manual_review)
-}
-
-// optional .bgs.protocol.account.v1.Identity identity = 5;
-inline bool AccountInfo::has_identity() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void AccountInfo::set_has_identity() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void AccountInfo::clear_has_identity() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void AccountInfo::clear_identity() {
-  if (identity_ != NULL) identity_->::bgs::protocol::account::v1::Identity::Clear();
-  clear_has_identity();
-}
-inline const ::bgs::protocol::account::v1::Identity& AccountInfo::identity() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.identity)
-  return identity_ != NULL ? *identity_ : *default_instance_->identity_;
-}
-inline ::bgs::protocol::account::v1::Identity* AccountInfo::mutable_identity() {
-  set_has_identity();
-  if (identity_ == NULL) identity_ = new ::bgs::protocol::account::v1::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountInfo.identity)
-  return identity_;
-}
-inline ::bgs::protocol::account::v1::Identity* AccountInfo::release_identity() {
-  clear_has_identity();
-  ::bgs::protocol::account::v1::Identity* temp = identity_;
-  identity_ = NULL;
-  return temp;
-}
-inline void AccountInfo::set_allocated_identity(::bgs::protocol::account::v1::Identity* identity) {
-  delete identity_;
-  identity_ = identity;
-  if (identity) {
-    set_has_identity();
-  } else {
-    clear_has_identity();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountInfo.identity)
-}
-
-// optional bool account_muted = 6 [default = false];
-inline bool AccountInfo::has_account_muted() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
-}
-inline void AccountInfo::set_has_account_muted() {
-  _has_bits_[0] |= 0x00000020u;
-}
-inline void AccountInfo::clear_has_account_muted() {
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline void AccountInfo::clear_account_muted() {
-  account_muted_ = false;
-  clear_has_account_muted();
-}
-inline bool AccountInfo::account_muted() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.account_muted)
-  return account_muted_;
-}
-inline void AccountInfo::set_account_muted(bool value) {
-  set_has_account_muted();
-  account_muted_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.account_muted)
-}
-
-// -------------------------------------------------------------------
-
 // ProgramTag
 
 // optional fixed32 program = 1;
@@ -9054,6 +5949,108 @@ inline void AccountLevelInfo::set_allocated_email(::std::string* email) {
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.email)
 }
 
+// optional bool headless_account = 14;
+inline bool AccountLevelInfo::has_headless_account() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void AccountLevelInfo::set_has_headless_account() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void AccountLevelInfo::clear_has_headless_account() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void AccountLevelInfo::clear_headless_account() {
+  headless_account_ = false;
+  clear_has_headless_account();
+}
+inline bool AccountLevelInfo::headless_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.headless_account)
+  return headless_account_;
+}
+inline void AccountLevelInfo::set_headless_account(bool value) {
+  set_has_headless_account();
+  headless_account_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.headless_account)
+}
+
+// optional bool test_account = 15;
+inline bool AccountLevelInfo::has_test_account() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void AccountLevelInfo::set_has_test_account() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void AccountLevelInfo::clear_has_test_account() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void AccountLevelInfo::clear_test_account() {
+  test_account_ = false;
+  clear_has_test_account();
+}
+inline bool AccountLevelInfo::test_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.test_account)
+  return test_account_;
+}
+inline void AccountLevelInfo::set_test_account(bool value) {
+  set_has_test_account();
+  test_account_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.test_account)
+}
+
+// repeated .bgs.protocol.account.v1.AccountRestriction restriction = 16;
+inline int AccountLevelInfo::restriction_size() const {
+  return restriction_.size();
+}
+inline void AccountLevelInfo::clear_restriction() {
+  restriction_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountRestriction& AccountLevelInfo::restriction(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.restriction)
+  return restriction_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountRestriction* AccountLevelInfo::mutable_restriction(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.restriction)
+  return restriction_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountRestriction* AccountLevelInfo::add_restriction() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountLevelInfo.restriction)
+  return restriction_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountRestriction >&
+AccountLevelInfo::restriction() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountLevelInfo.restriction)
+  return restriction_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountRestriction >*
+AccountLevelInfo::mutable_restriction() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountLevelInfo.restriction)
+  return &restriction_;
+}
+
+// optional bool is_sms_protected = 17;
+inline bool AccountLevelInfo::has_is_sms_protected() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void AccountLevelInfo::set_has_is_sms_protected() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void AccountLevelInfo::clear_has_is_sms_protected() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void AccountLevelInfo::clear_is_sms_protected() {
+  is_sms_protected_ = false;
+  clear_has_is_sms_protected();
+}
+inline bool AccountLevelInfo::is_sms_protected() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.is_sms_protected)
+  return is_sms_protected_;
+}
+inline void AccountLevelInfo::set_is_sms_protected(bool value) {
+  set_has_is_sms_protected();
+  is_sms_protected_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.is_sms_protected)
+}
+
 // -------------------------------------------------------------------
 
 // PrivacyInfo
@@ -9082,28 +6079,28 @@ inline void PrivacyInfo::set_is_using_rid(bool value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_using_rid)
 }
 
-// optional bool is_real_id_visible_for_view_friends = 4;
-inline bool PrivacyInfo::has_is_real_id_visible_for_view_friends() const {
+// optional bool is_visible_for_view_friends = 4;
+inline bool PrivacyInfo::has_is_visible_for_view_friends() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline void PrivacyInfo::set_has_is_real_id_visible_for_view_friends() {
+inline void PrivacyInfo::set_has_is_visible_for_view_friends() {
   _has_bits_[0] |= 0x00000002u;
 }
-inline void PrivacyInfo::clear_has_is_real_id_visible_for_view_friends() {
+inline void PrivacyInfo::clear_has_is_visible_for_view_friends() {
   _has_bits_[0] &= ~0x00000002u;
 }
-inline void PrivacyInfo::clear_is_real_id_visible_for_view_friends() {
-  is_real_id_visible_for_view_friends_ = false;
-  clear_has_is_real_id_visible_for_view_friends();
+inline void PrivacyInfo::clear_is_visible_for_view_friends() {
+  is_visible_for_view_friends_ = false;
+  clear_has_is_visible_for_view_friends();
 }
-inline bool PrivacyInfo::is_real_id_visible_for_view_friends() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.is_real_id_visible_for_view_friends)
-  return is_real_id_visible_for_view_friends_;
+inline bool PrivacyInfo::is_visible_for_view_friends() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.is_visible_for_view_friends)
+  return is_visible_for_view_friends_;
 }
-inline void PrivacyInfo::set_is_real_id_visible_for_view_friends(bool value) {
-  set_has_is_real_id_visible_for_view_friends();
-  is_real_id_visible_for_view_friends_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_real_id_visible_for_view_friends)
+inline void PrivacyInfo::set_is_visible_for_view_friends(bool value) {
+  set_has_is_visible_for_view_friends();
+  is_visible_for_view_friends_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_visible_for_view_friends)
 }
 
 // optional bool is_hidden_from_friend_finder = 5;
@@ -9155,6 +6152,30 @@ inline void PrivacyInfo::set_game_info_privacy(::bgs::protocol::account::v1::Pri
   // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.game_info_privacy)
 }
 
+// optional bool only_allow_friend_whispers = 7;
+inline bool PrivacyInfo::has_only_allow_friend_whispers() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void PrivacyInfo::set_has_only_allow_friend_whispers() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void PrivacyInfo::clear_has_only_allow_friend_whispers() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void PrivacyInfo::clear_only_allow_friend_whispers() {
+  only_allow_friend_whispers_ = false;
+  clear_has_only_allow_friend_whispers();
+}
+inline bool PrivacyInfo::only_allow_friend_whispers() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.only_allow_friend_whispers)
+  return only_allow_friend_whispers_;
+}
+inline void PrivacyInfo::set_only_allow_friend_whispers(bool value) {
+  set_has_only_allow_friend_whispers();
+  only_allow_friend_whispers_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.only_allow_friend_whispers)
+}
+
 // -------------------------------------------------------------------
 
 // ParentalControlInfo
@@ -9361,6 +6382,54 @@ ParentalControlInfo::mutable_play_schedule() {
   return &play_schedule_;
 }
 
+// optional bool can_join_group = 9;
+inline bool ParentalControlInfo::has_can_join_group() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ParentalControlInfo::set_has_can_join_group() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ParentalControlInfo::clear_has_can_join_group() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ParentalControlInfo::clear_can_join_group() {
+  can_join_group_ = false;
+  clear_has_can_join_group();
+}
+inline bool ParentalControlInfo::can_join_group() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.can_join_group)
+  return can_join_group_;
+}
+inline void ParentalControlInfo::set_can_join_group(bool value) {
+  set_has_can_join_group();
+  can_join_group_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.can_join_group)
+}
+
+// optional bool can_use_profile = 10;
+inline bool ParentalControlInfo::has_can_use_profile() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ParentalControlInfo::set_has_can_use_profile() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ParentalControlInfo::clear_has_can_use_profile() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ParentalControlInfo::clear_can_use_profile() {
+  can_use_profile_ = false;
+  clear_has_can_use_profile();
+}
+inline bool ParentalControlInfo::can_use_profile() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.can_use_profile)
+  return can_use_profile_;
+}
+inline void ParentalControlInfo::set_can_use_profile(bool value) {
+  set_has_can_use_profile();
+  can_use_profile_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.can_use_profile)
+}
+
 // -------------------------------------------------------------------
 
 // GameLevelInfo
@@ -9791,7 +6860,7 @@ inline void GameTimeRemainingInfo::set_parental_weekly_minutes_remaining(::googl
   // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeRemainingInfo.parental_weekly_minutes_remaining)
 }
 
-// optional uint32 seconds_remaining_until_kick = 4;
+// optional uint32 seconds_remaining_until_kick = 4 [deprecated = true];
 inline bool GameTimeRemainingInfo::has_seconds_remaining_until_kick() const {
   return (_has_bits_[0] & 0x00000008u) != 0;
 }
@@ -11277,575 +8346,144 @@ AuthorizedData::mutable_license() {
 
 // -------------------------------------------------------------------
 
-// BenefactorAddress
-
-// optional uint32 region = 1;
-inline bool BenefactorAddress::has_region() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void BenefactorAddress::set_has_region() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void BenefactorAddress::clear_has_region() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void BenefactorAddress::clear_region() {
-  region_ = 0u;
-  clear_has_region();
-}
-inline ::google::protobuf::uint32 BenefactorAddress::region() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.BenefactorAddress.region)
-  return region_;
-}
-inline void BenefactorAddress::set_region(::google::protobuf::uint32 value) {
-  set_has_region();
-  region_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.BenefactorAddress.region)
-}
+// IgrId
 
-// optional string igr_address = 2;
-inline bool BenefactorAddress::has_igr_address() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void BenefactorAddress::set_has_igr_address() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void BenefactorAddress::clear_has_igr_address() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void BenefactorAddress::clear_igr_address() {
-  if (igr_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_->clear();
-  }
-  clear_has_igr_address();
-}
-inline const ::std::string& BenefactorAddress::igr_address() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.BenefactorAddress.igr_address)
-  return *igr_address_;
+// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+inline bool IgrId::has_game_account() const {
+  return type_case() == kGameAccount;
 }
-inline void BenefactorAddress::set_igr_address(const ::std::string& value) {
-  set_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_ = new ::std::string;
-  }
-  igr_address_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.BenefactorAddress.igr_address)
+inline void IgrId::set_has_game_account() {
+  _oneof_case_[0] = kGameAccount;
 }
-inline void BenefactorAddress::set_igr_address(const char* value) {
-  set_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_ = new ::std::string;
+inline void IgrId::clear_game_account() {
+  if (has_game_account()) {
+    delete type_.game_account_;
+    clear_has_type();
   }
-  igr_address_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.BenefactorAddress.igr_address)
 }
-inline void BenefactorAddress::set_igr_address(const char* value, size_t size) {
-  set_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_ = new ::std::string;
-  }
-  igr_address_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.BenefactorAddress.igr_address)
+inline const ::bgs::protocol::account::v1::GameAccountHandle& IgrId::game_account() const {
+  return has_game_account() ? *type_.game_account_
+                      : ::bgs::protocol::account::v1::GameAccountHandle::default_instance();
 }
-inline ::std::string* BenefactorAddress::mutable_igr_address() {
-  set_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_ = new ::std::string;
+inline ::bgs::protocol::account::v1::GameAccountHandle* IgrId::mutable_game_account() {
+  if (!has_game_account()) {
+    clear_type();
+    set_has_game_account();
+    type_.game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
   }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.BenefactorAddress.igr_address)
-  return igr_address_;
+  return type_.game_account_;
 }
-inline ::std::string* BenefactorAddress::release_igr_address() {
-  clear_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = igr_address_;
-    igr_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+inline ::bgs::protocol::account::v1::GameAccountHandle* IgrId::release_game_account() {
+  if (has_game_account()) {
+    clear_has_type();
+    ::bgs::protocol::account::v1::GameAccountHandle* temp = type_.game_account_;
+    type_.game_account_ = NULL;
     return temp;
-  }
-}
-inline void BenefactorAddress::set_allocated_igr_address(::std::string* igr_address) {
-  if (igr_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete igr_address_;
-  }
-  if (igr_address) {
-    set_has_igr_address();
-    igr_address_ = igr_address;
   } else {
-    clear_has_igr_address();
-    igr_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.BenefactorAddress.igr_address)
-}
-
-// -------------------------------------------------------------------
-
-// ExternalBenefactorLookup
-
-// optional fixed32 benefactor_id = 1;
-inline bool ExternalBenefactorLookup::has_benefactor_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void ExternalBenefactorLookup::set_has_benefactor_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void ExternalBenefactorLookup::clear_has_benefactor_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void ExternalBenefactorLookup::clear_benefactor_id() {
-  benefactor_id_ = 0u;
-  clear_has_benefactor_id();
-}
-inline ::google::protobuf::uint32 ExternalBenefactorLookup::benefactor_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ExternalBenefactorLookup.benefactor_id)
-  return benefactor_id_;
-}
-inline void ExternalBenefactorLookup::set_benefactor_id(::google::protobuf::uint32 value) {
-  set_has_benefactor_id();
-  benefactor_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ExternalBenefactorLookup.benefactor_id)
-}
-
-// optional uint32 region = 2;
-inline bool ExternalBenefactorLookup::has_region() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void ExternalBenefactorLookup::set_has_region() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void ExternalBenefactorLookup::clear_has_region() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void ExternalBenefactorLookup::clear_region() {
-  region_ = 0u;
-  clear_has_region();
-}
-inline ::google::protobuf::uint32 ExternalBenefactorLookup::region() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ExternalBenefactorLookup.region)
-  return region_;
-}
-inline void ExternalBenefactorLookup::set_region(::google::protobuf::uint32 value) {
-  set_has_region();
-  region_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ExternalBenefactorLookup.region)
-}
-
-// -------------------------------------------------------------------
-
-// AuthBenefactor
-
-// optional string igr_address = 1;
-inline bool AuthBenefactor::has_igr_address() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void AuthBenefactor::set_has_igr_address() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void AuthBenefactor::clear_has_igr_address() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void AuthBenefactor::clear_igr_address() {
-  if (igr_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_->clear();
+    return NULL;
   }
-  clear_has_igr_address();
-}
-inline const ::std::string& AuthBenefactor::igr_address() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AuthBenefactor.igr_address)
-  return *igr_address_;
 }
-inline void AuthBenefactor::set_igr_address(const ::std::string& value) {
-  set_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_ = new ::std::string;
+inline void IgrId::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
+  clear_type();
+  if (game_account) {
+    set_has_game_account();
+    type_.game_account_ = game_account;
   }
-  igr_address_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AuthBenefactor.igr_address)
 }
-inline void AuthBenefactor::set_igr_address(const char* value) {
-  set_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_ = new ::std::string;
-  }
-  igr_address_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AuthBenefactor.igr_address)
+
+// optional fixed32 external_id = 2;
+inline bool IgrId::has_external_id() const {
+  return type_case() == kExternalId;
 }
-inline void AuthBenefactor::set_igr_address(const char* value, size_t size) {
-  set_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_ = new ::std::string;
-  }
-  igr_address_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AuthBenefactor.igr_address)
+inline void IgrId::set_has_external_id() {
+  _oneof_case_[0] = kExternalId;
 }
-inline ::std::string* AuthBenefactor::mutable_igr_address() {
-  set_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    igr_address_ = new ::std::string;
+inline void IgrId::clear_external_id() {
+  if (has_external_id()) {
+    type_.external_id_ = 0u;
+    clear_has_type();
   }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AuthBenefactor.igr_address)
-  return igr_address_;
 }
-inline ::std::string* AuthBenefactor::release_igr_address() {
-  clear_has_igr_address();
-  if (igr_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = igr_address_;
-    igr_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
+inline ::google::protobuf::uint32 IgrId::external_id() const {
+  if (has_external_id()) {
+    return type_.external_id_;
   }
+  return 0u;
 }
-inline void AuthBenefactor::set_allocated_igr_address(::std::string* igr_address) {
-  if (igr_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete igr_address_;
-  }
-  if (igr_address) {
-    set_has_igr_address();
-    igr_address_ = igr_address;
-  } else {
-    clear_has_igr_address();
-    igr_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+inline void IgrId::set_external_id(::google::protobuf::uint32 value) {
+  if (!has_external_id()) {
+    clear_type();
+    set_has_external_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AuthBenefactor.igr_address)
-}
-
-// optional fixed32 benefactor_id = 2;
-inline bool AuthBenefactor::has_benefactor_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void AuthBenefactor::set_has_benefactor_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void AuthBenefactor::clear_has_benefactor_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void AuthBenefactor::clear_benefactor_id() {
-  benefactor_id_ = 0u;
-  clear_has_benefactor_id();
-}
-inline ::google::protobuf::uint32 AuthBenefactor::benefactor_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AuthBenefactor.benefactor_id)
-  return benefactor_id_;
-}
-inline void AuthBenefactor::set_benefactor_id(::google::protobuf::uint32 value) {
-  set_has_benefactor_id();
-  benefactor_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AuthBenefactor.benefactor_id)
-}
-
-// optional bool active = 3;
-inline bool AuthBenefactor::has_active() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void AuthBenefactor::set_has_active() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void AuthBenefactor::clear_has_active() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void AuthBenefactor::clear_active() {
-  active_ = false;
-  clear_has_active();
-}
-inline bool AuthBenefactor::active() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AuthBenefactor.active)
-  return active_;
-}
-inline void AuthBenefactor::set_active(bool value) {
-  set_has_active();
-  active_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AuthBenefactor.active)
-}
-
-// optional uint64 last_update_time = 4;
-inline bool AuthBenefactor::has_last_update_time() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void AuthBenefactor::set_has_last_update_time() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void AuthBenefactor::clear_has_last_update_time() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void AuthBenefactor::clear_last_update_time() {
-  last_update_time_ = GOOGLE_ULONGLONG(0);
-  clear_has_last_update_time();
-}
-inline ::google::protobuf::uint64 AuthBenefactor::last_update_time() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AuthBenefactor.last_update_time)
-  return last_update_time_;
-}
-inline void AuthBenefactor::set_last_update_time(::google::protobuf::uint64 value) {
-  set_has_last_update_time();
-  last_update_time_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AuthBenefactor.last_update_time)
-}
-
-// -------------------------------------------------------------------
-
-// ApplicationInfo
-
-// optional fixed32 platform_id = 1;
-inline bool ApplicationInfo::has_platform_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void ApplicationInfo::set_has_platform_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void ApplicationInfo::clear_has_platform_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void ApplicationInfo::clear_platform_id() {
-  platform_id_ = 0u;
-  clear_has_platform_id();
-}
-inline ::google::protobuf::uint32 ApplicationInfo::platform_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ApplicationInfo.platform_id)
-  return platform_id_;
-}
-inline void ApplicationInfo::set_platform_id(::google::protobuf::uint32 value) {
-  set_has_platform_id();
-  platform_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ApplicationInfo.platform_id)
-}
-
-// optional fixed32 locale = 2;
-inline bool ApplicationInfo::has_locale() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void ApplicationInfo::set_has_locale() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void ApplicationInfo::clear_has_locale() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void ApplicationInfo::clear_locale() {
-  locale_ = 0u;
-  clear_has_locale();
-}
-inline ::google::protobuf::uint32 ApplicationInfo::locale() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ApplicationInfo.locale)
-  return locale_;
-}
-inline void ApplicationInfo::set_locale(::google::protobuf::uint32 value) {
-  set_has_locale();
-  locale_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ApplicationInfo.locale)
+  type_.external_id_ = value;
 }
 
-// optional int32 application_version = 3;
-inline bool ApplicationInfo::has_application_version() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void ApplicationInfo::set_has_application_version() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void ApplicationInfo::clear_has_application_version() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void ApplicationInfo::clear_application_version() {
-  application_version_ = 0;
-  clear_has_application_version();
+inline bool IgrId::has_type() {
+  return type_case() != TYPE_NOT_SET;
 }
-inline ::google::protobuf::int32 ApplicationInfo::application_version() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ApplicationInfo.application_version)
-  return application_version_;
+inline void IgrId::clear_has_type() {
+  _oneof_case_[0] = TYPE_NOT_SET;
 }
-inline void ApplicationInfo::set_application_version(::google::protobuf::int32 value) {
-  set_has_application_version();
-  application_version_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ApplicationInfo.application_version)
+inline IgrId::TypeCase IgrId::type_case() const {
+  return IgrId::TypeCase(_oneof_case_[0]);
 }
-
 // -------------------------------------------------------------------
 
-// DeductRecord
+// IgrAddress
 
-// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-inline bool DeductRecord::has_game_account() const {
+// optional string client_address = 1;
+inline bool IgrAddress::has_client_address() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void DeductRecord::set_has_game_account() {
+inline void IgrAddress::set_has_client_address() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void DeductRecord::clear_has_game_account() {
+inline void IgrAddress::clear_has_client_address() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void DeductRecord::clear_game_account() {
-  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-  clear_has_game_account();
-}
-inline const ::bgs::protocol::account::v1::GameAccountHandle& DeductRecord::game_account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.DeductRecord.game_account)
-  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* DeductRecord::mutable_game_account() {
-  set_has_game_account();
-  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.DeductRecord.game_account)
-  return game_account_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* DeductRecord::release_game_account() {
-  clear_has_game_account();
-  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
-  game_account_ = NULL;
-  return temp;
-}
-inline void DeductRecord::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
-  delete game_account_;
-  game_account_ = game_account;
-  if (game_account) {
-    set_has_game_account();
-  } else {
-    clear_has_game_account();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.DeductRecord.game_account)
-}
-
-// optional .bgs.protocol.account.v1.GameAccountHandle benefactor = 2;
-inline bool DeductRecord::has_benefactor() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void DeductRecord::set_has_benefactor() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void DeductRecord::clear_has_benefactor() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void DeductRecord::clear_benefactor() {
-  if (benefactor_ != NULL) benefactor_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
-  clear_has_benefactor();
-}
-inline const ::bgs::protocol::account::v1::GameAccountHandle& DeductRecord::benefactor() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.DeductRecord.benefactor)
-  return benefactor_ != NULL ? *benefactor_ : *default_instance_->benefactor_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* DeductRecord::mutable_benefactor() {
-  set_has_benefactor();
-  if (benefactor_ == NULL) benefactor_ = new ::bgs::protocol::account::v1::GameAccountHandle;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.DeductRecord.benefactor)
-  return benefactor_;
-}
-inline ::bgs::protocol::account::v1::GameAccountHandle* DeductRecord::release_benefactor() {
-  clear_has_benefactor();
-  ::bgs::protocol::account::v1::GameAccountHandle* temp = benefactor_;
-  benefactor_ = NULL;
-  return temp;
-}
-inline void DeductRecord::set_allocated_benefactor(::bgs::protocol::account::v1::GameAccountHandle* benefactor) {
-  delete benefactor_;
-  benefactor_ = benefactor;
-  if (benefactor) {
-    set_has_benefactor();
-  } else {
-    clear_has_benefactor();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.DeductRecord.benefactor)
-}
-
-// optional uint64 start_time = 3;
-inline bool DeductRecord::has_start_time() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void DeductRecord::set_has_start_time() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void DeductRecord::clear_has_start_time() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void DeductRecord::clear_start_time() {
-  start_time_ = GOOGLE_ULONGLONG(0);
-  clear_has_start_time();
-}
-inline ::google::protobuf::uint64 DeductRecord::start_time() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.DeductRecord.start_time)
-  return start_time_;
-}
-inline void DeductRecord::set_start_time(::google::protobuf::uint64 value) {
-  set_has_start_time();
-  start_time_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.DeductRecord.start_time)
-}
-
-// optional uint64 end_time = 4;
-inline bool DeductRecord::has_end_time() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void DeductRecord::set_has_end_time() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void DeductRecord::clear_has_end_time() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void DeductRecord::clear_end_time() {
-  end_time_ = GOOGLE_ULONGLONG(0);
-  clear_has_end_time();
-}
-inline ::google::protobuf::uint64 DeductRecord::end_time() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.DeductRecord.end_time)
-  return end_time_;
-}
-inline void DeductRecord::set_end_time(::google::protobuf::uint64 value) {
-  set_has_end_time();
-  end_time_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.DeductRecord.end_time)
-}
-
-// optional string client_address = 5;
-inline bool DeductRecord::has_client_address() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void DeductRecord::set_has_client_address() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void DeductRecord::clear_has_client_address() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void DeductRecord::clear_client_address() {
+inline void IgrAddress::clear_client_address() {
   if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     client_address_->clear();
   }
   clear_has_client_address();
 }
-inline const ::std::string& DeductRecord::client_address() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.DeductRecord.client_address)
+inline const ::std::string& IgrAddress::client_address() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.IgrAddress.client_address)
   return *client_address_;
 }
-inline void DeductRecord::set_client_address(const ::std::string& value) {
+inline void IgrAddress::set_client_address(const ::std::string& value) {
   set_has_client_address();
   if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     client_address_ = new ::std::string;
   }
   client_address_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.DeductRecord.client_address)
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.IgrAddress.client_address)
 }
-inline void DeductRecord::set_client_address(const char* value) {
+inline void IgrAddress::set_client_address(const char* value) {
   set_has_client_address();
   if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     client_address_ = new ::std::string;
   }
   client_address_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.DeductRecord.client_address)
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.IgrAddress.client_address)
 }
-inline void DeductRecord::set_client_address(const char* value, size_t size) {
+inline void IgrAddress::set_client_address(const char* value, size_t size) {
   set_has_client_address();
   if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     client_address_ = new ::std::string;
   }
   client_address_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.DeductRecord.client_address)
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.IgrAddress.client_address)
 }
-inline ::std::string* DeductRecord::mutable_client_address() {
+inline ::std::string* IgrAddress::mutable_client_address() {
   set_has_client_address();
   if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     client_address_ = new ::std::string;
   }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.DeductRecord.client_address)
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.IgrAddress.client_address)
   return client_address_;
 }
-inline ::std::string* DeductRecord::release_client_address() {
+inline ::std::string* IgrAddress::release_client_address() {
   clear_has_client_address();
   if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     return NULL;
@@ -11855,7 +8493,7 @@ inline ::std::string* DeductRecord::release_client_address() {
     return temp;
   }
 }
-inline void DeductRecord::set_allocated_client_address(::std::string* client_address) {
+inline void IgrAddress::set_allocated_client_address(::std::string* client_address) {
   if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete client_address_;
   }
@@ -11866,233 +8504,188 @@ inline void DeductRecord::set_allocated_client_address(::std::string* client_add
     clear_has_client_address();
     client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.DeductRecord.client_address)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.IgrAddress.client_address)
 }
 
-// optional .bgs.protocol.account.v1.ApplicationInfo application_info = 6;
-inline bool DeductRecord::has_application_info() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
-}
-inline void DeductRecord::set_has_application_info() {
-  _has_bits_[0] |= 0x00000020u;
-}
-inline void DeductRecord::clear_has_application_info() {
-  _has_bits_[0] &= ~0x00000020u;
+// optional uint32 region = 2;
+inline bool IgrAddress::has_region() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline void DeductRecord::clear_application_info() {
-  if (application_info_ != NULL) application_info_->::bgs::protocol::account::v1::ApplicationInfo::Clear();
-  clear_has_application_info();
+inline void IgrAddress::set_has_region() {
+  _has_bits_[0] |= 0x00000002u;
 }
-inline const ::bgs::protocol::account::v1::ApplicationInfo& DeductRecord::application_info() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.DeductRecord.application_info)
-  return application_info_ != NULL ? *application_info_ : *default_instance_->application_info_;
+inline void IgrAddress::clear_has_region() {
+  _has_bits_[0] &= ~0x00000002u;
 }
-inline ::bgs::protocol::account::v1::ApplicationInfo* DeductRecord::mutable_application_info() {
-  set_has_application_info();
-  if (application_info_ == NULL) application_info_ = new ::bgs::protocol::account::v1::ApplicationInfo;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.DeductRecord.application_info)
-  return application_info_;
+inline void IgrAddress::clear_region() {
+  region_ = 0u;
+  clear_has_region();
 }
-inline ::bgs::protocol::account::v1::ApplicationInfo* DeductRecord::release_application_info() {
-  clear_has_application_info();
-  ::bgs::protocol::account::v1::ApplicationInfo* temp = application_info_;
-  application_info_ = NULL;
-  return temp;
+inline ::google::protobuf::uint32 IgrAddress::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.IgrAddress.region)
+  return region_;
 }
-inline void DeductRecord::set_allocated_application_info(::bgs::protocol::account::v1::ApplicationInfo* application_info) {
-  delete application_info_;
-  application_info_ = application_info;
-  if (application_info) {
-    set_has_application_info();
-  } else {
-    clear_has_application_info();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.DeductRecord.application_info)
+inline void IgrAddress::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.IgrAddress.region)
 }
 
-// optional string session_owner = 7;
-inline bool DeductRecord::has_session_owner() const {
-  return (_has_bits_[0] & 0x00000040u) != 0;
+// -------------------------------------------------------------------
+
+// AccountRestriction
+
+// optional uint32 restriction_id = 1;
+inline bool AccountRestriction::has_restriction_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void DeductRecord::set_has_session_owner() {
-  _has_bits_[0] |= 0x00000040u;
+inline void AccountRestriction::set_has_restriction_id() {
+  _has_bits_[0] |= 0x00000001u;
 }
-inline void DeductRecord::clear_has_session_owner() {
-  _has_bits_[0] &= ~0x00000040u;
+inline void AccountRestriction::clear_has_restriction_id() {
+  _has_bits_[0] &= ~0x00000001u;
 }
-inline void DeductRecord::clear_session_owner() {
-  if (session_owner_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_owner_->clear();
-  }
-  clear_has_session_owner();
+inline void AccountRestriction::clear_restriction_id() {
+  restriction_id_ = 0u;
+  clear_has_restriction_id();
 }
-inline const ::std::string& DeductRecord::session_owner() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.DeductRecord.session_owner)
-  return *session_owner_;
+inline ::google::protobuf::uint32 AccountRestriction::restriction_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountRestriction.restriction_id)
+  return restriction_id_;
 }
-inline void DeductRecord::set_session_owner(const ::std::string& value) {
-  set_has_session_owner();
-  if (session_owner_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_owner_ = new ::std::string;
-  }
-  session_owner_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.DeductRecord.session_owner)
+inline void AccountRestriction::set_restriction_id(::google::protobuf::uint32 value) {
+  set_has_restriction_id();
+  restriction_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountRestriction.restriction_id)
 }
-inline void DeductRecord::set_session_owner(const char* value) {
-  set_has_session_owner();
-  if (session_owner_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_owner_ = new ::std::string;
-  }
-  session_owner_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.DeductRecord.session_owner)
+
+// optional fixed32 program = 2;
+inline bool AccountRestriction::has_program() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline void DeductRecord::set_session_owner(const char* value, size_t size) {
-  set_has_session_owner();
-  if (session_owner_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_owner_ = new ::std::string;
-  }
-  session_owner_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.DeductRecord.session_owner)
+inline void AccountRestriction::set_has_program() {
+  _has_bits_[0] |= 0x00000002u;
 }
-inline ::std::string* DeductRecord::mutable_session_owner() {
-  set_has_session_owner();
-  if (session_owner_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_owner_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.DeductRecord.session_owner)
-  return session_owner_;
+inline void AccountRestriction::clear_has_program() {
+  _has_bits_[0] &= ~0x00000002u;
 }
-inline ::std::string* DeductRecord::release_session_owner() {
-  clear_has_session_owner();
-  if (session_owner_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = session_owner_;
-    session_owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
+inline void AccountRestriction::clear_program() {
+  program_ = 0u;
+  clear_has_program();
 }
-inline void DeductRecord::set_allocated_session_owner(::std::string* session_owner) {
-  if (session_owner_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete session_owner_;
-  }
-  if (session_owner) {
-    set_has_session_owner();
-    session_owner_ = session_owner;
-  } else {
-    clear_has_session_owner();
-    session_owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.DeductRecord.session_owner)
+inline ::google::protobuf::uint32 AccountRestriction::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountRestriction.program)
+  return program_;
+}
+inline void AccountRestriction::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountRestriction.program)
 }
 
-// optional bool free_session = 8;
-inline bool DeductRecord::has_free_session() const {
-  return (_has_bits_[0] & 0x00000080u) != 0;
+// optional .bgs.protocol.account.v1.RestrictionType type = 3;
+inline bool AccountRestriction::has_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
 }
-inline void DeductRecord::set_has_free_session() {
-  _has_bits_[0] |= 0x00000080u;
+inline void AccountRestriction::set_has_type() {
+  _has_bits_[0] |= 0x00000004u;
 }
-inline void DeductRecord::clear_has_free_session() {
-  _has_bits_[0] &= ~0x00000080u;
+inline void AccountRestriction::clear_has_type() {
+  _has_bits_[0] &= ~0x00000004u;
 }
-inline void DeductRecord::clear_free_session() {
-  free_session_ = false;
-  clear_has_free_session();
+inline void AccountRestriction::clear_type() {
+  type_ = 0;
+  clear_has_type();
 }
-inline bool DeductRecord::free_session() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.DeductRecord.free_session)
-  return free_session_;
+inline ::bgs::protocol::account::v1::RestrictionType AccountRestriction::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountRestriction.type)
+  return static_cast< ::bgs::protocol::account::v1::RestrictionType >(type_);
 }
-inline void DeductRecord::set_free_session(bool value) {
-  set_has_free_session();
-  free_session_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.DeductRecord.free_session)
+inline void AccountRestriction::set_type(::bgs::protocol::account::v1::RestrictionType value) {
+  assert(::bgs::protocol::account::v1::RestrictionType_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountRestriction.type)
 }
 
-// -------------------------------------------------------------------
-
-// IgrId
-
-// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
-inline bool IgrId::has_game_account() const {
-  return type_case() == kGameAccount;
+// repeated fixed32 platform = 4;
+inline int AccountRestriction::platform_size() const {
+  return platform_.size();
 }
-inline void IgrId::set_has_game_account() {
-  _oneof_case_[0] = kGameAccount;
+inline void AccountRestriction::clear_platform() {
+  platform_.Clear();
 }
-inline void IgrId::clear_game_account() {
-  if (has_game_account()) {
-    delete type_.game_account_;
-    clear_has_type();
-  }
+inline ::google::protobuf::uint32 AccountRestriction::platform(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountRestriction.platform)
+  return platform_.Get(index);
 }
-inline const ::bgs::protocol::account::v1::GameAccountHandle& IgrId::game_account() const {
-  return has_game_account() ? *type_.game_account_
-                      : ::bgs::protocol::account::v1::GameAccountHandle::default_instance();
+inline void AccountRestriction::set_platform(int index, ::google::protobuf::uint32 value) {
+  platform_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountRestriction.platform)
 }
-inline ::bgs::protocol::account::v1::GameAccountHandle* IgrId::mutable_game_account() {
-  if (!has_game_account()) {
-    clear_type();
-    set_has_game_account();
-    type_.game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
-  }
-  return type_.game_account_;
+inline void AccountRestriction::add_platform(::google::protobuf::uint32 value) {
+  platform_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountRestriction.platform)
 }
-inline ::bgs::protocol::account::v1::GameAccountHandle* IgrId::release_game_account() {
-  if (has_game_account()) {
-    clear_has_type();
-    ::bgs::protocol::account::v1::GameAccountHandle* temp = type_.game_account_;
-    type_.game_account_ = NULL;
-    return temp;
-  } else {
-    return NULL;
-  }
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+AccountRestriction::platform() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountRestriction.platform)
+  return platform_;
 }
-inline void IgrId::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
-  clear_type();
-  if (game_account) {
-    set_has_game_account();
-    type_.game_account_ = game_account;
-  }
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+AccountRestriction::mutable_platform() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountRestriction.platform)
+  return &platform_;
 }
 
-// optional fixed32 external_id = 2;
-inline bool IgrId::has_external_id() const {
-  return type_case() == kExternalId;
+// optional uint64 expire_time = 5;
+inline bool AccountRestriction::has_expire_time() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
 }
-inline void IgrId::set_has_external_id() {
-  _oneof_case_[0] = kExternalId;
+inline void AccountRestriction::set_has_expire_time() {
+  _has_bits_[0] |= 0x00000010u;
 }
-inline void IgrId::clear_external_id() {
-  if (has_external_id()) {
-    type_.external_id_ = 0u;
-    clear_has_type();
-  }
+inline void AccountRestriction::clear_has_expire_time() {
+  _has_bits_[0] &= ~0x00000010u;
 }
-inline ::google::protobuf::uint32 IgrId::external_id() const {
-  if (has_external_id()) {
-    return type_.external_id_;
-  }
-  return 0u;
+inline void AccountRestriction::clear_expire_time() {
+  expire_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_expire_time();
 }
-inline void IgrId::set_external_id(::google::protobuf::uint32 value) {
-  if (!has_external_id()) {
-    clear_type();
-    set_has_external_id();
-  }
-  type_.external_id_ = value;
+inline ::google::protobuf::uint64 AccountRestriction::expire_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountRestriction.expire_time)
+  return expire_time_;
+}
+inline void AccountRestriction::set_expire_time(::google::protobuf::uint64 value) {
+  set_has_expire_time();
+  expire_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountRestriction.expire_time)
 }
 
-inline bool IgrId::has_type() {
-  return type_case() != TYPE_NOT_SET;
+// optional uint64 created_time = 6;
+inline bool AccountRestriction::has_created_time() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
 }
-inline void IgrId::clear_has_type() {
-  _oneof_case_[0] = TYPE_NOT_SET;
+inline void AccountRestriction::set_has_created_time() {
+  _has_bits_[0] |= 0x00000020u;
 }
-inline IgrId::TypeCase IgrId::type_case() const {
-  return IgrId::TypeCase(_oneof_case_[0]);
+inline void AccountRestriction::clear_has_created_time() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void AccountRestriction::clear_created_time() {
+  created_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_created_time();
+}
+inline ::google::protobuf::uint64 AccountRestriction::created_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountRestriction.created_time)
+  return created_time_;
 }
+inline void AccountRestriction::set_created_time(::google::protobuf::uint64 value) {
+  set_has_created_time();
+  created_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountRestriction.created_time)
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 
@@ -12115,6 +8708,11 @@ template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::account::v1::IdentityVerificationStatus>() {
   return ::bgs::protocol::account::v1::IdentityVerificationStatus_descriptor();
 }
+template <> struct is_proto_enum< ::bgs::protocol::account::v1::RestrictionType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::account::v1::RestrictionType>() {
+  return ::bgs::protocol::account::v1::RestrictionType_descriptor();
+}
 
 }  // namespace google
 }  // namespace protobuf
diff --git a/src/server/proto/Client/client/v1/channel_id.pb.cc b/src/server/proto/Client/api/client/v1/channel_id.pb.cc
index bd313efb61d..7707817cee3 100644
--- a/src/server/proto/Client/client/v1/channel_id.pb.cc
+++ b/src/server/proto/Client/api/client/v1/channel_id.pb.cc
@@ -1,8 +1,8 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: client/v1/channel_id.proto
+// source: api/client/v1/channel_id.proto
 
 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
-#include "client/v1/channel_id.pb.h"
+#include "api/client/v1/channel_id.pb.h"
 
 #include <algorithm>
 #include <utility>
@@ -18,11 +18,6 @@
 #include "Log.h"
 // @@protoc_insertion_point(includes)
 
-// Fix stupid windows.h included from Log.h->Common.h
-#ifdef SendMessage
-#undef SendMessage
-#endif
-
 namespace bgs {
 namespace protocol {
 namespace channel {
@@ -37,11 +32,11 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 }  // namespace
 
 
-void protobuf_AssignDesc_client_2fv1_2fchannel_5fid_2eproto() {
-  protobuf_AddDesc_client_2fv1_2fchannel_5fid_2eproto();
+void protobuf_AssignDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto() {
+  protobuf_AddDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto();
   const ::google::protobuf::FileDescriptor* file =
     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
-      "client/v1/channel_id.proto");
+      "api/client/v1/channel_id.proto");
   GOOGLE_CHECK(file != NULL);
   ChannelId_descriptor_ = file->message_type(0);
   static const int ChannelId_offsets_[3] = {
@@ -67,7 +62,7 @@ namespace {
 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
 inline void protobuf_AssignDescriptorsOnce() {
   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
-                 &protobuf_AssignDesc_client_2fv1_2fchannel_5fid_2eproto);
+                 &protobuf_AssignDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto);
 }
 
 void protobuf_RegisterTypes(const ::std::string&) {
@@ -78,12 +73,12 @@ void protobuf_RegisterTypes(const ::std::string&) {
 
 }  // namespace
 
-void protobuf_ShutdownFile_client_2fv1_2fchannel_5fid_2eproto() {
+void protobuf_ShutdownFile_api_2fclient_2fv1_2fchannel_5fid_2eproto() {
   delete ChannelId::default_instance_;
   delete ChannelId_reflection_;
 }
 
-void protobuf_AddDesc_client_2fv1_2fchannel_5fid_2eproto() {
+void protobuf_AddDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto() {
   static bool already_here = false;
   if (already_here) return;
   already_here = true;
@@ -91,23 +86,24 @@ void protobuf_AddDesc_client_2fv1_2fchannel_5fid_2eproto() {
 
   ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-    "\n\032client/v1/channel_id.proto\022\027bgs.protoc"
-    "ol.channel.v1\032\017rpc_types.proto\"L\n\tChanne"
-    "lId\022\014\n\004type\030\001 \001(\r\022%\n\004host\030\002 \001(\0132\027.bgs.pr"
-    "otocol.ProcessId\022\n\n\002id\030\003 \001(\007B\002H\001", 152);
+    "\n\036api/client/v1/channel_id.proto\022\027bgs.pr"
+    "otocol.channel.v1\032\017rpc_types.proto\"T\n\tCh"
+    "annelId\022\014\n\004type\030\001 \001(\r\022%\n\004host\030\002 \001(\0132\027.bg"
+    "s.protocol.ProcessId\022\n\n\002id\030\003 \001(\007:\006\202\371+\002\010\001"
+    "B\002H\001", 164);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
-    "client/v1/channel_id.proto", &protobuf_RegisterTypes);
+    "api/client/v1/channel_id.proto", &protobuf_RegisterTypes);
   ChannelId::default_instance_ = new ChannelId();
   ChannelId::default_instance_->InitAsDefaultInstance();
-  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_client_2fv1_2fchannel_5fid_2eproto);
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_api_2fclient_2fv1_2fchannel_5fid_2eproto);
 }
 
 // Force AddDescriptors() to be called at static initialization time.
-struct StaticDescriptorInitializer_client_2fv1_2fchannel_5fid_2eproto {
-  StaticDescriptorInitializer_client_2fv1_2fchannel_5fid_2eproto() {
-    protobuf_AddDesc_client_2fv1_2fchannel_5fid_2eproto();
+struct StaticDescriptorInitializer_api_2fclient_2fv1_2fchannel_5fid_2eproto {
+  StaticDescriptorInitializer_api_2fclient_2fv1_2fchannel_5fid_2eproto() {
+    protobuf_AddDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto();
   }
-} static_descriptor_initializer_client_2fv1_2fchannel_5fid_2eproto_;
+} static_descriptor_initializer_api_2fclient_2fv1_2fchannel_5fid_2eproto_;
 
 // ===================================================================
 
@@ -164,7 +160,7 @@ const ::google::protobuf::Descriptor* ChannelId::descriptor() {
 }
 
 const ChannelId& ChannelId::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_client_2fv1_2fchannel_5fid_2eproto();
+  if (default_instance_ == NULL) protobuf_AddDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto();
   return *default_instance_;
 }
 
diff --git a/src/server/proto/Client/client/v1/channel_id.pb.h b/src/server/proto/Client/api/client/v1/channel_id.pb.h
index 74795675ca2..a336c5e968e 100644
--- a/src/server/proto/Client/client/v1/channel_id.pb.h
+++ b/src/server/proto/Client/api/client/v1/channel_id.pb.h
@@ -1,8 +1,8 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: client/v1/channel_id.proto
+// source: api/client/v1/channel_id.proto
 
-#ifndef PROTOBUF_client_2fv1_2fchannel_5fid_2eproto__INCLUDED
-#define PROTOBUF_client_2fv1_2fchannel_5fid_2eproto__INCLUDED
+#ifndef PROTOBUF_api_2fclient_2fv1_2fchannel_5fid_2eproto__INCLUDED
+#define PROTOBUF_api_2fclient_2fv1_2fchannel_5fid_2eproto__INCLUDED
 
 #include <string>
 
@@ -34,9 +34,9 @@ namespace channel {
 namespace v1 {
 
 // Internal implementation detail -- do not call these.
-void TC_PROTO_API protobuf_AddDesc_client_2fv1_2fchannel_5fid_2eproto();
-void protobuf_AssignDesc_client_2fv1_2fchannel_5fid_2eproto();
-void protobuf_ShutdownFile_client_2fv1_2fchannel_5fid_2eproto();
+void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto();
+void protobuf_AssignDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto();
+void protobuf_ShutdownFile_api_2fclient_2fv1_2fchannel_5fid_2eproto();
 
 class ChannelId;
 
@@ -134,9 +134,9 @@ class TC_PROTO_API ChannelId : public ::google::protobuf::Message {
   ::bgs::protocol::ProcessId* host_;
   ::google::protobuf::uint32 type_;
   ::google::protobuf::uint32 id_;
-  friend void TC_PROTO_API protobuf_AddDesc_client_2fv1_2fchannel_5fid_2eproto();
-  friend void protobuf_AssignDesc_client_2fv1_2fchannel_5fid_2eproto();
-  friend void protobuf_ShutdownFile_client_2fv1_2fchannel_5fid_2eproto();
+  friend void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto();
+  friend void protobuf_AssignDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto();
+  friend void protobuf_ShutdownFile_api_2fclient_2fv1_2fchannel_5fid_2eproto();
 
   void InitAsDefaultInstance();
   static ChannelId* default_instance_;
@@ -259,4 +259,4 @@ namespace protobuf {
 
 // @@protoc_insertion_point(global_scope)
 
-#endif  // PROTOBUF_client_2fv1_2fchannel_5fid_2eproto__INCLUDED
+#endif  // PROTOBUF_api_2fclient_2fv1_2fchannel_5fid_2eproto__INCLUDED
diff --git a/src/server/proto/Client/api/client/v2/attribute_types.pb.cc b/src/server/proto/Client/api/client/v2/attribute_types.pb.cc
new file mode 100644
index 00000000000..0137abf2da0
--- /dev/null
+++ b/src/server/proto/Client/api/client/v2/attribute_types.pb.cc
@@ -0,0 +1,1242 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: api/client/v2/attribute_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "api/client/v2/attribute_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace v2 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* Variant_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Variant_reflection_ = NULL;
+struct VariantOneofInstance {
+  bool bool_value_;
+  ::google::protobuf::int64 int_value_;
+  double float_value_;
+  const ::std::string* string_value_;
+  const ::std::string* blob_value_;
+  ::google::protobuf::uint64 uint_value_;
+}* Variant_default_oneof_instance_ = NULL;
+const ::google::protobuf::Descriptor* Attribute_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Attribute_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AttributeFilter_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AttributeFilter_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* AttributeFilter_Operation_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto() {
+  protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "api/client/v2/attribute_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  Variant_descriptor_ = file->message_type(0);
+  static const int Variant_offsets_[7] = {
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(Variant_default_oneof_instance_, bool_value_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(Variant_default_oneof_instance_, int_value_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(Variant_default_oneof_instance_, float_value_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(Variant_default_oneof_instance_, string_value_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(Variant_default_oneof_instance_, blob_value_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(Variant_default_oneof_instance_, uint_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, type_),
+  };
+  Variant_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Variant_descriptor_,
+      Variant::default_instance_,
+      Variant_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, _unknown_fields_),
+      -1,
+      Variant_default_oneof_instance_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, _oneof_case_[0]),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Variant));
+  Attribute_descriptor_ = file->message_type(1);
+  static const int Attribute_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, value_),
+  };
+  Attribute_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Attribute_descriptor_,
+      Attribute::default_instance_,
+      Attribute_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Attribute));
+  AttributeFilter_descriptor_ = file->message_type(2);
+  static const int AttributeFilter_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, op_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, attribute_),
+  };
+  AttributeFilter_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AttributeFilter_descriptor_,
+      AttributeFilter::default_instance_,
+      AttributeFilter_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AttributeFilter));
+  AttributeFilter_Operation_descriptor_ = AttributeFilter_descriptor_->enum_type(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Variant_descriptor_, &Variant::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Attribute_descriptor_, &Attribute::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AttributeFilter_descriptor_, &AttributeFilter::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_api_2fclient_2fv2_2fattribute_5ftypes_2eproto() {
+  delete Variant::default_instance_;
+  delete Variant_default_oneof_instance_;
+  delete Variant_reflection_;
+  delete Attribute::default_instance_;
+  delete Attribute_reflection_;
+  delete AttributeFilter::default_instance_;
+  delete AttributeFilter_reflection_;
+}
+
+void protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n#api/client/v2/attribute_types.proto\022\017b"
+    "gs.protocol.v2\"\227\001\n\007Variant\022\024\n\nbool_value"
+    "\030\001 \001(\010H\000\022\023\n\tint_value\030\002 \001(\003H\000\022\025\n\013float_v"
+    "alue\030\003 \001(\001H\000\022\026\n\014string_value\030\004 \001(\tH\000\022\024\n\n"
+    "blob_value\030\005 \001(\014H\000\022\024\n\nuint_value\030\006 \001(\004H\000"
+    "B\006\n\004type\"B\n\tAttribute\022\014\n\004name\030\001 \001(\t\022\'\n\005v"
+    "alue\030\002 \001(\0132\030.bgs.protocol.v2.Variant\"\320\001\n"
+    "\017AttributeFilter\0226\n\002op\030\001 \001(\0162*.bgs.proto"
+    "col.v2.AttributeFilter.Operation\022-\n\tattr"
+    "ibute\030\002 \003(\0132\032.bgs.protocol.v2.Attribute\""
+    "V\n\tOperation\022\016\n\nMATCH_NONE\020\000\022\r\n\tMATCH_AN"
+    "Y\020\001\022\r\n\tMATCH_ALL\020\002\022\033\n\027MATCH_ALL_MOST_SPE"
+    "CIFIC\020\003B\002H\001", 491);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "api/client/v2/attribute_types.proto", &protobuf_RegisterTypes);
+  Variant::default_instance_ = new Variant();
+  Variant_default_oneof_instance_ = new VariantOneofInstance;
+  Attribute::default_instance_ = new Attribute();
+  AttributeFilter::default_instance_ = new AttributeFilter();
+  Variant::default_instance_->InitAsDefaultInstance();
+  Attribute::default_instance_->InitAsDefaultInstance();
+  AttributeFilter::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_api_2fclient_2fv2_2fattribute_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_api_2fclient_2fv2_2fattribute_5ftypes_2eproto {
+  StaticDescriptorInitializer_api_2fclient_2fv2_2fattribute_5ftypes_2eproto() {
+    protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_api_2fclient_2fv2_2fattribute_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Variant::kBoolValueFieldNumber;
+const int Variant::kIntValueFieldNumber;
+const int Variant::kFloatValueFieldNumber;
+const int Variant::kStringValueFieldNumber;
+const int Variant::kBlobValueFieldNumber;
+const int Variant::kUintValueFieldNumber;
+#endif  // !_MSC_VER
+
+Variant::Variant()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.v2.Variant)
+}
+
+void Variant::InitAsDefaultInstance() {
+  Variant_default_oneof_instance_->bool_value_ = false;
+  Variant_default_oneof_instance_->int_value_ = GOOGLE_LONGLONG(0);
+  Variant_default_oneof_instance_->float_value_ = 0;
+  Variant_default_oneof_instance_->string_value_ = &::google::protobuf::internal::GetEmptyStringAlreadyInited();
+  Variant_default_oneof_instance_->blob_value_ = &::google::protobuf::internal::GetEmptyStringAlreadyInited();
+  Variant_default_oneof_instance_->uint_value_ = GOOGLE_ULONGLONG(0);
+}
+
+Variant::Variant(const Variant& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.v2.Variant)
+}
+
+void Variant::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  clear_has_type();
+}
+
+Variant::~Variant() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.v2.Variant)
+  SharedDtor();
+}
+
+void Variant::SharedDtor() {
+  if (has_type()) {
+    clear_type();
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void Variant::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Variant::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Variant_descriptor_;
+}
+
+const Variant& Variant::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Variant* Variant::default_instance_ = NULL;
+
+Variant* Variant::New() const {
+  return new Variant;
+}
+
+void Variant::clear_type() {
+  switch(type_case()) {
+    case kBoolValue: {
+      // No need to clear
+      break;
+    }
+    case kIntValue: {
+      // No need to clear
+      break;
+    }
+    case kFloatValue: {
+      // No need to clear
+      break;
+    }
+    case kStringValue: {
+      delete type_.string_value_;
+      break;
+    }
+    case kBlobValue: {
+      delete type_.blob_value_;
+      break;
+    }
+    case kUintValue: {
+      // No need to clear
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+
+
+void Variant::Clear() {
+  clear_type();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Variant::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.v2.Variant)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool bool_value = 1;
+      case 1: {
+        if (tag == 8) {
+          clear_type();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &type_.bool_value_)));
+          set_has_bool_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_int_value;
+        break;
+      }
+
+      // optional int64 int_value = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_int_value:
+          clear_type();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &type_.int_value_)));
+          set_has_int_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_float_value;
+        break;
+      }
+
+      // optional double float_value = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_float_value:
+          clear_type();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &type_.float_value_)));
+          set_has_float_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_string_value;
+        break;
+      }
+
+      // optional string string_value = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_string_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_string_value()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->string_value().data(), this->string_value().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "string_value");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_blob_value;
+        break;
+      }
+
+      // optional bytes blob_value = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_blob_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_blob_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_uint_value;
+        break;
+      }
+
+      // optional uint64 uint_value = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_uint_value:
+          clear_type();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &type_.uint_value_)));
+          set_has_uint_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.v2.Variant)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.v2.Variant)
+  return false;
+#undef DO_
+}
+
+void Variant::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.v2.Variant)
+  // optional bool bool_value = 1;
+  if (has_bool_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->bool_value(), output);
+  }
+
+  // optional int64 int_value = 2;
+  if (has_int_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->int_value(), output);
+  }
+
+  // optional double float_value = 3;
+  if (has_float_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->float_value(), output);
+  }
+
+  // optional string string_value = 4;
+  if (has_string_value()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->string_value().data(), this->string_value().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "string_value");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->string_value(), output);
+  }
+
+  // optional bytes blob_value = 5;
+  if (has_blob_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      5, this->blob_value(), output);
+  }
+
+  // optional uint64 uint_value = 6;
+  if (has_uint_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->uint_value(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.v2.Variant)
+}
+
+::google::protobuf::uint8* Variant::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.v2.Variant)
+  // optional bool bool_value = 1;
+  if (has_bool_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->bool_value(), target);
+  }
+
+  // optional int64 int_value = 2;
+  if (has_int_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->int_value(), target);
+  }
+
+  // optional double float_value = 3;
+  if (has_float_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->float_value(), target);
+  }
+
+  // optional string string_value = 4;
+  if (has_string_value()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->string_value().data(), this->string_value().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "string_value");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->string_value(), target);
+  }
+
+  // optional bytes blob_value = 5;
+  if (has_blob_value()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        5, this->blob_value(), target);
+  }
+
+  // optional uint64 uint_value = 6;
+  if (has_uint_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->uint_value(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.v2.Variant)
+  return target;
+}
+
+int Variant::ByteSize() const {
+  int total_size = 0;
+
+  switch (type_case()) {
+    // optional bool bool_value = 1;
+    case kBoolValue: {
+      total_size += 1 + 1;
+      break;
+    }
+    // optional int64 int_value = 2;
+    case kIntValue: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->int_value());
+      break;
+    }
+    // optional double float_value = 3;
+    case kFloatValue: {
+      total_size += 1 + 8;
+      break;
+    }
+    // optional string string_value = 4;
+    case kStringValue: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->string_value());
+      break;
+    }
+    // optional bytes blob_value = 5;
+    case kBlobValue: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->blob_value());
+      break;
+    }
+    // optional uint64 uint_value = 6;
+    case kUintValue: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->uint_value());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Variant::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Variant* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Variant*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Variant::MergeFrom(const Variant& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  switch (from.type_case()) {
+    case kBoolValue: {
+      set_bool_value(from.bool_value());
+      break;
+    }
+    case kIntValue: {
+      set_int_value(from.int_value());
+      break;
+    }
+    case kFloatValue: {
+      set_float_value(from.float_value());
+      break;
+    }
+    case kStringValue: {
+      set_string_value(from.string_value());
+      break;
+    }
+    case kBlobValue: {
+      set_blob_value(from.blob_value());
+      break;
+    }
+    case kUintValue: {
+      set_uint_value(from.uint_value());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Variant::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Variant::CopyFrom(const Variant& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Variant::IsInitialized() const {
+
+  return true;
+}
+
+void Variant::Swap(Variant* other) {
+  if (other != this) {
+    std::swap(type_, other->type_);
+    std::swap(_oneof_case_[0], other->_oneof_case_[0]);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Variant::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Variant_descriptor_;
+  metadata.reflection = Variant_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Attribute::kNameFieldNumber;
+const int Attribute::kValueFieldNumber;
+#endif  // !_MSC_VER
+
+Attribute::Attribute()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.v2.Attribute)
+}
+
+void Attribute::InitAsDefaultInstance() {
+  value_ = const_cast< ::bgs::protocol::v2::Variant*>(&::bgs::protocol::v2::Variant::default_instance());
+}
+
+Attribute::Attribute(const Attribute& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.v2.Attribute)
+}
+
+void Attribute::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  value_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Attribute::~Attribute() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.v2.Attribute)
+  SharedDtor();
+}
+
+void Attribute::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+    delete value_;
+  }
+}
+
+void Attribute::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Attribute::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Attribute_descriptor_;
+}
+
+const Attribute& Attribute::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Attribute* Attribute::default_instance_ = NULL;
+
+Attribute* Attribute::New() const {
+  return new Attribute;
+}
+
+void Attribute::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_value()) {
+      if (value_ != NULL) value_->::bgs::protocol::v2::Variant::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Attribute::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.v2.Attribute)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_value;
+        break;
+      }
+
+      // optional .bgs.protocol.v2.Variant value = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.v2.Attribute)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.v2.Attribute)
+  return false;
+#undef DO_
+}
+
+void Attribute::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.v2.Attribute)
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->name(), output);
+  }
+
+  // optional .bgs.protocol.v2.Variant value = 2;
+  if (has_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->value(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.v2.Attribute)
+}
+
+::google::protobuf::uint8* Attribute::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.v2.Attribute)
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->name(), target);
+  }
+
+  // optional .bgs.protocol.v2.Variant value = 2;
+  if (has_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->value(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.v2.Attribute)
+  return target;
+}
+
+int Attribute::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional .bgs.protocol.v2.Variant value = 2;
+    if (has_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->value());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Attribute::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Attribute* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Attribute*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Attribute::MergeFrom(const Attribute& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_value()) {
+      mutable_value()->::bgs::protocol::v2::Variant::MergeFrom(from.value());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Attribute::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Attribute::CopyFrom(const Attribute& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Attribute::IsInitialized() const {
+
+  return true;
+}
+
+void Attribute::Swap(Attribute* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(value_, other->value_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Attribute::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Attribute_descriptor_;
+  metadata.reflection = Attribute_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+const ::google::protobuf::EnumDescriptor* AttributeFilter_Operation_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AttributeFilter_Operation_descriptor_;
+}
+bool AttributeFilter_Operation_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const AttributeFilter_Operation AttributeFilter::MATCH_NONE;
+const AttributeFilter_Operation AttributeFilter::MATCH_ANY;
+const AttributeFilter_Operation AttributeFilter::MATCH_ALL;
+const AttributeFilter_Operation AttributeFilter::MATCH_ALL_MOST_SPECIFIC;
+const AttributeFilter_Operation AttributeFilter::Operation_MIN;
+const AttributeFilter_Operation AttributeFilter::Operation_MAX;
+const int AttributeFilter::Operation_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int AttributeFilter::kOpFieldNumber;
+const int AttributeFilter::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+AttributeFilter::AttributeFilter()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.v2.AttributeFilter)
+}
+
+void AttributeFilter::InitAsDefaultInstance() {
+}
+
+AttributeFilter::AttributeFilter(const AttributeFilter& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.v2.AttributeFilter)
+}
+
+void AttributeFilter::SharedCtor() {
+  _cached_size_ = 0;
+  op_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AttributeFilter::~AttributeFilter() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.v2.AttributeFilter)
+  SharedDtor();
+}
+
+void AttributeFilter::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AttributeFilter::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AttributeFilter::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AttributeFilter_descriptor_;
+}
+
+const AttributeFilter& AttributeFilter::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AttributeFilter* AttributeFilter::default_instance_ = NULL;
+
+AttributeFilter* AttributeFilter::New() const {
+  return new AttributeFilter;
+}
+
+void AttributeFilter::Clear() {
+  op_ = 0;
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AttributeFilter::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.v2.AttributeFilter)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.v2.AttributeFilter.Operation op = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::v2::AttributeFilter_Operation_IsValid(value)) {
+            set_op(static_cast< ::bgs::protocol::v2::AttributeFilter_Operation >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.v2.AttributeFilter)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.v2.AttributeFilter)
+  return false;
+#undef DO_
+}
+
+void AttributeFilter::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.v2.AttributeFilter)
+  // optional .bgs.protocol.v2.AttributeFilter.Operation op = 1;
+  if (has_op()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->op(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.v2.AttributeFilter)
+}
+
+::google::protobuf::uint8* AttributeFilter::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.v2.AttributeFilter)
+  // optional .bgs.protocol.v2.AttributeFilter.Operation op = 1;
+  if (has_op()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->op(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.v2.AttributeFilter)
+  return target;
+}
+
+int AttributeFilter::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.v2.AttributeFilter.Operation op = 1;
+    if (has_op()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->op());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AttributeFilter::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AttributeFilter* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AttributeFilter*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AttributeFilter::MergeFrom(const AttributeFilter& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_op()) {
+      set_op(from.op());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AttributeFilter::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AttributeFilter::CopyFrom(const AttributeFilter& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AttributeFilter::IsInitialized() const {
+
+  return true;
+}
+
+void AttributeFilter::Swap(AttributeFilter* other) {
+  if (other != this) {
+    std::swap(op_, other->op_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AttributeFilter::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AttributeFilter_descriptor_;
+  metadata.reflection = AttributeFilter_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v2
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/api/client/v2/attribute_types.pb.h b/src/server/proto/Client/api/client/v2/attribute_types.pb.h
new file mode 100644
index 00000000000..76c85d631a0
--- /dev/null
+++ b/src/server/proto/Client/api/client/v2/attribute_types.pb.h
@@ -0,0 +1,901 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: api/client/v2/attribute_types.proto
+
+#ifndef PROTOBUF_api_2fclient_2fv2_2fattribute_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_api_2fclient_2fv2_2fattribute_5ftypes_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace v2 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+void protobuf_AssignDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+void protobuf_ShutdownFile_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+
+class Variant;
+class Attribute;
+class AttributeFilter;
+
+enum AttributeFilter_Operation {
+  AttributeFilter_Operation_MATCH_NONE = 0,
+  AttributeFilter_Operation_MATCH_ANY = 1,
+  AttributeFilter_Operation_MATCH_ALL = 2,
+  AttributeFilter_Operation_MATCH_ALL_MOST_SPECIFIC = 3
+};
+TC_PROTO_API bool AttributeFilter_Operation_IsValid(int value);
+const AttributeFilter_Operation AttributeFilter_Operation_Operation_MIN = AttributeFilter_Operation_MATCH_NONE;
+const AttributeFilter_Operation AttributeFilter_Operation_Operation_MAX = AttributeFilter_Operation_MATCH_ALL_MOST_SPECIFIC;
+const int AttributeFilter_Operation_Operation_ARRAYSIZE = AttributeFilter_Operation_Operation_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* AttributeFilter_Operation_descriptor();
+inline const ::std::string& AttributeFilter_Operation_Name(AttributeFilter_Operation value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    AttributeFilter_Operation_descriptor(), value);
+}
+inline bool AttributeFilter_Operation_Parse(
+    const ::std::string& name, AttributeFilter_Operation* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<AttributeFilter_Operation>(
+    AttributeFilter_Operation_descriptor(), name, value);
+}
+// ===================================================================
+
+class TC_PROTO_API Variant : public ::google::protobuf::Message {
+ public:
+  Variant();
+  virtual ~Variant();
+
+  Variant(const Variant& from);
+
+  inline Variant& operator=(const Variant& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Variant& default_instance();
+
+  enum TypeCase {
+    kBoolValue = 1,
+    kIntValue = 2,
+    kFloatValue = 3,
+    kStringValue = 4,
+    kBlobValue = 5,
+    kUintValue = 6,
+    TYPE_NOT_SET = 0,
+  };
+
+  void Swap(Variant* other);
+
+  // implements Message ----------------------------------------------
+
+  Variant* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Variant& from);
+  void MergeFrom(const Variant& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bool bool_value = 1;
+  inline bool has_bool_value() const;
+  inline void clear_bool_value();
+  static const int kBoolValueFieldNumber = 1;
+  inline bool bool_value() const;
+  inline void set_bool_value(bool value);
+
+  // optional int64 int_value = 2;
+  inline bool has_int_value() const;
+  inline void clear_int_value();
+  static const int kIntValueFieldNumber = 2;
+  inline ::google::protobuf::int64 int_value() const;
+  inline void set_int_value(::google::protobuf::int64 value);
+
+  // optional double float_value = 3;
+  inline bool has_float_value() const;
+  inline void clear_float_value();
+  static const int kFloatValueFieldNumber = 3;
+  inline double float_value() const;
+  inline void set_float_value(double value);
+
+  // optional string string_value = 4;
+  inline bool has_string_value() const;
+  inline void clear_string_value();
+  static const int kStringValueFieldNumber = 4;
+  inline const ::std::string& string_value() const;
+  inline void set_string_value(const ::std::string& value);
+  inline void set_string_value(const char* value);
+  inline void set_string_value(const char* value, size_t size);
+  inline ::std::string* mutable_string_value();
+  inline ::std::string* release_string_value();
+  inline void set_allocated_string_value(::std::string* string_value);
+
+  // optional bytes blob_value = 5;
+  inline bool has_blob_value() const;
+  inline void clear_blob_value();
+  static const int kBlobValueFieldNumber = 5;
+  inline const ::std::string& blob_value() const;
+  inline void set_blob_value(const ::std::string& value);
+  inline void set_blob_value(const char* value);
+  inline void set_blob_value(const void* value, size_t size);
+  inline ::std::string* mutable_blob_value();
+  inline ::std::string* release_blob_value();
+  inline void set_allocated_blob_value(::std::string* blob_value);
+
+  // optional uint64 uint_value = 6;
+  inline bool has_uint_value() const;
+  inline void clear_uint_value();
+  static const int kUintValueFieldNumber = 6;
+  inline ::google::protobuf::uint64 uint_value() const;
+  inline void set_uint_value(::google::protobuf::uint64 value);
+
+  inline TypeCase type_case() const;
+  // @@protoc_insertion_point(class_scope:bgs.protocol.v2.Variant)
+ private:
+  inline void set_has_bool_value();
+  inline void set_has_int_value();
+  inline void set_has_float_value();
+  inline void set_has_string_value();
+  inline void set_has_blob_value();
+  inline void set_has_uint_value();
+
+  inline bool has_type();
+  void clear_type();
+  inline void clear_has_type();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  union TypeUnion {
+    bool bool_value_;
+    ::google::protobuf::int64 int_value_;
+    double float_value_;
+    ::std::string* string_value_;
+    ::std::string* blob_value_;
+    ::google::protobuf::uint64 uint_value_;
+  } type_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Variant* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API Attribute : public ::google::protobuf::Message {
+ public:
+  Attribute();
+  virtual ~Attribute();
+
+  Attribute(const Attribute& from);
+
+  inline Attribute& operator=(const Attribute& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Attribute& default_instance();
+
+  void Swap(Attribute* other);
+
+  // implements Message ----------------------------------------------
+
+  Attribute* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Attribute& from);
+  void MergeFrom(const Attribute& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional .bgs.protocol.v2.Variant value = 2;
+  inline bool has_value() const;
+  inline void clear_value();
+  static const int kValueFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Variant& value() const;
+  inline ::bgs::protocol::v2::Variant* mutable_value();
+  inline ::bgs::protocol::v2::Variant* release_value();
+  inline void set_allocated_value(::bgs::protocol::v2::Variant* value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.v2.Attribute)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_value();
+  inline void clear_has_value();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  ::bgs::protocol::v2::Variant* value_;
+  friend void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Attribute* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AttributeFilter : public ::google::protobuf::Message {
+ public:
+  AttributeFilter();
+  virtual ~AttributeFilter();
+
+  AttributeFilter(const AttributeFilter& from);
+
+  inline AttributeFilter& operator=(const AttributeFilter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AttributeFilter& default_instance();
+
+  void Swap(AttributeFilter* other);
+
+  // implements Message ----------------------------------------------
+
+  AttributeFilter* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AttributeFilter& from);
+  void MergeFrom(const AttributeFilter& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef AttributeFilter_Operation Operation;
+  static const Operation MATCH_NONE = AttributeFilter_Operation_MATCH_NONE;
+  static const Operation MATCH_ANY = AttributeFilter_Operation_MATCH_ANY;
+  static const Operation MATCH_ALL = AttributeFilter_Operation_MATCH_ALL;
+  static const Operation MATCH_ALL_MOST_SPECIFIC = AttributeFilter_Operation_MATCH_ALL_MOST_SPECIFIC;
+  static inline bool Operation_IsValid(int value) {
+    return AttributeFilter_Operation_IsValid(value);
+  }
+  static const Operation Operation_MIN =
+    AttributeFilter_Operation_Operation_MIN;
+  static const Operation Operation_MAX =
+    AttributeFilter_Operation_Operation_MAX;
+  static const int Operation_ARRAYSIZE =
+    AttributeFilter_Operation_Operation_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  Operation_descriptor() {
+    return AttributeFilter_Operation_descriptor();
+  }
+  static inline const ::std::string& Operation_Name(Operation value) {
+    return AttributeFilter_Operation_Name(value);
+  }
+  static inline bool Operation_Parse(const ::std::string& name,
+      Operation* value) {
+    return AttributeFilter_Operation_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.v2.AttributeFilter.Operation op = 1;
+  inline bool has_op() const;
+  inline void clear_op();
+  static const int kOpFieldNumber = 1;
+  inline ::bgs::protocol::v2::AttributeFilter_Operation op() const;
+  inline void set_op(::bgs::protocol::v2::AttributeFilter_Operation value);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.v2.AttributeFilter)
+ private:
+  inline void set_has_op();
+  inline void clear_has_op();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  int op_;
+  friend void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AttributeFilter* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// Variant
+
+// optional bool bool_value = 1;
+inline bool Variant::has_bool_value() const {
+  return type_case() == kBoolValue;
+}
+inline void Variant::set_has_bool_value() {
+  _oneof_case_[0] = kBoolValue;
+}
+inline void Variant::clear_bool_value() {
+  if (has_bool_value()) {
+    type_.bool_value_ = false;
+    clear_has_type();
+  }
+}
+inline bool Variant::bool_value() const {
+  if (has_bool_value()) {
+    return type_.bool_value_;
+  }
+  return false;
+}
+inline void Variant::set_bool_value(bool value) {
+  if (!has_bool_value()) {
+    clear_type();
+    set_has_bool_value();
+  }
+  type_.bool_value_ = value;
+}
+
+// optional int64 int_value = 2;
+inline bool Variant::has_int_value() const {
+  return type_case() == kIntValue;
+}
+inline void Variant::set_has_int_value() {
+  _oneof_case_[0] = kIntValue;
+}
+inline void Variant::clear_int_value() {
+  if (has_int_value()) {
+    type_.int_value_ = GOOGLE_LONGLONG(0);
+    clear_has_type();
+  }
+}
+inline ::google::protobuf::int64 Variant::int_value() const {
+  if (has_int_value()) {
+    return type_.int_value_;
+  }
+  return GOOGLE_LONGLONG(0);
+}
+inline void Variant::set_int_value(::google::protobuf::int64 value) {
+  if (!has_int_value()) {
+    clear_type();
+    set_has_int_value();
+  }
+  type_.int_value_ = value;
+}
+
+// optional double float_value = 3;
+inline bool Variant::has_float_value() const {
+  return type_case() == kFloatValue;
+}
+inline void Variant::set_has_float_value() {
+  _oneof_case_[0] = kFloatValue;
+}
+inline void Variant::clear_float_value() {
+  if (has_float_value()) {
+    type_.float_value_ = 0;
+    clear_has_type();
+  }
+}
+inline double Variant::float_value() const {
+  if (has_float_value()) {
+    return type_.float_value_;
+  }
+  return 0;
+}
+inline void Variant::set_float_value(double value) {
+  if (!has_float_value()) {
+    clear_type();
+    set_has_float_value();
+  }
+  type_.float_value_ = value;
+}
+
+// optional string string_value = 4;
+inline bool Variant::has_string_value() const {
+  return type_case() == kStringValue;
+}
+inline void Variant::set_has_string_value() {
+  _oneof_case_[0] = kStringValue;
+}
+inline void Variant::clear_string_value() {
+  if (has_string_value()) {
+    delete type_.string_value_;
+    clear_has_type();
+  }
+}
+inline const ::std::string& Variant::string_value() const {
+  if (has_string_value()) {
+    return *type_.string_value_;
+  }
+  return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
+}
+inline void Variant::set_string_value(const ::std::string& value) {
+  if (!has_string_value()) {
+    clear_type();
+    set_has_string_value();
+    type_.string_value_ = new ::std::string;
+  }
+  type_.string_value_->assign(value);
+}
+inline void Variant::set_string_value(const char* value) {
+  if (!has_string_value()) {
+    clear_type();
+    set_has_string_value();
+    type_.string_value_ = new ::std::string;
+  }
+  type_.string_value_->assign(value);
+}
+inline void Variant::set_string_value(const char* value, size_t size) {
+  if (!has_string_value()) {
+    clear_type();
+    set_has_string_value();
+    type_.string_value_ = new ::std::string;
+  }
+  type_.string_value_->assign(
+      reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* Variant::mutable_string_value() {
+  if (!has_string_value()) {
+    clear_type();
+    set_has_string_value();
+    type_.string_value_ = new ::std::string;
+  }
+  return type_.string_value_;
+}
+inline ::std::string* Variant::release_string_value() {
+  if (has_string_value()) {
+    clear_has_type();
+    ::std::string* temp = type_.string_value_;
+    type_.string_value_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void Variant::set_allocated_string_value(::std::string* string_value) {
+  clear_type();
+  if (string_value) {
+    set_has_string_value();
+    type_.string_value_ = string_value;
+  }
+}
+
+// optional bytes blob_value = 5;
+inline bool Variant::has_blob_value() const {
+  return type_case() == kBlobValue;
+}
+inline void Variant::set_has_blob_value() {
+  _oneof_case_[0] = kBlobValue;
+}
+inline void Variant::clear_blob_value() {
+  if (has_blob_value()) {
+    delete type_.blob_value_;
+    clear_has_type();
+  }
+}
+inline const ::std::string& Variant::blob_value() const {
+  if (has_blob_value()) {
+    return *type_.blob_value_;
+  }
+  return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
+}
+inline void Variant::set_blob_value(const ::std::string& value) {
+  if (!has_blob_value()) {
+    clear_type();
+    set_has_blob_value();
+    type_.blob_value_ = new ::std::string;
+  }
+  type_.blob_value_->assign(value);
+}
+inline void Variant::set_blob_value(const char* value) {
+  if (!has_blob_value()) {
+    clear_type();
+    set_has_blob_value();
+    type_.blob_value_ = new ::std::string;
+  }
+  type_.blob_value_->assign(value);
+}
+inline void Variant::set_blob_value(const void* value, size_t size) {
+  if (!has_blob_value()) {
+    clear_type();
+    set_has_blob_value();
+    type_.blob_value_ = new ::std::string;
+  }
+  type_.blob_value_->assign(
+      reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* Variant::mutable_blob_value() {
+  if (!has_blob_value()) {
+    clear_type();
+    set_has_blob_value();
+    type_.blob_value_ = new ::std::string;
+  }
+  return type_.blob_value_;
+}
+inline ::std::string* Variant::release_blob_value() {
+  if (has_blob_value()) {
+    clear_has_type();
+    ::std::string* temp = type_.blob_value_;
+    type_.blob_value_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void Variant::set_allocated_blob_value(::std::string* blob_value) {
+  clear_type();
+  if (blob_value) {
+    set_has_blob_value();
+    type_.blob_value_ = blob_value;
+  }
+}
+
+// optional uint64 uint_value = 6;
+inline bool Variant::has_uint_value() const {
+  return type_case() == kUintValue;
+}
+inline void Variant::set_has_uint_value() {
+  _oneof_case_[0] = kUintValue;
+}
+inline void Variant::clear_uint_value() {
+  if (has_uint_value()) {
+    type_.uint_value_ = GOOGLE_ULONGLONG(0);
+    clear_has_type();
+  }
+}
+inline ::google::protobuf::uint64 Variant::uint_value() const {
+  if (has_uint_value()) {
+    return type_.uint_value_;
+  }
+  return GOOGLE_ULONGLONG(0);
+}
+inline void Variant::set_uint_value(::google::protobuf::uint64 value) {
+  if (!has_uint_value()) {
+    clear_type();
+    set_has_uint_value();
+  }
+  type_.uint_value_ = value;
+}
+
+inline bool Variant::has_type() {
+  return type_case() != TYPE_NOT_SET;
+}
+inline void Variant::clear_has_type() {
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+inline Variant::TypeCase Variant::type_case() const {
+  return Variant::TypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Attribute
+
+// optional string name = 1;
+inline bool Attribute::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Attribute::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Attribute::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Attribute::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& Attribute::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.v2.Attribute.name)
+  return *name_;
+}
+inline void Attribute::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.v2.Attribute.name)
+}
+inline void Attribute::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.v2.Attribute.name)
+}
+inline void Attribute::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.v2.Attribute.name)
+}
+inline ::std::string* Attribute::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.v2.Attribute.name)
+  return name_;
+}
+inline ::std::string* Attribute::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Attribute::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.v2.Attribute.name)
+}
+
+// optional .bgs.protocol.v2.Variant value = 2;
+inline bool Attribute::has_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Attribute::set_has_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Attribute::clear_has_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Attribute::clear_value() {
+  if (value_ != NULL) value_->::bgs::protocol::v2::Variant::Clear();
+  clear_has_value();
+}
+inline const ::bgs::protocol::v2::Variant& Attribute::value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.v2.Attribute.value)
+  return value_ != NULL ? *value_ : *default_instance_->value_;
+}
+inline ::bgs::protocol::v2::Variant* Attribute::mutable_value() {
+  set_has_value();
+  if (value_ == NULL) value_ = new ::bgs::protocol::v2::Variant;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.v2.Attribute.value)
+  return value_;
+}
+inline ::bgs::protocol::v2::Variant* Attribute::release_value() {
+  clear_has_value();
+  ::bgs::protocol::v2::Variant* temp = value_;
+  value_ = NULL;
+  return temp;
+}
+inline void Attribute::set_allocated_value(::bgs::protocol::v2::Variant* value) {
+  delete value_;
+  value_ = value;
+  if (value) {
+    set_has_value();
+  } else {
+    clear_has_value();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.v2.Attribute.value)
+}
+
+// -------------------------------------------------------------------
+
+// AttributeFilter
+
+// optional .bgs.protocol.v2.AttributeFilter.Operation op = 1;
+inline bool AttributeFilter::has_op() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AttributeFilter::set_has_op() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AttributeFilter::clear_has_op() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AttributeFilter::clear_op() {
+  op_ = 0;
+  clear_has_op();
+}
+inline ::bgs::protocol::v2::AttributeFilter_Operation AttributeFilter::op() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.v2.AttributeFilter.op)
+  return static_cast< ::bgs::protocol::v2::AttributeFilter_Operation >(op_);
+}
+inline void AttributeFilter::set_op(::bgs::protocol::v2::AttributeFilter_Operation value) {
+  assert(::bgs::protocol::v2::AttributeFilter_Operation_IsValid(value));
+  set_has_op();
+  op_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.v2.AttributeFilter.op)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 2;
+inline int AttributeFilter::attribute_size() const {
+  return attribute_.size();
+}
+inline void AttributeFilter::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& AttributeFilter::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.v2.AttributeFilter.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* AttributeFilter::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.v2.AttributeFilter.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* AttributeFilter::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.v2.AttributeFilter.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+AttributeFilter::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.v2.AttributeFilter.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+AttributeFilter::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.v2.AttributeFilter.attribute)
+  return &attribute_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v2
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::v2::AttributeFilter_Operation> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::v2::AttributeFilter_Operation>() {
+  return ::bgs::protocol::v2::AttributeFilter_Operation_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_api_2fclient_2fv2_2fattribute_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/api/client/v2/report_service.pb.cc b/src/server/proto/Client/api/client/v2/report_service.pb.cc
new file mode 100644
index 00000000000..6b4341f2c92
--- /dev/null
+++ b/src/server/proto/Client/api/client/v2/report_service.pb.cc
@@ -0,0 +1,654 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: api/client/v2/report_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "api/client/v2/report_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "Errors.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace report {
+namespace v2 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* SubmitReportRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubmitReportRequest_reflection_ = NULL;
+struct SubmitReportRequestOneofInstance {
+  const ::bgs::protocol::report::v2::UserOptions* user_options_;
+  const ::bgs::protocol::report::v2::ClubOptions* club_options_;
+}* SubmitReportRequest_default_oneof_instance_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ReportService_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_api_2fclient_2fv2_2freport_5fservice_2eproto() {
+  protobuf_AddDesc_api_2fclient_2fv2_2freport_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "api/client/v2/report_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  SubmitReportRequest_descriptor_ = file->message_type(0);
+  static const int SubmitReportRequest_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, user_description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, program_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(SubmitReportRequest_default_oneof_instance_, user_options_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(SubmitReportRequest_default_oneof_instance_, club_options_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, type_),
+  };
+  SubmitReportRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubmitReportRequest_descriptor_,
+      SubmitReportRequest::default_instance_,
+      SubmitReportRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, _unknown_fields_),
+      -1,
+      SubmitReportRequest_default_oneof_instance_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, _oneof_case_[0]),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubmitReportRequest));
+  ReportService_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_api_2fclient_2fv2_2freport_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubmitReportRequest_descriptor_, &SubmitReportRequest::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5fservice_2eproto() {
+  delete SubmitReportRequest::default_instance_;
+  delete SubmitReportRequest_default_oneof_instance_;
+  delete SubmitReportRequest_reflection_;
+}
+
+void protobuf_AddDesc_api_2fclient_2fv2_2freport_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
+  ::bgs::protocol::report::v2::protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\"api/client/v2/report_service.proto\022\026bg"
+    "s.protocol.report.v2\032\023account_types.prot"
+    "o\032 api/client/v2/report_types.proto\032\017rpc"
+    "_types.proto\"\370\001\n\023SubmitReportRequest\0224\n\010"
+    "agent_id\030\001 \001(\0132\".bgs.protocol.account.v1"
+    ".AccountId\022\030\n\020user_description\030\002 \001(\t\022\017\n\007"
+    "program\030\003 \001(\r\022;\n\014user_options\030\n \001(\0132#.bg"
+    "s.protocol.report.v2.UserOptionsH\000\022;\n\014cl"
+    "ub_options\030\013 \001(\0132#.bgs.protocol.report.v"
+    "2.ClubOptionsH\000B\006\n\004type2\245\001\n\rReportServic"
+    "e\022Y\n\014SubmitReport\022+.bgs.protocol.report."
+    "v2.SubmitReportRequest\032\024.bgs.protocol.No"
+    "Data\"\006\202\371+\002\010\001\0329\202\371+/\n%bnet.protocol.report"
+    ".v2.ReportService*\006report\212\371+\002\020\001B\005H\001\200\001\000", 558);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "api/client/v2/report_service.proto", &protobuf_RegisterTypes);
+  SubmitReportRequest::default_instance_ = new SubmitReportRequest();
+  SubmitReportRequest_default_oneof_instance_ = new SubmitReportRequestOneofInstance;
+  SubmitReportRequest::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_api_2fclient_2fv2_2freport_5fservice_2eproto {
+  StaticDescriptorInitializer_api_2fclient_2fv2_2freport_5fservice_2eproto() {
+    protobuf_AddDesc_api_2fclient_2fv2_2freport_5fservice_2eproto();
+  }
+} static_descriptor_initializer_api_2fclient_2fv2_2freport_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubmitReportRequest::kAgentIdFieldNumber;
+const int SubmitReportRequest::kUserDescriptionFieldNumber;
+const int SubmitReportRequest::kProgramFieldNumber;
+const int SubmitReportRequest::kUserOptionsFieldNumber;
+const int SubmitReportRequest::kClubOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+SubmitReportRequest::SubmitReportRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.report.v2.SubmitReportRequest)
+}
+
+void SubmitReportRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  SubmitReportRequest_default_oneof_instance_->user_options_ = const_cast< ::bgs::protocol::report::v2::UserOptions*>(&::bgs::protocol::report::v2::UserOptions::default_instance());
+  SubmitReportRequest_default_oneof_instance_->club_options_ = const_cast< ::bgs::protocol::report::v2::ClubOptions*>(&::bgs::protocol::report::v2::ClubOptions::default_instance());
+}
+
+SubmitReportRequest::SubmitReportRequest(const SubmitReportRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.report.v2.SubmitReportRequest)
+}
+
+void SubmitReportRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  user_description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  clear_has_type();
+}
+
+SubmitReportRequest::~SubmitReportRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.report.v2.SubmitReportRequest)
+  SharedDtor();
+}
+
+void SubmitReportRequest::SharedDtor() {
+  if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete user_description_;
+  }
+  if (has_type()) {
+    clear_type();
+  }
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SubmitReportRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubmitReportRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubmitReportRequest_descriptor_;
+}
+
+const SubmitReportRequest& SubmitReportRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_api_2fclient_2fv2_2freport_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubmitReportRequest* SubmitReportRequest::default_instance_ = NULL;
+
+SubmitReportRequest* SubmitReportRequest::New() const {
+  return new SubmitReportRequest;
+}
+
+void SubmitReportRequest::clear_type() {
+  switch(type_case()) {
+    case kUserOptions: {
+      delete type_.user_options_;
+      break;
+    }
+    case kClubOptions: {
+      delete type_.club_options_;
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+
+
+void SubmitReportRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_user_description()) {
+      if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        user_description_->clear();
+      }
+    }
+    program_ = 0u;
+  }
+  clear_type();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubmitReportRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.report.v2.SubmitReportRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_user_description;
+        break;
+      }
+
+      // optional string user_description = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_user_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_user_description()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->user_description().data(), this->user_description().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "user_description");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_program;
+        break;
+      }
+
+      // optional uint32 program = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_user_options;
+        break;
+      }
+
+      // optional .bgs.protocol.report.v2.UserOptions user_options = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_user_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_user_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(90)) goto parse_club_options;
+        break;
+      }
+
+      // optional .bgs.protocol.report.v2.ClubOptions club_options = 11;
+      case 11: {
+        if (tag == 90) {
+         parse_club_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_club_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.report.v2.SubmitReportRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.report.v2.SubmitReportRequest)
+  return false;
+#undef DO_
+}
+
+void SubmitReportRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.report.v2.SubmitReportRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional string user_description = 2;
+  if (has_user_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->user_description().data(), this->user_description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "user_description");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->user_description(), output);
+  }
+
+  // optional uint32 program = 3;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->program(), output);
+  }
+
+  // optional .bgs.protocol.report.v2.UserOptions user_options = 10;
+  if (has_user_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->user_options(), output);
+  }
+
+  // optional .bgs.protocol.report.v2.ClubOptions club_options = 11;
+  if (has_club_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      11, this->club_options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.report.v2.SubmitReportRequest)
+}
+
+::google::protobuf::uint8* SubmitReportRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.report.v2.SubmitReportRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional string user_description = 2;
+  if (has_user_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->user_description().data(), this->user_description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "user_description");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->user_description(), target);
+  }
+
+  // optional uint32 program = 3;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->program(), target);
+  }
+
+  // optional .bgs.protocol.report.v2.UserOptions user_options = 10;
+  if (has_user_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->user_options(), target);
+  }
+
+  // optional .bgs.protocol.report.v2.ClubOptions club_options = 11;
+  if (has_club_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        11, this->club_options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.report.v2.SubmitReportRequest)
+  return target;
+}
+
+int SubmitReportRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional string user_description = 2;
+    if (has_user_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->user_description());
+    }
+
+    // optional uint32 program = 3;
+    if (has_program()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->program());
+    }
+
+  }
+  switch (type_case()) {
+    // optional .bgs.protocol.report.v2.UserOptions user_options = 10;
+    case kUserOptions: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->user_options());
+      break;
+    }
+    // optional .bgs.protocol.report.v2.ClubOptions club_options = 11;
+    case kClubOptions: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->club_options());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubmitReportRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubmitReportRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubmitReportRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubmitReportRequest::MergeFrom(const SubmitReportRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  switch (from.type_case()) {
+    case kUserOptions: {
+      mutable_user_options()->::bgs::protocol::report::v2::UserOptions::MergeFrom(from.user_options());
+      break;
+    }
+    case kClubOptions: {
+      mutable_club_options()->::bgs::protocol::report::v2::ClubOptions::MergeFrom(from.club_options());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+    if (from.has_user_description()) {
+      set_user_description(from.user_description());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubmitReportRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubmitReportRequest::CopyFrom(const SubmitReportRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubmitReportRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_user_options()) {
+    if (!this->user_options().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubmitReportRequest::Swap(SubmitReportRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(user_description_, other->user_description_);
+    std::swap(program_, other->program_);
+    std::swap(type_, other->type_);
+    std::swap(_oneof_case_[0], other->_oneof_case_[0]);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubmitReportRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubmitReportRequest_descriptor_;
+  metadata.reflection = SubmitReportRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+ReportService::ReportService(bool use_original_hash) : service_hash_(use_original_hash ? OriginalHash::value : NameHash::value) {
+}
+
+ReportService::~ReportService() {
+}
+
+google::protobuf::ServiceDescriptor const* ReportService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ReportService_descriptor_;
+}
+
+void ReportService::SubmitReport(::bgs::protocol::report::v2::SubmitReportRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ReportService.SubmitReport(bgs.protocol.report.v2.SubmitReportRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      responseCallback(&response);
+  };
+  SendRequest(service_hash_, 1, request, std::move(callback));
+}
+
+void ReportService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::report::v2::SubmitReportRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ReportService.SubmitReport server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ReportService.SubmitReport(bgs.protocol.report.v2.SubmitReportRequest{ %s }).",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
+      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
+      {
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
+        ReportService* self = static_cast<ReportService*>(service);
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ReportService.SubmitReport() returned bgs.protocol.NoData{ %s } status %u.",
+          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
+        if (!status)
+          self->SendResponse(self->service_hash_, 1, token, response);
+        else
+          self->SendResponse(self->service_hash_, 1, token, status);
+      };
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleSubmitReport(&request, &response, continuation);
+      if (continuation)
+        continuation(this, status, &response);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ReportService::HandleSubmitReport(::bgs::protocol::report::v2::SubmitReportRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ReportService.SubmitReport({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v2
+}  // namespace report
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/api/client/v2/report_service.pb.h b/src/server/proto/Client/api/client/v2/report_service.pb.h
new file mode 100644
index 00000000000..fb033acc335
--- /dev/null
+++ b/src/server/proto/Client/api/client/v2/report_service.pb.h
@@ -0,0 +1,483 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: api/client/v2/report_service.proto
+
+#ifndef PROTOBUF_api_2fclient_2fv2_2freport_5fservice_2eproto__INCLUDED
+#define PROTOBUF_api_2fclient_2fv2_2freport_5fservice_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "account_types.pb.h"
+#include "api/client/v2/report_types.pb.h"
+#include "rpc_types.pb.h"
+#include "ServiceBase.h"
+#include "MessageBuffer.h"
+#include <functional>
+#include <type_traits>
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace report {
+namespace v2 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2freport_5fservice_2eproto();
+void protobuf_AssignDesc_api_2fclient_2fv2_2freport_5fservice_2eproto();
+void protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5fservice_2eproto();
+
+class SubmitReportRequest;
+
+// ===================================================================
+
+class TC_PROTO_API SubmitReportRequest : public ::google::protobuf::Message {
+ public:
+  SubmitReportRequest();
+  virtual ~SubmitReportRequest();
+
+  SubmitReportRequest(const SubmitReportRequest& from);
+
+  inline SubmitReportRequest& operator=(const SubmitReportRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubmitReportRequest& default_instance();
+
+  enum TypeCase {
+    kUserOptions = 10,
+    kClubOptions = 11,
+    TYPE_NOT_SET = 0,
+  };
+
+  void Swap(SubmitReportRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SubmitReportRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubmitReportRequest& from);
+  void MergeFrom(const SubmitReportRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // optional string user_description = 2;
+  inline bool has_user_description() const;
+  inline void clear_user_description();
+  static const int kUserDescriptionFieldNumber = 2;
+  inline const ::std::string& user_description() const;
+  inline void set_user_description(const ::std::string& value);
+  inline void set_user_description(const char* value);
+  inline void set_user_description(const char* value, size_t size);
+  inline ::std::string* mutable_user_description();
+  inline ::std::string* release_user_description();
+  inline void set_allocated_user_description(::std::string* user_description);
+
+  // optional uint32 program = 3;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 3;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.report.v2.UserOptions user_options = 10;
+  inline bool has_user_options() const;
+  inline void clear_user_options();
+  static const int kUserOptionsFieldNumber = 10;
+  inline const ::bgs::protocol::report::v2::UserOptions& user_options() const;
+  inline ::bgs::protocol::report::v2::UserOptions* mutable_user_options();
+  inline ::bgs::protocol::report::v2::UserOptions* release_user_options();
+  inline void set_allocated_user_options(::bgs::protocol::report::v2::UserOptions* user_options);
+
+  // optional .bgs.protocol.report.v2.ClubOptions club_options = 11;
+  inline bool has_club_options() const;
+  inline void clear_club_options();
+  static const int kClubOptionsFieldNumber = 11;
+  inline const ::bgs::protocol::report::v2::ClubOptions& club_options() const;
+  inline ::bgs::protocol::report::v2::ClubOptions* mutable_club_options();
+  inline ::bgs::protocol::report::v2::ClubOptions* release_club_options();
+  inline void set_allocated_club_options(::bgs::protocol::report::v2::ClubOptions* club_options);
+
+  inline TypeCase type_case() const;
+  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v2.SubmitReportRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_user_description();
+  inline void clear_has_user_description();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_user_options();
+  inline void set_has_club_options();
+
+  inline bool has_type();
+  void clear_type();
+  inline void clear_has_type();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  ::std::string* user_description_;
+  ::google::protobuf::uint32 program_;
+  union TypeUnion {
+    ::bgs::protocol::report::v2::UserOptions* user_options_;
+    ::bgs::protocol::report::v2::ClubOptions* club_options_;
+  } type_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2freport_5fservice_2eproto();
+  friend void protobuf_AssignDesc_api_2fclient_2fv2_2freport_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubmitReportRequest* default_instance_;
+};
+// ===================================================================
+
+class TC_PROTO_API ReportService : public ServiceBase
+{
+ public:
+
+  explicit ReportService(bool use_original_hash);
+  virtual ~ReportService();
+
+  typedef std::integral_constant<uint32, 0x3A4218FBu> OriginalHash;
+  typedef std::integral_constant<uint32, 0xA2480772u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void SubmitReport(::bgs::protocol::report::v2::SubmitReportRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleSubmitReport(::bgs::protocol::report::v2::SubmitReportRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ReportService);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// SubmitReportRequest
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool SubmitReportRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubmitReportRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubmitReportRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubmitReportRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& SubmitReportRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.SubmitReportRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SubmitReportRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v2.SubmitReportRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SubmitReportRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SubmitReportRequest::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v2.SubmitReportRequest.agent_id)
+}
+
+// optional string user_description = 2;
+inline bool SubmitReportRequest::has_user_description() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubmitReportRequest::set_has_user_description() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubmitReportRequest::clear_has_user_description() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubmitReportRequest::clear_user_description() {
+  if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_->clear();
+  }
+  clear_has_user_description();
+}
+inline const ::std::string& SubmitReportRequest::user_description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.SubmitReportRequest.user_description)
+  return *user_description_;
+}
+inline void SubmitReportRequest::set_user_description(const ::std::string& value) {
+  set_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_ = new ::std::string;
+  }
+  user_description_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v2.SubmitReportRequest.user_description)
+}
+inline void SubmitReportRequest::set_user_description(const char* value) {
+  set_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_ = new ::std::string;
+  }
+  user_description_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v2.SubmitReportRequest.user_description)
+}
+inline void SubmitReportRequest::set_user_description(const char* value, size_t size) {
+  set_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_ = new ::std::string;
+  }
+  user_description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v2.SubmitReportRequest.user_description)
+}
+inline ::std::string* SubmitReportRequest::mutable_user_description() {
+  set_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v2.SubmitReportRequest.user_description)
+  return user_description_;
+}
+inline ::std::string* SubmitReportRequest::release_user_description() {
+  clear_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = user_description_;
+    user_description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void SubmitReportRequest::set_allocated_user_description(::std::string* user_description) {
+  if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete user_description_;
+  }
+  if (user_description) {
+    set_has_user_description();
+    user_description_ = user_description;
+  } else {
+    clear_has_user_description();
+    user_description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v2.SubmitReportRequest.user_description)
+}
+
+// optional uint32 program = 3;
+inline bool SubmitReportRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SubmitReportRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SubmitReportRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SubmitReportRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 SubmitReportRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.SubmitReportRequest.program)
+  return program_;
+}
+inline void SubmitReportRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v2.SubmitReportRequest.program)
+}
+
+// optional .bgs.protocol.report.v2.UserOptions user_options = 10;
+inline bool SubmitReportRequest::has_user_options() const {
+  return type_case() == kUserOptions;
+}
+inline void SubmitReportRequest::set_has_user_options() {
+  _oneof_case_[0] = kUserOptions;
+}
+inline void SubmitReportRequest::clear_user_options() {
+  if (has_user_options()) {
+    delete type_.user_options_;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::report::v2::UserOptions& SubmitReportRequest::user_options() const {
+  return has_user_options() ? *type_.user_options_
+                      : ::bgs::protocol::report::v2::UserOptions::default_instance();
+}
+inline ::bgs::protocol::report::v2::UserOptions* SubmitReportRequest::mutable_user_options() {
+  if (!has_user_options()) {
+    clear_type();
+    set_has_user_options();
+    type_.user_options_ = new ::bgs::protocol::report::v2::UserOptions;
+  }
+  return type_.user_options_;
+}
+inline ::bgs::protocol::report::v2::UserOptions* SubmitReportRequest::release_user_options() {
+  if (has_user_options()) {
+    clear_has_type();
+    ::bgs::protocol::report::v2::UserOptions* temp = type_.user_options_;
+    type_.user_options_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void SubmitReportRequest::set_allocated_user_options(::bgs::protocol::report::v2::UserOptions* user_options) {
+  clear_type();
+  if (user_options) {
+    set_has_user_options();
+    type_.user_options_ = user_options;
+  }
+}
+
+// optional .bgs.protocol.report.v2.ClubOptions club_options = 11;
+inline bool SubmitReportRequest::has_club_options() const {
+  return type_case() == kClubOptions;
+}
+inline void SubmitReportRequest::set_has_club_options() {
+  _oneof_case_[0] = kClubOptions;
+}
+inline void SubmitReportRequest::clear_club_options() {
+  if (has_club_options()) {
+    delete type_.club_options_;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::report::v2::ClubOptions& SubmitReportRequest::club_options() const {
+  return has_club_options() ? *type_.club_options_
+                      : ::bgs::protocol::report::v2::ClubOptions::default_instance();
+}
+inline ::bgs::protocol::report::v2::ClubOptions* SubmitReportRequest::mutable_club_options() {
+  if (!has_club_options()) {
+    clear_type();
+    set_has_club_options();
+    type_.club_options_ = new ::bgs::protocol::report::v2::ClubOptions;
+  }
+  return type_.club_options_;
+}
+inline ::bgs::protocol::report::v2::ClubOptions* SubmitReportRequest::release_club_options() {
+  if (has_club_options()) {
+    clear_has_type();
+    ::bgs::protocol::report::v2::ClubOptions* temp = type_.club_options_;
+    type_.club_options_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void SubmitReportRequest::set_allocated_club_options(::bgs::protocol::report::v2::ClubOptions* club_options) {
+  clear_type();
+  if (club_options) {
+    set_has_club_options();
+    type_.club_options_ = club_options;
+  }
+}
+
+inline bool SubmitReportRequest::has_type() {
+  return type_case() != TYPE_NOT_SET;
+}
+inline void SubmitReportRequest::clear_has_type() {
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+inline SubmitReportRequest::TypeCase SubmitReportRequest::type_case() const {
+  return SubmitReportRequest::TypeCase(_oneof_case_[0]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v2
+}  // namespace report
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_api_2fclient_2fv2_2freport_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/api/client/v2/report_types.pb.cc b/src/server/proto/Client/api/client/v2/report_types.pb.cc
new file mode 100644
index 00000000000..8cb58d6d61f
--- /dev/null
+++ b/src/server/proto/Client/api/client/v2/report_types.pb.cc
@@ -0,0 +1,1293 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: api/client/v2/report_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "api/client/v2/report_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace report {
+namespace v2 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ReportItem_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ReportItem_reflection_ = NULL;
+struct ReportItemOneofInstance {
+  const ::bgs::protocol::MessageId* message_id_;
+}* ReportItem_default_oneof_instance_ = NULL;
+const ::google::protobuf::Descriptor* UserOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UserOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubOptions_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* IssueType_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* UserSource_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* ClubSource_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto() {
+  protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "api/client/v2/report_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  ReportItem_descriptor_ = file->message_type(0);
+  static const int ReportItem_offsets_[2] = {
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ReportItem_default_oneof_instance_, message_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReportItem, type_),
+  };
+  ReportItem_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ReportItem_descriptor_,
+      ReportItem::default_instance_,
+      ReportItem_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReportItem, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReportItem, _unknown_fields_),
+      -1,
+      ReportItem_default_oneof_instance_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReportItem, _oneof_case_[0]),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ReportItem));
+  UserOptions_descriptor_ = file->message_type(1);
+  static const int UserOptions_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserOptions, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserOptions, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserOptions, source_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserOptions, item_),
+  };
+  UserOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UserOptions_descriptor_,
+      UserOptions::default_instance_,
+      UserOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UserOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UserOptions));
+  ClubOptions_descriptor_ = file->message_type(2);
+  static const int ClubOptions_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubOptions, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubOptions, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubOptions, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubOptions, source_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubOptions, item_),
+  };
+  ClubOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubOptions_descriptor_,
+      ClubOptions::default_instance_,
+      ClubOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubOptions));
+  IssueType_descriptor_ = file->enum_type(0);
+  UserSource_descriptor_ = file->enum_type(1);
+  ClubSource_descriptor_ = file->enum_type(2);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ReportItem_descriptor_, &ReportItem::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UserOptions_descriptor_, &UserOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubOptions_descriptor_, &ClubOptions::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5ftypes_2eproto() {
+  delete ReportItem::default_instance_;
+  delete ReportItem_default_oneof_instance_;
+  delete ReportItem_reflection_;
+  delete UserOptions::default_instance_;
+  delete UserOptions_reflection_;
+  delete ClubOptions::default_instance_;
+  delete ClubOptions_reflection_;
+}
+
+void protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_message_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n api/client/v2/report_types.proto\022\026bgs."
+    "protocol.report.v2\032\023account_types.proto\032"
+    "\017rpc_types.proto\032\023message_types.proto\"C\n"
+    "\nReportItem\022-\n\nmessage_id\030\001 \001(\0132\027.bgs.pr"
+    "otocol.MessageIdH\000B\006\n\004type\"\333\001\n\013UserOptio"
+    "ns\0225\n\ttarget_id\030\001 \001(\0132\".bgs.protocol.acc"
+    "ount.v1.AccountId\022/\n\004type\030\002 \001(\0162!.bgs.pr"
+    "otocol.report.v2.IssueType\0222\n\006source\030\003 \001"
+    "(\0162\".bgs.protocol.report.v2.UserSource\0220"
+    "\n\004item\030\004 \001(\0132\".bgs.protocol.report.v2.Re"
+    "portItem\"\310\001\n\013ClubOptions\022\017\n\007club_id\030\001 \001("
+    "\004\022\021\n\tstream_id\030\002 \001(\004\022/\n\004type\030\003 \001(\0162!.bgs"
+    ".protocol.report.v2.IssueType\0222\n\006source\030"
+    "\004 \001(\0162\".bgs.protocol.report.v2.ClubSourc"
+    "e\0220\n\004item\030\005 \001(\0132\".bgs.protocol.report.v2"
+    ".ReportItem*\215\001\n\tIssueType\022\023\n\017ISSUE_TYPE_"
+    "SPAM\020\000\022\031\n\025ISSUE_TYPE_HARASSMENT\020\001\022 \n\034ISS"
+    "UE_TYPE_OFFENSIVE_CONTENT\020\003\022\026\n\022ISSUE_TYP"
+    "E_HACKING\020\004\022\026\n\022ISSUE_TYPE_BOTTING\020\005*\252\001\n\n"
+    "UserSource\022\025\n\021USER_SOURCE_OTHER\020\000\022\027\n\023USE"
+    "R_SOURCE_WHISPER\020\001\022\027\n\023USER_SOURCE_PROFIL"
+    "E\020\002\022\032\n\026USER_SOURCE_BATTLE_TAG\020\003\022\024\n\020USER_"
+    "SOURCE_CHAT\020\004\022!\n\035USER_SOURCE_FRIEND_INVI"
+    "TATION\020\005*t\n\nClubSource\022\025\n\021CLUB_SOURCE_OT"
+    "HER\020\000\022\027\n\023CLUB_SOURCE_MESSAGE\020\001\022\031\n\025CLUB_S"
+    "OURCE_CLUB_NAME\020\002\022\033\n\027CLUB_SOURCE_STREAM_"
+    "NAME\020\003B\005H\001\200\001\000", 1053);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "api/client/v2/report_types.proto", &protobuf_RegisterTypes);
+  ReportItem::default_instance_ = new ReportItem();
+  ReportItem_default_oneof_instance_ = new ReportItemOneofInstance;
+  UserOptions::default_instance_ = new UserOptions();
+  ClubOptions::default_instance_ = new ClubOptions();
+  ReportItem::default_instance_->InitAsDefaultInstance();
+  UserOptions::default_instance_->InitAsDefaultInstance();
+  ClubOptions::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_api_2fclient_2fv2_2freport_5ftypes_2eproto {
+  StaticDescriptorInitializer_api_2fclient_2fv2_2freport_5ftypes_2eproto() {
+    protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_api_2fclient_2fv2_2freport_5ftypes_2eproto_;
+const ::google::protobuf::EnumDescriptor* IssueType_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return IssueType_descriptor_;
+}
+bool IssueType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* UserSource_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UserSource_descriptor_;
+}
+bool UserSource_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* ClubSource_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSource_descriptor_;
+}
+bool ClubSource_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ReportItem::kMessageIdFieldNumber;
+#endif  // !_MSC_VER
+
+ReportItem::ReportItem()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.report.v2.ReportItem)
+}
+
+void ReportItem::InitAsDefaultInstance() {
+  ReportItem_default_oneof_instance_->message_id_ = const_cast< ::bgs::protocol::MessageId*>(&::bgs::protocol::MessageId::default_instance());
+}
+
+ReportItem::ReportItem(const ReportItem& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.report.v2.ReportItem)
+}
+
+void ReportItem::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  clear_has_type();
+}
+
+ReportItem::~ReportItem() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.report.v2.ReportItem)
+  SharedDtor();
+}
+
+void ReportItem::SharedDtor() {
+  if (has_type()) {
+    clear_type();
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ReportItem::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ReportItem::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ReportItem_descriptor_;
+}
+
+const ReportItem& ReportItem::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ReportItem* ReportItem::default_instance_ = NULL;
+
+ReportItem* ReportItem::New() const {
+  return new ReportItem;
+}
+
+void ReportItem::clear_type() {
+  switch(type_case()) {
+    case kMessageId: {
+      delete type_.message_id_;
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+
+
+void ReportItem::Clear() {
+  clear_type();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ReportItem::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.report.v2.ReportItem)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.MessageId message_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.report.v2.ReportItem)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.report.v2.ReportItem)
+  return false;
+#undef DO_
+}
+
+void ReportItem::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.report.v2.ReportItem)
+  // optional .bgs.protocol.MessageId message_id = 1;
+  if (has_message_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->message_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.report.v2.ReportItem)
+}
+
+::google::protobuf::uint8* ReportItem::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.report.v2.ReportItem)
+  // optional .bgs.protocol.MessageId message_id = 1;
+  if (has_message_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->message_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.report.v2.ReportItem)
+  return target;
+}
+
+int ReportItem::ByteSize() const {
+  int total_size = 0;
+
+  switch (type_case()) {
+    // optional .bgs.protocol.MessageId message_id = 1;
+    case kMessageId: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message_id());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ReportItem::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ReportItem* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ReportItem*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ReportItem::MergeFrom(const ReportItem& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  switch (from.type_case()) {
+    case kMessageId: {
+      mutable_message_id()->::bgs::protocol::MessageId::MergeFrom(from.message_id());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ReportItem::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ReportItem::CopyFrom(const ReportItem& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReportItem::IsInitialized() const {
+
+  return true;
+}
+
+void ReportItem::Swap(ReportItem* other) {
+  if (other != this) {
+    std::swap(type_, other->type_);
+    std::swap(_oneof_case_[0], other->_oneof_case_[0]);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ReportItem::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ReportItem_descriptor_;
+  metadata.reflection = ReportItem_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UserOptions::kTargetIdFieldNumber;
+const int UserOptions::kTypeFieldNumber;
+const int UserOptions::kSourceFieldNumber;
+const int UserOptions::kItemFieldNumber;
+#endif  // !_MSC_VER
+
+UserOptions::UserOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.report.v2.UserOptions)
+}
+
+void UserOptions::InitAsDefaultInstance() {
+  target_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  item_ = const_cast< ::bgs::protocol::report::v2::ReportItem*>(&::bgs::protocol::report::v2::ReportItem::default_instance());
+}
+
+UserOptions::UserOptions(const UserOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.report.v2.UserOptions)
+}
+
+void UserOptions::SharedCtor() {
+  _cached_size_ = 0;
+  target_id_ = NULL;
+  type_ = 0;
+  source_ = 0;
+  item_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UserOptions::~UserOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.report.v2.UserOptions)
+  SharedDtor();
+}
+
+void UserOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete target_id_;
+    delete item_;
+  }
+}
+
+void UserOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UserOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UserOptions_descriptor_;
+}
+
+const UserOptions& UserOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+UserOptions* UserOptions::default_instance_ = NULL;
+
+UserOptions* UserOptions::New() const {
+  return new UserOptions;
+}
+
+void UserOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<UserOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(type_, source_);
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_item()) {
+      if (item_ != NULL) item_->::bgs::protocol::report::v2::ReportItem::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UserOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.report.v2.UserOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId target_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_type;
+        break;
+      }
+
+      // optional .bgs.protocol.report.v2.IssueType type = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::report::v2::IssueType_IsValid(value)) {
+            set_type(static_cast< ::bgs::protocol::report::v2::IssueType >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(2, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_source;
+        break;
+      }
+
+      // optional .bgs.protocol.report.v2.UserSource source = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_source:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::report::v2::UserSource_IsValid(value)) {
+            set_source(static_cast< ::bgs::protocol::report::v2::UserSource >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(3, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_item;
+        break;
+      }
+
+      // optional .bgs.protocol.report.v2.ReportItem item = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_item:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_item()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.report.v2.UserOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.report.v2.UserOptions)
+  return false;
+#undef DO_
+}
+
+void UserOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.report.v2.UserOptions)
+  // optional .bgs.protocol.account.v1.AccountId target_id = 1;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->target_id(), output);
+  }
+
+  // optional .bgs.protocol.report.v2.IssueType type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->type(), output);
+  }
+
+  // optional .bgs.protocol.report.v2.UserSource source = 3;
+  if (has_source()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->source(), output);
+  }
+
+  // optional .bgs.protocol.report.v2.ReportItem item = 4;
+  if (has_item()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->item(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.report.v2.UserOptions)
+}
+
+::google::protobuf::uint8* UserOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.report.v2.UserOptions)
+  // optional .bgs.protocol.account.v1.AccountId target_id = 1;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->target_id(), target);
+  }
+
+  // optional .bgs.protocol.report.v2.IssueType type = 2;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->type(), target);
+  }
+
+  // optional .bgs.protocol.report.v2.UserSource source = 3;
+  if (has_source()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      3, this->source(), target);
+  }
+
+  // optional .bgs.protocol.report.v2.ReportItem item = 4;
+  if (has_item()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->item(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.report.v2.UserOptions)
+  return target;
+}
+
+int UserOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId target_id = 1;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // optional .bgs.protocol.report.v2.IssueType type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+    }
+
+    // optional .bgs.protocol.report.v2.UserSource source = 3;
+    if (has_source()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->source());
+    }
+
+    // optional .bgs.protocol.report.v2.ReportItem item = 4;
+    if (has_item()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->item());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UserOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UserOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UserOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UserOptions::MergeFrom(const UserOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.target_id());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_source()) {
+      set_source(from.source());
+    }
+    if (from.has_item()) {
+      mutable_item()->::bgs::protocol::report::v2::ReportItem::MergeFrom(from.item());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UserOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UserOptions::CopyFrom(const UserOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UserOptions::IsInitialized() const {
+
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UserOptions::Swap(UserOptions* other) {
+  if (other != this) {
+    std::swap(target_id_, other->target_id_);
+    std::swap(type_, other->type_);
+    std::swap(source_, other->source_);
+    std::swap(item_, other->item_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UserOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UserOptions_descriptor_;
+  metadata.reflection = UserOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubOptions::kClubIdFieldNumber;
+const int ClubOptions::kStreamIdFieldNumber;
+const int ClubOptions::kTypeFieldNumber;
+const int ClubOptions::kSourceFieldNumber;
+const int ClubOptions::kItemFieldNumber;
+#endif  // !_MSC_VER
+
+ClubOptions::ClubOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.report.v2.ClubOptions)
+}
+
+void ClubOptions::InitAsDefaultInstance() {
+  item_ = const_cast< ::bgs::protocol::report::v2::ReportItem*>(&::bgs::protocol::report::v2::ReportItem::default_instance());
+}
+
+ClubOptions::ClubOptions(const ClubOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.report.v2.ClubOptions)
+}
+
+void ClubOptions::SharedCtor() {
+  _cached_size_ = 0;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  type_ = 0;
+  source_ = 0;
+  item_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubOptions::~ClubOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.report.v2.ClubOptions)
+  SharedDtor();
+}
+
+void ClubOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete item_;
+  }
+}
+
+void ClubOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubOptions_descriptor_;
+}
+
+const ClubOptions& ClubOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ClubOptions* ClubOptions::default_instance_ = NULL;
+
+ClubOptions* ClubOptions::New() const {
+  return new ClubOptions;
+}
+
+void ClubOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClubOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(club_id_, source_);
+    if (has_item()) {
+      if (item_ != NULL) item_->::bgs::protocol::report::v2::ReportItem::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.report.v2.ClubOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 club_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_type;
+        break;
+      }
+
+      // optional .bgs.protocol.report.v2.IssueType type = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::report::v2::IssueType_IsValid(value)) {
+            set_type(static_cast< ::bgs::protocol::report::v2::IssueType >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(3, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_source;
+        break;
+      }
+
+      // optional .bgs.protocol.report.v2.ClubSource source = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_source:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::report::v2::ClubSource_IsValid(value)) {
+            set_source(static_cast< ::bgs::protocol::report::v2::ClubSource >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(4, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_item;
+        break;
+      }
+
+      // optional .bgs.protocol.report.v2.ReportItem item = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_item:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_item()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.report.v2.ClubOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.report.v2.ClubOptions)
+  return false;
+#undef DO_
+}
+
+void ClubOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.report.v2.ClubOptions)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.report.v2.IssueType type = 3;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->type(), output);
+  }
+
+  // optional .bgs.protocol.report.v2.ClubSource source = 4;
+  if (has_source()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->source(), output);
+  }
+
+  // optional .bgs.protocol.report.v2.ReportItem item = 5;
+  if (has_item()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->item(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.report.v2.ClubOptions)
+}
+
+::google::protobuf::uint8* ClubOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.report.v2.ClubOptions)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.report.v2.IssueType type = 3;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      3, this->type(), target);
+  }
+
+  // optional .bgs.protocol.report.v2.ClubSource source = 4;
+  if (has_source()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      4, this->source(), target);
+  }
+
+  // optional .bgs.protocol.report.v2.ReportItem item = 5;
+  if (has_item()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->item(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.report.v2.ClubOptions)
+  return target;
+}
+
+int ClubOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 club_id = 1;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 2;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.report.v2.IssueType type = 3;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
+    }
+
+    // optional .bgs.protocol.report.v2.ClubSource source = 4;
+    if (has_source()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->source());
+    }
+
+    // optional .bgs.protocol.report.v2.ReportItem item = 5;
+    if (has_item()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->item());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubOptions::MergeFrom(const ClubOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_source()) {
+      set_source(from.source());
+    }
+    if (from.has_item()) {
+      mutable_item()->::bgs::protocol::report::v2::ReportItem::MergeFrom(from.item());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubOptions::CopyFrom(const ClubOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubOptions::IsInitialized() const {
+
+  return true;
+}
+
+void ClubOptions::Swap(ClubOptions* other) {
+  if (other != this) {
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(type_, other->type_);
+    std::swap(source_, other->source_);
+    std::swap(item_, other->item_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubOptions_descriptor_;
+  metadata.reflection = ClubOptions_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v2
+}  // namespace report
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/api/client/v2/report_types.pb.h b/src/server/proto/Client/api/client/v2/report_types.pb.h
new file mode 100644
index 00000000000..bfaa6277203
--- /dev/null
+++ b/src/server/proto/Client/api/client/v2/report_types.pb.h
@@ -0,0 +1,817 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: api/client/v2/report_types.proto
+
+#ifndef PROTOBUF_api_2fclient_2fv2_2freport_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_api_2fclient_2fv2_2freport_5ftypes_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "account_types.pb.h"
+#include "rpc_types.pb.h"
+#include "message_types.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace report {
+namespace v2 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+void protobuf_AssignDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+void protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+
+class ReportItem;
+class UserOptions;
+class ClubOptions;
+
+enum IssueType {
+  ISSUE_TYPE_SPAM = 0,
+  ISSUE_TYPE_HARASSMENT = 1,
+  ISSUE_TYPE_OFFENSIVE_CONTENT = 3,
+  ISSUE_TYPE_HACKING = 4,
+  ISSUE_TYPE_BOTTING = 5
+};
+TC_PROTO_API bool IssueType_IsValid(int value);
+const IssueType IssueType_MIN = ISSUE_TYPE_SPAM;
+const IssueType IssueType_MAX = ISSUE_TYPE_BOTTING;
+const int IssueType_ARRAYSIZE = IssueType_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* IssueType_descriptor();
+inline const ::std::string& IssueType_Name(IssueType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    IssueType_descriptor(), value);
+}
+inline bool IssueType_Parse(
+    const ::std::string& name, IssueType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<IssueType>(
+    IssueType_descriptor(), name, value);
+}
+enum UserSource {
+  USER_SOURCE_OTHER = 0,
+  USER_SOURCE_WHISPER = 1,
+  USER_SOURCE_PROFILE = 2,
+  USER_SOURCE_BATTLE_TAG = 3,
+  USER_SOURCE_CHAT = 4,
+  USER_SOURCE_FRIEND_INVITATION = 5
+};
+TC_PROTO_API bool UserSource_IsValid(int value);
+const UserSource UserSource_MIN = USER_SOURCE_OTHER;
+const UserSource UserSource_MAX = USER_SOURCE_FRIEND_INVITATION;
+const int UserSource_ARRAYSIZE = UserSource_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* UserSource_descriptor();
+inline const ::std::string& UserSource_Name(UserSource value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    UserSource_descriptor(), value);
+}
+inline bool UserSource_Parse(
+    const ::std::string& name, UserSource* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<UserSource>(
+    UserSource_descriptor(), name, value);
+}
+enum ClubSource {
+  CLUB_SOURCE_OTHER = 0,
+  CLUB_SOURCE_MESSAGE = 1,
+  CLUB_SOURCE_CLUB_NAME = 2,
+  CLUB_SOURCE_STREAM_NAME = 3
+};
+TC_PROTO_API bool ClubSource_IsValid(int value);
+const ClubSource ClubSource_MIN = CLUB_SOURCE_OTHER;
+const ClubSource ClubSource_MAX = CLUB_SOURCE_STREAM_NAME;
+const int ClubSource_ARRAYSIZE = ClubSource_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* ClubSource_descriptor();
+inline const ::std::string& ClubSource_Name(ClubSource value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ClubSource_descriptor(), value);
+}
+inline bool ClubSource_Parse(
+    const ::std::string& name, ClubSource* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ClubSource>(
+    ClubSource_descriptor(), name, value);
+}
+// ===================================================================
+
+class TC_PROTO_API ReportItem : public ::google::protobuf::Message {
+ public:
+  ReportItem();
+  virtual ~ReportItem();
+
+  ReportItem(const ReportItem& from);
+
+  inline ReportItem& operator=(const ReportItem& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ReportItem& default_instance();
+
+  enum TypeCase {
+    kMessageId = 1,
+    TYPE_NOT_SET = 0,
+  };
+
+  void Swap(ReportItem* other);
+
+  // implements Message ----------------------------------------------
+
+  ReportItem* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ReportItem& from);
+  void MergeFrom(const ReportItem& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.MessageId message_id = 1;
+  inline bool has_message_id() const;
+  inline void clear_message_id();
+  static const int kMessageIdFieldNumber = 1;
+  inline const ::bgs::protocol::MessageId& message_id() const;
+  inline ::bgs::protocol::MessageId* mutable_message_id();
+  inline ::bgs::protocol::MessageId* release_message_id();
+  inline void set_allocated_message_id(::bgs::protocol::MessageId* message_id);
+
+  inline TypeCase type_case() const;
+  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v2.ReportItem)
+ private:
+  inline void set_has_message_id();
+
+  inline bool has_type();
+  void clear_type();
+  inline void clear_has_type();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  union TypeUnion {
+    ::bgs::protocol::MessageId* message_id_;
+  } type_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ReportItem* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UserOptions : public ::google::protobuf::Message {
+ public:
+  UserOptions();
+  virtual ~UserOptions();
+
+  UserOptions(const UserOptions& from);
+
+  inline UserOptions& operator=(const UserOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UserOptions& default_instance();
+
+  void Swap(UserOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  UserOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UserOptions& from);
+  void MergeFrom(const UserOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId target_id = 1;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& target_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_target_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::account::v1::AccountId* target_id);
+
+  // optional .bgs.protocol.report.v2.IssueType type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline ::bgs::protocol::report::v2::IssueType type() const;
+  inline void set_type(::bgs::protocol::report::v2::IssueType value);
+
+  // optional .bgs.protocol.report.v2.UserSource source = 3;
+  inline bool has_source() const;
+  inline void clear_source();
+  static const int kSourceFieldNumber = 3;
+  inline ::bgs::protocol::report::v2::UserSource source() const;
+  inline void set_source(::bgs::protocol::report::v2::UserSource value);
+
+  // optional .bgs.protocol.report.v2.ReportItem item = 4;
+  inline bool has_item() const;
+  inline void clear_item();
+  static const int kItemFieldNumber = 4;
+  inline const ::bgs::protocol::report::v2::ReportItem& item() const;
+  inline ::bgs::protocol::report::v2::ReportItem* mutable_item();
+  inline ::bgs::protocol::report::v2::ReportItem* release_item();
+  inline void set_allocated_item(::bgs::protocol::report::v2::ReportItem* item);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v2.UserOptions)
+ private:
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_source();
+  inline void clear_has_source();
+  inline void set_has_item();
+  inline void clear_has_item();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* target_id_;
+  int type_;
+  int source_;
+  ::bgs::protocol::report::v2::ReportItem* item_;
+  friend void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static UserOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubOptions : public ::google::protobuf::Message {
+ public:
+  ClubOptions();
+  virtual ~ClubOptions();
+
+  ClubOptions(const ClubOptions& from);
+
+  inline ClubOptions& operator=(const ClubOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubOptions& default_instance();
+
+  void Swap(ClubOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubOptions& from);
+  void MergeFrom(const ClubOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 club_id = 1;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 2;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.report.v2.IssueType type = 3;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 3;
+  inline ::bgs::protocol::report::v2::IssueType type() const;
+  inline void set_type(::bgs::protocol::report::v2::IssueType value);
+
+  // optional .bgs.protocol.report.v2.ClubSource source = 4;
+  inline bool has_source() const;
+  inline void clear_source();
+  static const int kSourceFieldNumber = 4;
+  inline ::bgs::protocol::report::v2::ClubSource source() const;
+  inline void set_source(::bgs::protocol::report::v2::ClubSource value);
+
+  // optional .bgs.protocol.report.v2.ReportItem item = 5;
+  inline bool has_item() const;
+  inline void clear_item();
+  static const int kItemFieldNumber = 5;
+  inline const ::bgs::protocol::report::v2::ReportItem& item() const;
+  inline ::bgs::protocol::report::v2::ReportItem* mutable_item();
+  inline ::bgs::protocol::report::v2::ReportItem* release_item();
+  inline void set_allocated_item(::bgs::protocol::report::v2::ReportItem* item);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v2.ClubOptions)
+ private:
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_source();
+  inline void clear_has_source();
+  inline void set_has_item();
+  inline void clear_has_item();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  int type_;
+  int source_;
+  ::bgs::protocol::report::v2::ReportItem* item_;
+  friend void TC_PROTO_API protobuf_AddDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_api_2fclient_2fv2_2freport_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubOptions* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ReportItem
+
+// optional .bgs.protocol.MessageId message_id = 1;
+inline bool ReportItem::has_message_id() const {
+  return type_case() == kMessageId;
+}
+inline void ReportItem::set_has_message_id() {
+  _oneof_case_[0] = kMessageId;
+}
+inline void ReportItem::clear_message_id() {
+  if (has_message_id()) {
+    delete type_.message_id_;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::MessageId& ReportItem::message_id() const {
+  return has_message_id() ? *type_.message_id_
+                      : ::bgs::protocol::MessageId::default_instance();
+}
+inline ::bgs::protocol::MessageId* ReportItem::mutable_message_id() {
+  if (!has_message_id()) {
+    clear_type();
+    set_has_message_id();
+    type_.message_id_ = new ::bgs::protocol::MessageId;
+  }
+  return type_.message_id_;
+}
+inline ::bgs::protocol::MessageId* ReportItem::release_message_id() {
+  if (has_message_id()) {
+    clear_has_type();
+    ::bgs::protocol::MessageId* temp = type_.message_id_;
+    type_.message_id_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void ReportItem::set_allocated_message_id(::bgs::protocol::MessageId* message_id) {
+  clear_type();
+  if (message_id) {
+    set_has_message_id();
+    type_.message_id_ = message_id;
+  }
+}
+
+inline bool ReportItem::has_type() {
+  return type_case() != TYPE_NOT_SET;
+}
+inline void ReportItem::clear_has_type() {
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+inline ReportItem::TypeCase ReportItem::type_case() const {
+  return ReportItem::TypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// UserOptions
+
+// optional .bgs.protocol.account.v1.AccountId target_id = 1;
+inline bool UserOptions::has_target_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UserOptions::set_has_target_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UserOptions::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UserOptions::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& UserOptions::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.UserOptions.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* UserOptions::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v2.UserOptions.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* UserOptions::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::account::v1::AccountId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void UserOptions::set_allocated_target_id(::bgs::protocol::account::v1::AccountId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v2.UserOptions.target_id)
+}
+
+// optional .bgs.protocol.report.v2.IssueType type = 2;
+inline bool UserOptions::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UserOptions::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UserOptions::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UserOptions::clear_type() {
+  type_ = 0;
+  clear_has_type();
+}
+inline ::bgs::protocol::report::v2::IssueType UserOptions::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.UserOptions.type)
+  return static_cast< ::bgs::protocol::report::v2::IssueType >(type_);
+}
+inline void UserOptions::set_type(::bgs::protocol::report::v2::IssueType value) {
+  assert(::bgs::protocol::report::v2::IssueType_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v2.UserOptions.type)
+}
+
+// optional .bgs.protocol.report.v2.UserSource source = 3;
+inline bool UserOptions::has_source() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UserOptions::set_has_source() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UserOptions::clear_has_source() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UserOptions::clear_source() {
+  source_ = 0;
+  clear_has_source();
+}
+inline ::bgs::protocol::report::v2::UserSource UserOptions::source() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.UserOptions.source)
+  return static_cast< ::bgs::protocol::report::v2::UserSource >(source_);
+}
+inline void UserOptions::set_source(::bgs::protocol::report::v2::UserSource value) {
+  assert(::bgs::protocol::report::v2::UserSource_IsValid(value));
+  set_has_source();
+  source_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v2.UserOptions.source)
+}
+
+// optional .bgs.protocol.report.v2.ReportItem item = 4;
+inline bool UserOptions::has_item() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void UserOptions::set_has_item() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void UserOptions::clear_has_item() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void UserOptions::clear_item() {
+  if (item_ != NULL) item_->::bgs::protocol::report::v2::ReportItem::Clear();
+  clear_has_item();
+}
+inline const ::bgs::protocol::report::v2::ReportItem& UserOptions::item() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.UserOptions.item)
+  return item_ != NULL ? *item_ : *default_instance_->item_;
+}
+inline ::bgs::protocol::report::v2::ReportItem* UserOptions::mutable_item() {
+  set_has_item();
+  if (item_ == NULL) item_ = new ::bgs::protocol::report::v2::ReportItem;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v2.UserOptions.item)
+  return item_;
+}
+inline ::bgs::protocol::report::v2::ReportItem* UserOptions::release_item() {
+  clear_has_item();
+  ::bgs::protocol::report::v2::ReportItem* temp = item_;
+  item_ = NULL;
+  return temp;
+}
+inline void UserOptions::set_allocated_item(::bgs::protocol::report::v2::ReportItem* item) {
+  delete item_;
+  item_ = item;
+  if (item) {
+    set_has_item();
+  } else {
+    clear_has_item();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v2.UserOptions.item)
+}
+
+// -------------------------------------------------------------------
+
+// ClubOptions
+
+// optional uint64 club_id = 1;
+inline bool ClubOptions::has_club_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubOptions::set_has_club_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubOptions::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubOptions::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 ClubOptions::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.ClubOptions.club_id)
+  return club_id_;
+}
+inline void ClubOptions::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v2.ClubOptions.club_id)
+}
+
+// optional uint64 stream_id = 2;
+inline bool ClubOptions::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubOptions::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubOptions::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubOptions::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 ClubOptions::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.ClubOptions.stream_id)
+  return stream_id_;
+}
+inline void ClubOptions::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v2.ClubOptions.stream_id)
+}
+
+// optional .bgs.protocol.report.v2.IssueType type = 3;
+inline bool ClubOptions::has_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubOptions::set_has_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubOptions::clear_has_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubOptions::clear_type() {
+  type_ = 0;
+  clear_has_type();
+}
+inline ::bgs::protocol::report::v2::IssueType ClubOptions::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.ClubOptions.type)
+  return static_cast< ::bgs::protocol::report::v2::IssueType >(type_);
+}
+inline void ClubOptions::set_type(::bgs::protocol::report::v2::IssueType value) {
+  assert(::bgs::protocol::report::v2::IssueType_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v2.ClubOptions.type)
+}
+
+// optional .bgs.protocol.report.v2.ClubSource source = 4;
+inline bool ClubOptions::has_source() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubOptions::set_has_source() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubOptions::clear_has_source() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubOptions::clear_source() {
+  source_ = 0;
+  clear_has_source();
+}
+inline ::bgs::protocol::report::v2::ClubSource ClubOptions::source() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.ClubOptions.source)
+  return static_cast< ::bgs::protocol::report::v2::ClubSource >(source_);
+}
+inline void ClubOptions::set_source(::bgs::protocol::report::v2::ClubSource value) {
+  assert(::bgs::protocol::report::v2::ClubSource_IsValid(value));
+  set_has_source();
+  source_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v2.ClubOptions.source)
+}
+
+// optional .bgs.protocol.report.v2.ReportItem item = 5;
+inline bool ClubOptions::has_item() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubOptions::set_has_item() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubOptions::clear_has_item() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubOptions::clear_item() {
+  if (item_ != NULL) item_->::bgs::protocol::report::v2::ReportItem::Clear();
+  clear_has_item();
+}
+inline const ::bgs::protocol::report::v2::ReportItem& ClubOptions::item() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v2.ClubOptions.item)
+  return item_ != NULL ? *item_ : *default_instance_->item_;
+}
+inline ::bgs::protocol::report::v2::ReportItem* ClubOptions::mutable_item() {
+  set_has_item();
+  if (item_ == NULL) item_ = new ::bgs::protocol::report::v2::ReportItem;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v2.ClubOptions.item)
+  return item_;
+}
+inline ::bgs::protocol::report::v2::ReportItem* ClubOptions::release_item() {
+  clear_has_item();
+  ::bgs::protocol::report::v2::ReportItem* temp = item_;
+  item_ = NULL;
+  return temp;
+}
+inline void ClubOptions::set_allocated_item(::bgs::protocol::report::v2::ReportItem* item) {
+  delete item_;
+  item_ = item;
+  if (item) {
+    set_has_item();
+  } else {
+    clear_has_item();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v2.ClubOptions.item)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v2
+}  // namespace report
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::report::v2::IssueType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::report::v2::IssueType>() {
+  return ::bgs::protocol::report::v2::IssueType_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::report::v2::UserSource> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::report::v2::UserSource>() {
+  return ::bgs::protocol::report::v2::UserSource_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::report::v2::ClubSource> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::report::v2::ClubSource>() {
+  return ::bgs::protocol::report::v2::ClubSource_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_api_2fclient_2fv2_2freport_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/authentication_service.pb.cc b/src/server/proto/Client/authentication_service.pb.cc
index aa13b55441f..9a2ffa34a62 100644
--- a/src/server/proto/Client/authentication_service.pb.cc
+++ b/src/server/proto/Client/authentication_service.pb.cc
@@ -148,7 +148,7 @@ void protobuf_AssignDesc_authentication_5fservice_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ModuleMessageRequest));
   LogonRequest_descriptor_ = file->message_type(3);
-  static const int LogonRequest_offsets_[14] = {
+  static const int LogonRequest_offsets_[11] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, program_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, platform_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, locale_),
@@ -156,10 +156,7 @@ void protobuf_AssignDesc_authentication_5fservice_2eproto() {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, version_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, application_version_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, public_computer_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, sso_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, disconnect_on_cookie_fail_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, allow_logon_queue_notifications_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, web_client_verification_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, cached_web_credentials_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, user_agent_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, device_id_),
@@ -558,106 +555,105 @@ void protobuf_AddDesc_authentication_5fservice_2eproto() {
     "rotocol.ContentHandle\022\017\n\007message\030\002 \001(\014\"7"
     "\n\022ModuleNotification\022\021\n\tmodule_id\030\002 \001(\005\022"
     "\016\n\006result\030\003 \001(\r\":\n\024ModuleMessageRequest\022"
-    "\021\n\tmodule_id\030\001 \002(\005\022\017\n\007message\030\002 \001(\014\"\360\002\n\014"
+    "\021\n\tmodule_id\030\001 \002(\005\022\017\n\007message\030\002 \001(\014\"\216\002\n\014"
     "LogonRequest\022\017\n\007program\030\001 \001(\t\022\020\n\010platfor"
     "m\030\002 \001(\t\022\016\n\006locale\030\003 \001(\t\022\r\n\005email\030\004 \001(\t\022\017"
     "\n\007version\030\005 \001(\t\022\033\n\023application_version\030\006"
-    " \001(\005\022\027\n\017public_computer\030\007 \001(\010\022\016\n\006sso_id\030"
-    "\010 \001(\014\022(\n\031disconnect_on_cookie_fail\030\t \001(\010"
-    ":\005false\022.\n\037allow_logon_queue_notificatio"
-    "ns\030\n \001(\010:\005false\022&\n\027web_client_verificati"
-    "on\030\013 \001(\010:\005false\022\036\n\026cached_web_credential"
-    "s\030\014 \001(\014\022\022\n\nuser_agent\030\016 \001(\t\022\021\n\tdevice_id"
-    "\030\017 \001(\t\"\232\002\n\013LogonResult\022\022\n\nerror_code\030\001 \002"
-    "(\r\022*\n\naccount_id\030\002 \001(\0132\026.bgs.protocol.En"
-    "tityId\022/\n\017game_account_id\030\003 \003(\0132\026.bgs.pr"
-    "otocol.EntityId\022\r\n\005email\030\004 \001(\t\022\030\n\020availa"
-    "ble_region\030\005 \003(\r\022\030\n\020connected_region\030\006 \001"
-    "(\r\022\022\n\nbattle_tag\030\007 \001(\t\022\025\n\rgeoip_country\030"
-    "\010 \001(\t\022\023\n\013session_key\030\t \001(\014\022\027\n\017restricted"
-    "_mode\030\n \001(\010\"*\n\027GenerateSSOTokenRequest\022\017"
-    "\n\007program\030\001 \001(\007\">\n\030GenerateSSOTokenRespo"
-    "nse\022\016\n\006sso_id\030\001 \001(\014\022\022\n\nsso_secret\030\002 \001(\014\""
-    "(\n\022LogonUpdateRequest\022\022\n\nerror_code\030\001 \002("
-    "\r\"a\n\027LogonQueueUpdateRequest\022\020\n\010position"
-    "\030\001 \002(\r\022\026\n\016estimated_time\030\002 \002(\004\022\034\n\024eta_de"
-    "viation_in_sec\030\003 \002(\004\"\276\001\n\033AccountSettings"
-    "Notification\0229\n\010licenses\030\001 \003(\0132\'.bgs.pro"
-    "tocol.account.v1.AccountLicense\022\024\n\014is_us"
-    "ing_rid\030\002 \001(\010\022\033\n\023is_playing_from_igr\030\003 \001"
-    "(\010\022\031\n\021can_receive_voice\030\004 \001(\010\022\026\n\016can_sen"
-    "d_voice\030\005 \001(\010\"=\n\030ServerStateChangeReques"
-    "t\022\r\n\005state\030\001 \002(\r\022\022\n\nevent_time\030\002 \002(\004\"T\n\013"
-    "VersionInfo\022\016\n\006number\030\001 \001(\r\022\r\n\005patch\030\002 \001"
-    "(\t\022\023\n\013is_optional\030\003 \001(\010\022\021\n\tkick_time\030\004 \001"
-    "(\004\"\\\n\027VersionInfoNotification\022A\n\014version"
-    "_info\030\001 \001(\0132+.bgs.protocol.authenticatio"
-    "n.v1.VersionInfo\"_\n\024MemModuleLoadRequest"
-    "\022+\n\006handle\030\001 \002(\0132\033.bgs.protocol.ContentH"
-    "andle\022\013\n\003key\030\002 \002(\014\022\r\n\005input\030\003 \002(\014\"%\n\025Mem"
-    "ModuleLoadResponse\022\014\n\004data\030\001 \002(\014\"K\n\030Sele"
-    "ctGameAccountRequest\022/\n\017game_account_id\030"
-    "\001 \002(\0132\026.bgs.protocol.EntityId\"]\n\032GameAcc"
-    "ountSelectedRequest\022\016\n\006result\030\001 \002(\r\022/\n\017g"
-    "ame_account_id\030\002 \001(\0132\026.bgs.protocol.Enti"
-    "tyId\"0\n\035GenerateWebCredentialsRequest\022\017\n"
-    "\007program\030\001 \001(\007\"9\n\036GenerateWebCredentials"
-    "Response\022\027\n\017web_credentials\030\001 \001(\014\"6\n\033Ver"
-    "ifyWebCredentialsRequest\022\027\n\017web_credenti"
-    "als\030\001 \001(\0142\202\t\n\026AuthenticationListener\022e\n\014"
-    "OnModuleLoad\0221.bgs.protocol.authenticati"
-    "on.v1.ModuleLoadRequest\032\031.bgs.protocol.N"
-    "O_RESPONSE\"\007\210\002\001\200\265\030\001\022f\n\017OnModuleMessage\0224"
-    ".bgs.protocol.authentication.v1.ModuleMe"
-    "ssageRequest\032\024.bgs.protocol.NoData\"\007\210\002\001\200"
-    "\265\030\002\022p\n\023OnServerStateChange\0228.bgs.protoco"
-    "l.authentication.v1.ServerStateChangeReq"
-    "uest\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\004\022_\n"
-    "\017OnLogonComplete\022+.bgs.protocol.authenti"
-    "cation.v1.LogonResult\032\031.bgs.protocol.NO_"
-    "RESPONSE\"\004\200\265\030\005\022\204\001\n\017OnMemModuleLoad\0224.bgs"
-    ".protocol.authentication.v1.MemModuleLoa"
-    "dRequest\0325.bgs.protocol.authentication.v"
-    "1.MemModuleLoadResponse\"\004\200\265\030\006\022d\n\rOnLogon"
-    "Update\0222.bgs.protocol.authentication.v1."
-    "LogonUpdateRequest\032\031.bgs.protocol.NO_RES"
-    "PONSE\"\004\200\265\030\n\022p\n\024OnVersionInfoUpdated\0227.bg"
-    "s.protocol.authentication.v1.VersionInfo"
-    "Notification\032\031.bgs.protocol.NO_RESPONSE\""
-    "\004\200\265\030\013\022n\n\022OnLogonQueueUpdate\0227.bgs.protoc"
-    "ol.authentication.v1.LogonQueueUpdateReq"
-    "uest\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\014\022H\n"
-    "\017OnLogonQueueEnd\022\024.bgs.protocol.NoData\032\031"
-    ".bgs.protocol.NO_RESPONSE\"\004\200\265\030\r\022w\n\025OnGam"
+    " \001(\005\022\027\n\017public_computer\030\007 \001(\010\022.\n\037allow_l"
+    "ogon_queue_notifications\030\n \001(\010:\005false\022\036\n"
+    "\026cached_web_credentials\030\014 \001(\014\022\022\n\nuser_ag"
+    "ent\030\016 \001(\t\022\021\n\tdevice_id\030\017 \001(\t\"\232\002\n\013LogonRe"
+    "sult\022\022\n\nerror_code\030\001 \002(\r\022*\n\naccount_id\030\002"
+    " \001(\0132\026.bgs.protocol.EntityId\022/\n\017game_acc"
+    "ount_id\030\003 \003(\0132\026.bgs.protocol.EntityId\022\r\n"
+    "\005email\030\004 \001(\t\022\030\n\020available_region\030\005 \003(\r\022\030"
+    "\n\020connected_region\030\006 \001(\r\022\022\n\nbattle_tag\030\007"
+    " \001(\t\022\025\n\rgeoip_country\030\010 \001(\t\022\023\n\013session_k"
+    "ey\030\t \001(\014\022\027\n\017restricted_mode\030\n \001(\010\"*\n\027Gen"
+    "erateSSOTokenRequest\022\017\n\007program\030\001 \001(\007\">\n"
+    "\030GenerateSSOTokenResponse\022\016\n\006sso_id\030\001 \001("
+    "\014\022\022\n\nsso_secret\030\002 \001(\014\"(\n\022LogonUpdateRequ"
+    "est\022\022\n\nerror_code\030\001 \002(\r\"a\n\027LogonQueueUpd"
+    "ateRequest\022\020\n\010position\030\001 \002(\r\022\026\n\016estimate"
+    "d_time\030\002 \002(\004\022\034\n\024eta_deviation_in_sec\030\003 \002"
+    "(\004\"\276\001\n\033AccountSettingsNotification\0229\n\010li"
+    "censes\030\001 \003(\0132\'.bgs.protocol.account.v1.A"
+    "ccountLicense\022\024\n\014is_using_rid\030\002 \001(\010\022\033\n\023i"
+    "s_playing_from_igr\030\003 \001(\010\022\031\n\021can_receive_"
+    "voice\030\004 \001(\010\022\026\n\016can_send_voice\030\005 \001(\010\"=\n\030S"
+    "erverStateChangeRequest\022\r\n\005state\030\001 \002(\r\022\022"
+    "\n\nevent_time\030\002 \002(\004\"T\n\013VersionInfo\022\016\n\006num"
+    "ber\030\001 \001(\r\022\r\n\005patch\030\002 \001(\t\022\023\n\013is_optional\030"
+    "\003 \001(\010\022\021\n\tkick_time\030\004 \001(\004\"\\\n\027VersionInfoN"
+    "otification\022A\n\014version_info\030\001 \001(\0132+.bgs."
+    "protocol.authentication.v1.VersionInfo\"_"
+    "\n\024MemModuleLoadRequest\022+\n\006handle\030\001 \002(\0132\033"
+    ".bgs.protocol.ContentHandle\022\013\n\003key\030\002 \002(\014"
+    "\022\r\n\005input\030\003 \002(\014\"%\n\025MemModuleLoadResponse"
+    "\022\014\n\004data\030\001 \002(\014\"K\n\030SelectGameAccountReque"
+    "st\022/\n\017game_account_id\030\001 \002(\0132\026.bgs.protoc"
+    "ol.EntityId\"]\n\032GameAccountSelectedReques"
+    "t\022\016\n\006result\030\001 \002(\r\022/\n\017game_account_id\030\002 \001"
+    "(\0132\026.bgs.protocol.EntityId\"0\n\035GenerateWe"
+    "bCredentialsRequest\022\017\n\007program\030\001 \001(\007\"9\n\036"
+    "GenerateWebCredentialsResponse\022\027\n\017web_cr"
+    "edentials\030\001 \001(\014\"6\n\033VerifyWebCredentialsR"
+    "equest\022\027\n\017web_credentials\030\001 \001(\0142\237\t\n\026Auth"
+    "enticationListener\022g\n\014OnModuleLoad\0221.bgs"
+    ".protocol.authentication.v1.ModuleLoadRe"
+    "quest\032\031.bgs.protocol.NO_RESPONSE\"\t\210\002\001\202\371+"
+    "\002\010\001\022h\n\017OnModuleMessage\0224.bgs.protocol.au"
+    "thentication.v1.ModuleMessageRequest\032\024.b"
+    "gs.protocol.NoData\"\t\210\002\001\202\371+\002\010\002\022r\n\023OnServe"
+    "rStateChange\0228.bgs.protocol.authenticati"
+    "on.v1.ServerStateChangeRequest\032\031.bgs.pro"
+    "tocol.NO_RESPONSE\"\006\202\371+\002\010\004\022a\n\017OnLogonComp"
+    "lete\022+.bgs.protocol.authentication.v1.Lo"
+    "gonResult\032\031.bgs.protocol.NO_RESPONSE\"\006\202\371"
+    "+\002\010\005\022\206\001\n\017OnMemModuleLoad\0224.bgs.protocol."
+    "authentication.v1.MemModuleLoadRequest\0325"
+    ".bgs.protocol.authentication.v1.MemModul"
+    "eLoadResponse\"\006\202\371+\002\010\006\022f\n\rOnLogonUpdate\0222"
+    ".bgs.protocol.authentication.v1.LogonUpd"
+    "ateRequest\032\031.bgs.protocol.NO_RESPONSE\"\006\202"
+    "\371+\002\010\n\022r\n\024OnVersionInfoUpdated\0227.bgs.prot"
+    "ocol.authentication.v1.VersionInfoNotifi"
+    "cation\032\031.bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010"
+    "\013\022p\n\022OnLogonQueueUpdate\0227.bgs.protocol.a"
+    "uthentication.v1.LogonQueueUpdateRequest"
+    "\032\031.bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010\014\022J\n\017O"
+    "nLogonQueueEnd\022\024.bgs.protocol.NoData\032\031.b"
+    "gs.protocol.NO_RESPONSE\"\006\202\371+\002\010\r\022y\n\025OnGam"
     "eAccountSelected\022:.bgs.protocol.authenti"
     "cation.v1.GameAccountSelectedRequest\032\031.b"
-    "gs.protocol.NO_RESPONSE\"\007\210\002\001\200\265\030\016\0324\312>1bne"
-    "t.protocol.authentication.Authentication"
-    "Client2\315\007\n\025AuthenticationService\022Q\n\005Logo"
-    "n\022,.bgs.protocol.authentication.v1.Logon"
-    "Request\032\024.bgs.protocol.NoData\"\004\200\265\030\001\022a\n\014M"
-    "oduleNotify\0222.bgs.protocol.authenticatio"
-    "n.v1.ModuleNotification\032\024.bgs.protocol.N"
-    "oData\"\007\210\002\001\200\265\030\002\022d\n\rModuleMessage\0224.bgs.pr"
-    "otocol.authentication.v1.ModuleMessageRe"
-    "quest\032\024.bgs.protocol.NoData\"\007\210\002\001\200\265\030\003\022U\n\034"
-    "SelectGameAccount_DEPRECATED\022\026.bgs.proto"
-    "col.EntityId\032\024.bgs.protocol.NoData\"\007\210\002\001\200"
-    "\265\030\004\022\213\001\n\020GenerateSSOToken\0227.bgs.protocol."
-    "authentication.v1.GenerateSSOTokenReques"
-    "t\0328.bgs.protocol.authentication.v1.Gener"
-    "ateSSOTokenResponse\"\004\200\265\030\005\022l\n\021SelectGameA"
-    "ccount\0228.bgs.protocol.authentication.v1."
-    "SelectGameAccountRequest\032\024.bgs.protocol."
-    "NoData\"\007\210\002\001\200\265\030\006\022o\n\024VerifyWebCredentials\022"
-    ";.bgs.protocol.authentication.v1.VerifyW"
-    "ebCredentialsRequest\032\024.bgs.protocol.NoDa"
-    "ta\"\004\200\265\030\007\022\235\001\n\026GenerateWebCredentials\022=.bg"
-    "s.protocol.authentication.v1.GenerateWeb"
-    "CredentialsRequest\032>.bgs.protocol.authen"
-    "tication.v1.GenerateWebCredentialsRespon"
-    "se\"\004\200\265\030\010\0324\312>1bnet.protocol.authenticatio"
-    "n.AuthenticationServerB\005H\001\200\001\000", 4309);
+    "gs.protocol.NO_RESPONSE\"\t\210\002\001\202\371+\002\010\016\032=\202\371+3"
+    "\n1bnet.protocol.authentication.Authentic"
+    "ationClient\212\371+\002\010\0012\346\007\n\025AuthenticationServ"
+    "ice\022S\n\005Logon\022,.bgs.protocol.authenticati"
+    "on.v1.LogonRequest\032\024.bgs.protocol.NoData"
+    "\"\006\202\371+\002\010\001\022c\n\014ModuleNotify\0222.bgs.protocol."
+    "authentication.v1.ModuleNotification\032\024.b"
+    "gs.protocol.NoData\"\t\210\002\001\202\371+\002\010\002\022f\n\rModuleM"
+    "essage\0224.bgs.protocol.authentication.v1."
+    "ModuleMessageRequest\032\024.bgs.protocol.NoDa"
+    "ta\"\t\210\002\001\202\371+\002\010\003\022W\n\034SelectGameAccount_DEPRE"
+    "CATED\022\026.bgs.protocol.EntityId\032\024.bgs.prot"
+    "ocol.NoData\"\t\210\002\001\202\371+\002\010\004\022\215\001\n\020GenerateSSOTo"
+    "ken\0227.bgs.protocol.authentication.v1.Gen"
+    "erateSSOTokenRequest\0328.bgs.protocol.auth"
+    "entication.v1.GenerateSSOTokenResponse\"\006"
+    "\202\371+\002\010\005\022n\n\021SelectGameAccount\0228.bgs.protoc"
+    "ol.authentication.v1.SelectGameAccountRe"
+    "quest\032\024.bgs.protocol.NoData\"\t\210\002\001\202\371+\002\010\006\022q"
+    "\n\024VerifyWebCredentials\022;.bgs.protocol.au"
+    "thentication.v1.VerifyWebCredentialsRequ"
+    "est\032\024.bgs.protocol.NoData\"\006\202\371+\002\010\007\022\237\001\n\026Ge"
+    "nerateWebCredentials\022=.bgs.protocol.auth"
+    "entication.v1.GenerateWebCredentialsRequ"
+    "est\032>.bgs.protocol.authentication.v1.Gen"
+    "erateWebCredentialsResponse\"\006\202\371+\002\010\010\032=\202\371+"
+    "3\n1bnet.protocol.authentication.Authenti"
+    "cationServer\212\371+\002\020\001B\005H\001\200\001\000", 4265);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "authentication_service.proto", &protobuf_RegisterTypes);
   ModuleLoadRequest::default_instance_ = new ModuleLoadRequest();
@@ -1548,10 +1544,7 @@ const int LogonRequest::kEmailFieldNumber;
 const int LogonRequest::kVersionFieldNumber;
 const int LogonRequest::kApplicationVersionFieldNumber;
 const int LogonRequest::kPublicComputerFieldNumber;
-const int LogonRequest::kSsoIdFieldNumber;
-const int LogonRequest::kDisconnectOnCookieFailFieldNumber;
 const int LogonRequest::kAllowLogonQueueNotificationsFieldNumber;
-const int LogonRequest::kWebClientVerificationFieldNumber;
 const int LogonRequest::kCachedWebCredentialsFieldNumber;
 const int LogonRequest::kUserAgentFieldNumber;
 const int LogonRequest::kDeviceIdFieldNumber;
@@ -1583,10 +1576,7 @@ void LogonRequest::SharedCtor() {
   version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   application_version_ = 0;
   public_computer_ = false;
-  sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  disconnect_on_cookie_fail_ = false;
   allow_logon_queue_notifications_ = false;
-  web_client_verification_ = false;
   cached_web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   user_agent_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   device_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
@@ -1614,9 +1604,6 @@ void LogonRequest::SharedDtor() {
   if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete version_;
   }
-  if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete sso_id_;
-  }
   if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete cached_web_credentials_;
   }
@@ -1663,7 +1650,7 @@ void LogonRequest::Clear() {
   } while (0)
 
   if (_has_bits_[0 / 32] & 255) {
-    ZR_(application_version_, public_computer_);
+    ZR_(application_version_, allow_logon_queue_notifications_);
     if (has_program()) {
       if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
         program_->clear();
@@ -1689,14 +1676,8 @@ void LogonRequest::Clear() {
         version_->clear();
       }
     }
-    if (has_sso_id()) {
-      if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        sso_id_->clear();
-      }
-    }
   }
-  if (_has_bits_[8 / 32] & 16128) {
-    ZR_(disconnect_on_cookie_fail_, web_client_verification_);
+  if (_has_bits_[8 / 32] & 1792) {
     if (has_cached_web_credentials()) {
       if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
         cached_web_credentials_->clear();
@@ -1841,34 +1822,6 @@ bool LogonRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(66)) goto parse_sso_id;
-        break;
-      }
-
-      // optional bytes sso_id = 8;
-      case 8: {
-        if (tag == 66) {
-         parse_sso_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
-                input, this->mutable_sso_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(72)) goto parse_disconnect_on_cookie_fail;
-        break;
-      }
-
-      // optional bool disconnect_on_cookie_fail = 9 [default = false];
-      case 9: {
-        if (tag == 72) {
-         parse_disconnect_on_cookie_fail:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &disconnect_on_cookie_fail_)));
-          set_has_disconnect_on_cookie_fail();
-        } else {
-          goto handle_unusual;
-        }
         if (input->ExpectTag(80)) goto parse_allow_logon_queue_notifications;
         break;
       }
@@ -1884,21 +1837,6 @@ bool LogonRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(88)) goto parse_web_client_verification;
-        break;
-      }
-
-      // optional bool web_client_verification = 11 [default = false];
-      case 11: {
-        if (tag == 88) {
-         parse_web_client_verification:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &web_client_verification_)));
-          set_has_web_client_verification();
-        } else {
-          goto handle_unusual;
-        }
         if (input->ExpectTag(98)) goto parse_cached_web_credentials;
         break;
       }
@@ -2035,27 +1973,11 @@ void LogonRequest::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->public_computer(), output);
   }
 
-  // optional bytes sso_id = 8;
-  if (has_sso_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
-      8, this->sso_id(), output);
-  }
-
-  // optional bool disconnect_on_cookie_fail = 9 [default = false];
-  if (has_disconnect_on_cookie_fail()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->disconnect_on_cookie_fail(), output);
-  }
-
   // optional bool allow_logon_queue_notifications = 10 [default = false];
   if (has_allow_logon_queue_notifications()) {
     ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->allow_logon_queue_notifications(), output);
   }
 
-  // optional bool web_client_verification = 11 [default = false];
-  if (has_web_client_verification()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->web_client_verification(), output);
-  }
-
   // optional bytes cached_web_credentials = 12;
   if (has_cached_web_credentials()) {
     ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
@@ -2157,28 +2079,11 @@ void LogonRequest::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->public_computer(), target);
   }
 
-  // optional bytes sso_id = 8;
-  if (has_sso_id()) {
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
-        8, this->sso_id(), target);
-  }
-
-  // optional bool disconnect_on_cookie_fail = 9 [default = false];
-  if (has_disconnect_on_cookie_fail()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->disconnect_on_cookie_fail(), target);
-  }
-
   // optional bool allow_logon_queue_notifications = 10 [default = false];
   if (has_allow_logon_queue_notifications()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->allow_logon_queue_notifications(), target);
   }
 
-  // optional bool web_client_verification = 11 [default = false];
-  if (has_web_client_verification()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->web_client_verification(), target);
-  }
-
   // optional bytes cached_web_credentials = 12;
   if (has_cached_web_credentials()) {
     target =
@@ -2267,30 +2172,13 @@ int LogonRequest::ByteSize() const {
       total_size += 1 + 1;
     }
 
-    // optional bytes sso_id = 8;
-    if (has_sso_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::BytesSize(
-          this->sso_id());
-    }
-
-  }
-  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
-    // optional bool disconnect_on_cookie_fail = 9 [default = false];
-    if (has_disconnect_on_cookie_fail()) {
-      total_size += 1 + 1;
-    }
-
     // optional bool allow_logon_queue_notifications = 10 [default = false];
     if (has_allow_logon_queue_notifications()) {
       total_size += 1 + 1;
     }
 
-    // optional bool web_client_verification = 11 [default = false];
-    if (has_web_client_verification()) {
-      total_size += 1 + 1;
-    }
-
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
     // optional bytes cached_web_credentials = 12;
     if (has_cached_web_credentials()) {
       total_size += 1 +
@@ -2360,20 +2248,11 @@ void LogonRequest::MergeFrom(const LogonRequest& from) {
     if (from.has_public_computer()) {
       set_public_computer(from.public_computer());
     }
-    if (from.has_sso_id()) {
-      set_sso_id(from.sso_id());
-    }
-  }
-  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
-    if (from.has_disconnect_on_cookie_fail()) {
-      set_disconnect_on_cookie_fail(from.disconnect_on_cookie_fail());
-    }
     if (from.has_allow_logon_queue_notifications()) {
       set_allow_logon_queue_notifications(from.allow_logon_queue_notifications());
     }
-    if (from.has_web_client_verification()) {
-      set_web_client_verification(from.web_client_verification());
-    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
     if (from.has_cached_web_credentials()) {
       set_cached_web_credentials(from.cached_web_credentials());
     }
@@ -2413,10 +2292,7 @@ void LogonRequest::Swap(LogonRequest* other) {
     std::swap(version_, other->version_);
     std::swap(application_version_, other->application_version_);
     std::swap(public_computer_, other->public_computer_);
-    std::swap(sso_id_, other->sso_id_);
-    std::swap(disconnect_on_cookie_fail_, other->disconnect_on_cookie_fail_);
     std::swap(allow_logon_queue_notifications_, other->allow_logon_queue_notifications_);
-    std::swap(web_client_verification_, other->web_client_verification_);
     std::swap(cached_web_credentials_, other->cached_web_credentials_);
     std::swap(user_agent_, other->user_agent_);
     std::swap(device_id_, other->device_id_);
diff --git a/src/server/proto/Client/authentication_service.pb.h b/src/server/proto/Client/authentication_service.pb.h
index b082cca58a7..fb9f12f01ef 100644
--- a/src/server/proto/Client/authentication_service.pb.h
+++ b/src/server/proto/Client/authentication_service.pb.h
@@ -473,25 +473,6 @@ class TC_PROTO_API LogonRequest : public ::google::protobuf::Message {
   inline bool public_computer() const;
   inline void set_public_computer(bool value);
 
-  // optional bytes sso_id = 8;
-  inline bool has_sso_id() const;
-  inline void clear_sso_id();
-  static const int kSsoIdFieldNumber = 8;
-  inline const ::std::string& sso_id() const;
-  inline void set_sso_id(const ::std::string& value);
-  inline void set_sso_id(const char* value);
-  inline void set_sso_id(const void* value, size_t size);
-  inline ::std::string* mutable_sso_id();
-  inline ::std::string* release_sso_id();
-  inline void set_allocated_sso_id(::std::string* sso_id);
-
-  // optional bool disconnect_on_cookie_fail = 9 [default = false];
-  inline bool has_disconnect_on_cookie_fail() const;
-  inline void clear_disconnect_on_cookie_fail();
-  static const int kDisconnectOnCookieFailFieldNumber = 9;
-  inline bool disconnect_on_cookie_fail() const;
-  inline void set_disconnect_on_cookie_fail(bool value);
-
   // optional bool allow_logon_queue_notifications = 10 [default = false];
   inline bool has_allow_logon_queue_notifications() const;
   inline void clear_allow_logon_queue_notifications();
@@ -499,13 +480,6 @@ class TC_PROTO_API LogonRequest : public ::google::protobuf::Message {
   inline bool allow_logon_queue_notifications() const;
   inline void set_allow_logon_queue_notifications(bool value);
 
-  // optional bool web_client_verification = 11 [default = false];
-  inline bool has_web_client_verification() const;
-  inline void clear_web_client_verification();
-  static const int kWebClientVerificationFieldNumber = 11;
-  inline bool web_client_verification() const;
-  inline void set_web_client_verification(bool value);
-
   // optional bytes cached_web_credentials = 12;
   inline bool has_cached_web_credentials() const;
   inline void clear_cached_web_credentials();
@@ -558,14 +532,8 @@ class TC_PROTO_API LogonRequest : public ::google::protobuf::Message {
   inline void clear_has_application_version();
   inline void set_has_public_computer();
   inline void clear_has_public_computer();
-  inline void set_has_sso_id();
-  inline void clear_has_sso_id();
-  inline void set_has_disconnect_on_cookie_fail();
-  inline void clear_has_disconnect_on_cookie_fail();
   inline void set_has_allow_logon_queue_notifications();
   inline void clear_has_allow_logon_queue_notifications();
-  inline void set_has_web_client_verification();
-  inline void clear_has_web_client_verification();
   inline void set_has_cached_web_credentials();
   inline void clear_has_cached_web_credentials();
   inline void set_has_user_agent();
@@ -582,12 +550,9 @@ class TC_PROTO_API LogonRequest : public ::google::protobuf::Message {
   ::std::string* locale_;
   ::std::string* email_;
   ::std::string* version_;
-  ::std::string* sso_id_;
   ::google::protobuf::int32 application_version_;
   bool public_computer_;
-  bool disconnect_on_cookie_fail_;
   bool allow_logon_queue_notifications_;
-  bool web_client_verification_;
   ::std::string* cached_web_credentials_;
   ::std::string* user_agent_;
   ::std::string* device_id_;
@@ -2975,115 +2940,15 @@ inline void LogonRequest::set_public_computer(bool value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.public_computer)
 }
 
-// optional bytes sso_id = 8;
-inline bool LogonRequest::has_sso_id() const {
-  return (_has_bits_[0] & 0x00000080u) != 0;
-}
-inline void LogonRequest::set_has_sso_id() {
-  _has_bits_[0] |= 0x00000080u;
-}
-inline void LogonRequest::clear_has_sso_id() {
-  _has_bits_[0] &= ~0x00000080u;
-}
-inline void LogonRequest::clear_sso_id() {
-  if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    sso_id_->clear();
-  }
-  clear_has_sso_id();
-}
-inline const ::std::string& LogonRequest::sso_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.sso_id)
-  return *sso_id_;
-}
-inline void LogonRequest::set_sso_id(const ::std::string& value) {
-  set_has_sso_id();
-  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    sso_id_ = new ::std::string;
-  }
-  sso_id_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.sso_id)
-}
-inline void LogonRequest::set_sso_id(const char* value) {
-  set_has_sso_id();
-  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    sso_id_ = new ::std::string;
-  }
-  sso_id_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.sso_id)
-}
-inline void LogonRequest::set_sso_id(const void* value, size_t size) {
-  set_has_sso_id();
-  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    sso_id_ = new ::std::string;
-  }
-  sso_id_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.sso_id)
-}
-inline ::std::string* LogonRequest::mutable_sso_id() {
-  set_has_sso_id();
-  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    sso_id_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.sso_id)
-  return sso_id_;
-}
-inline ::std::string* LogonRequest::release_sso_id() {
-  clear_has_sso_id();
-  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = sso_id_;
-    sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void LogonRequest::set_allocated_sso_id(::std::string* sso_id) {
-  if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete sso_id_;
-  }
-  if (sso_id) {
-    set_has_sso_id();
-    sso_id_ = sso_id;
-  } else {
-    clear_has_sso_id();
-    sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.sso_id)
-}
-
-// optional bool disconnect_on_cookie_fail = 9 [default = false];
-inline bool LogonRequest::has_disconnect_on_cookie_fail() const {
-  return (_has_bits_[0] & 0x00000100u) != 0;
-}
-inline void LogonRequest::set_has_disconnect_on_cookie_fail() {
-  _has_bits_[0] |= 0x00000100u;
-}
-inline void LogonRequest::clear_has_disconnect_on_cookie_fail() {
-  _has_bits_[0] &= ~0x00000100u;
-}
-inline void LogonRequest::clear_disconnect_on_cookie_fail() {
-  disconnect_on_cookie_fail_ = false;
-  clear_has_disconnect_on_cookie_fail();
-}
-inline bool LogonRequest::disconnect_on_cookie_fail() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.disconnect_on_cookie_fail)
-  return disconnect_on_cookie_fail_;
-}
-inline void LogonRequest::set_disconnect_on_cookie_fail(bool value) {
-  set_has_disconnect_on_cookie_fail();
-  disconnect_on_cookie_fail_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.disconnect_on_cookie_fail)
-}
-
 // optional bool allow_logon_queue_notifications = 10 [default = false];
 inline bool LogonRequest::has_allow_logon_queue_notifications() const {
-  return (_has_bits_[0] & 0x00000200u) != 0;
+  return (_has_bits_[0] & 0x00000080u) != 0;
 }
 inline void LogonRequest::set_has_allow_logon_queue_notifications() {
-  _has_bits_[0] |= 0x00000200u;
+  _has_bits_[0] |= 0x00000080u;
 }
 inline void LogonRequest::clear_has_allow_logon_queue_notifications() {
-  _has_bits_[0] &= ~0x00000200u;
+  _has_bits_[0] &= ~0x00000080u;
 }
 inline void LogonRequest::clear_allow_logon_queue_notifications() {
   allow_logon_queue_notifications_ = false;
@@ -3099,39 +2964,15 @@ inline void LogonRequest::set_allow_logon_queue_notifications(bool value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.allow_logon_queue_notifications)
 }
 
-// optional bool web_client_verification = 11 [default = false];
-inline bool LogonRequest::has_web_client_verification() const {
-  return (_has_bits_[0] & 0x00000400u) != 0;
-}
-inline void LogonRequest::set_has_web_client_verification() {
-  _has_bits_[0] |= 0x00000400u;
-}
-inline void LogonRequest::clear_has_web_client_verification() {
-  _has_bits_[0] &= ~0x00000400u;
-}
-inline void LogonRequest::clear_web_client_verification() {
-  web_client_verification_ = false;
-  clear_has_web_client_verification();
-}
-inline bool LogonRequest::web_client_verification() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.web_client_verification)
-  return web_client_verification_;
-}
-inline void LogonRequest::set_web_client_verification(bool value) {
-  set_has_web_client_verification();
-  web_client_verification_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.web_client_verification)
-}
-
 // optional bytes cached_web_credentials = 12;
 inline bool LogonRequest::has_cached_web_credentials() const {
-  return (_has_bits_[0] & 0x00000800u) != 0;
+  return (_has_bits_[0] & 0x00000100u) != 0;
 }
 inline void LogonRequest::set_has_cached_web_credentials() {
-  _has_bits_[0] |= 0x00000800u;
+  _has_bits_[0] |= 0x00000100u;
 }
 inline void LogonRequest::clear_has_cached_web_credentials() {
-  _has_bits_[0] &= ~0x00000800u;
+  _has_bits_[0] &= ~0x00000100u;
 }
 inline void LogonRequest::clear_cached_web_credentials() {
   if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
@@ -3201,13 +3042,13 @@ inline void LogonRequest::set_allocated_cached_web_credentials(::std::string* ca
 
 // optional string user_agent = 14;
 inline bool LogonRequest::has_user_agent() const {
-  return (_has_bits_[0] & 0x00001000u) != 0;
+  return (_has_bits_[0] & 0x00000200u) != 0;
 }
 inline void LogonRequest::set_has_user_agent() {
-  _has_bits_[0] |= 0x00001000u;
+  _has_bits_[0] |= 0x00000200u;
 }
 inline void LogonRequest::clear_has_user_agent() {
-  _has_bits_[0] &= ~0x00001000u;
+  _has_bits_[0] &= ~0x00000200u;
 }
 inline void LogonRequest::clear_user_agent() {
   if (user_agent_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
@@ -3277,13 +3118,13 @@ inline void LogonRequest::set_allocated_user_agent(::std::string* user_agent) {
 
 // optional string device_id = 15;
 inline bool LogonRequest::has_device_id() const {
-  return (_has_bits_[0] & 0x00002000u) != 0;
+  return (_has_bits_[0] & 0x00000400u) != 0;
 }
 inline void LogonRequest::set_has_device_id() {
-  _has_bits_[0] |= 0x00002000u;
+  _has_bits_[0] |= 0x00000400u;
 }
 inline void LogonRequest::clear_has_device_id() {
-  _has_bits_[0] &= ~0x00002000u;
+  _has_bits_[0] &= ~0x00000400u;
 }
 inline void LogonRequest::clear_device_id() {
   if (device_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
diff --git a/src/server/proto/Client/challenge_service.pb.cc b/src/server/proto/Client/challenge_service.pb.cc
index 257a27eb289..b710ef26e3a 100644
--- a/src/server/proto/Client/challenge_service.pb.cc
+++ b/src/server/proto/Client/challenge_service.pb.cc
@@ -27,43 +27,12 @@ namespace v1 {
 
 namespace {
 
-const ::google::protobuf::Descriptor* Challenge_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  Challenge_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ChallengePickedRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ChallengePickedRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ChallengePickedResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ChallengePickedResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ChallengeAnsweredRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ChallengeAnsweredRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ChallengeAnsweredResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ChallengeAnsweredResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ChallengeCancelledRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ChallengeCancelledRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* SendChallengeToUserRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  SendChallengeToUserRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* SendChallengeToUserResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  SendChallengeToUserResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ChallengeUserRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ChallengeUserRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ChallengeResultRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ChallengeResultRequest_reflection_ = NULL;
 const ::google::protobuf::Descriptor* ChallengeExternalRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   ChallengeExternalRequest_reflection_ = NULL;
 const ::google::protobuf::Descriptor* ChallengeExternalResult_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   ChallengeExternalResult_reflection_ = NULL;
-const ::google::protobuf::ServiceDescriptor* ChallengeService_descriptor_ = NULL;
 const ::google::protobuf::ServiceDescriptor* ChallengeListener_descriptor_ = NULL;
 
 }  // namespace
@@ -75,181 +44,7 @@ void protobuf_AssignDesc_challenge_5fservice_2eproto() {
     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
       "challenge_service.proto");
   GOOGLE_CHECK(file != NULL);
-  Challenge_descriptor_ = file->message_type(0);
-  static const int Challenge_offsets_[4] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, type_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, info_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, answer_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, retries_),
-  };
-  Challenge_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      Challenge_descriptor_,
-      Challenge::default_instance_,
-      Challenge_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(Challenge));
-  ChallengePickedRequest_descriptor_ = file->message_type(1);
-  static const int ChallengePickedRequest_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, challenge_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, new_challenge_protocol_),
-  };
-  ChallengePickedRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ChallengePickedRequest_descriptor_,
-      ChallengePickedRequest::default_instance_,
-      ChallengePickedRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ChallengePickedRequest));
-  ChallengePickedResponse_descriptor_ = file->message_type(2);
-  static const int ChallengePickedResponse_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedResponse, data_),
-  };
-  ChallengePickedResponse_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ChallengePickedResponse_descriptor_,
-      ChallengePickedResponse::default_instance_,
-      ChallengePickedResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedResponse, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ChallengePickedResponse));
-  ChallengeAnsweredRequest_descriptor_ = file->message_type(3);
-  static const int ChallengeAnsweredRequest_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, answer_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, data_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, id_),
-  };
-  ChallengeAnsweredRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ChallengeAnsweredRequest_descriptor_,
-      ChallengeAnsweredRequest::default_instance_,
-      ChallengeAnsweredRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ChallengeAnsweredRequest));
-  ChallengeAnsweredResponse_descriptor_ = file->message_type(4);
-  static const int ChallengeAnsweredResponse_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, data_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, do_retry_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, record_not_found_),
-  };
-  ChallengeAnsweredResponse_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ChallengeAnsweredResponse_descriptor_,
-      ChallengeAnsweredResponse::default_instance_,
-      ChallengeAnsweredResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ChallengeAnsweredResponse));
-  ChallengeCancelledRequest_descriptor_ = file->message_type(5);
-  static const int ChallengeCancelledRequest_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeCancelledRequest, id_),
-  };
-  ChallengeCancelledRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ChallengeCancelledRequest_descriptor_,
-      ChallengeCancelledRequest::default_instance_,
-      ChallengeCancelledRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeCancelledRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeCancelledRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ChallengeCancelledRequest));
-  SendChallengeToUserRequest_descriptor_ = file->message_type(6);
-  static const int SendChallengeToUserRequest_offsets_[8] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, peer_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, game_account_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, challenges_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, context_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, timeout_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, attributes_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, host_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, account_id_),
-  };
-  SendChallengeToUserRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      SendChallengeToUserRequest_descriptor_,
-      SendChallengeToUserRequest::default_instance_,
-      SendChallengeToUserRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(SendChallengeToUserRequest));
-  SendChallengeToUserResponse_descriptor_ = file->message_type(7);
-  static const int SendChallengeToUserResponse_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserResponse, id_),
-  };
-  SendChallengeToUserResponse_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      SendChallengeToUserResponse_descriptor_,
-      SendChallengeToUserResponse::default_instance_,
-      SendChallengeToUserResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserResponse, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(SendChallengeToUserResponse));
-  ChallengeUserRequest_descriptor_ = file->message_type(8);
-  static const int ChallengeUserRequest_offsets_[6] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, challenges_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, context_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, deadline_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, attributes_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, game_account_id_),
-  };
-  ChallengeUserRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ChallengeUserRequest_descriptor_,
-      ChallengeUserRequest::default_instance_,
-      ChallengeUserRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ChallengeUserRequest));
-  ChallengeResultRequest_descriptor_ = file->message_type(9);
-  static const int ChallengeResultRequest_offsets_[4] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, type_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, error_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, answer_),
-  };
-  ChallengeResultRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ChallengeResultRequest_descriptor_,
-      ChallengeResultRequest::default_instance_,
-      ChallengeResultRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ChallengeResultRequest));
-  ChallengeExternalRequest_descriptor_ = file->message_type(10);
+  ChallengeExternalRequest_descriptor_ = file->message_type(0);
   static const int ChallengeExternalRequest_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, request_token_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, payload_type_),
@@ -266,7 +61,7 @@ void protobuf_AssignDesc_challenge_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ChallengeExternalRequest));
-  ChallengeExternalResult_descriptor_ = file->message_type(11);
+  ChallengeExternalResult_descriptor_ = file->message_type(1);
   static const int ChallengeExternalResult_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, request_token_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, passed_),
@@ -282,8 +77,7 @@ void protobuf_AssignDesc_challenge_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ChallengeExternalResult));
-  ChallengeService_descriptor_ = file->service(0);
-  ChallengeListener_descriptor_ = file->service(1);
+  ChallengeListener_descriptor_ = file->service(0);
 }
 
 namespace {
@@ -297,26 +91,6 @@ inline void protobuf_AssignDescriptorsOnce() {
 void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    Challenge_descriptor_, &Challenge::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ChallengePickedRequest_descriptor_, &ChallengePickedRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ChallengePickedResponse_descriptor_, &ChallengePickedResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ChallengeAnsweredRequest_descriptor_, &ChallengeAnsweredRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ChallengeAnsweredResponse_descriptor_, &ChallengeAnsweredResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ChallengeCancelledRequest_descriptor_, &ChallengeCancelledRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    SendChallengeToUserRequest_descriptor_, &SendChallengeToUserRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    SendChallengeToUserResponse_descriptor_, &SendChallengeToUserResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ChallengeUserRequest_descriptor_, &ChallengeUserRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ChallengeResultRequest_descriptor_, &ChallengeResultRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     ChallengeExternalRequest_descriptor_, &ChallengeExternalRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     ChallengeExternalResult_descriptor_, &ChallengeExternalResult::default_instance());
@@ -325,26 +99,6 @@ void protobuf_RegisterTypes(const ::std::string&) {
 }  // namespace
 
 void protobuf_ShutdownFile_challenge_5fservice_2eproto() {
-  delete Challenge::default_instance_;
-  delete Challenge_reflection_;
-  delete ChallengePickedRequest::default_instance_;
-  delete ChallengePickedRequest_reflection_;
-  delete ChallengePickedResponse::default_instance_;
-  delete ChallengePickedResponse_reflection_;
-  delete ChallengeAnsweredRequest::default_instance_;
-  delete ChallengeAnsweredRequest_reflection_;
-  delete ChallengeAnsweredResponse::default_instance_;
-  delete ChallengeAnsweredResponse_reflection_;
-  delete ChallengeCancelledRequest::default_instance_;
-  delete ChallengeCancelledRequest_reflection_;
-  delete SendChallengeToUserRequest::default_instance_;
-  delete SendChallengeToUserRequest_reflection_;
-  delete SendChallengeToUserResponse::default_instance_;
-  delete SendChallengeToUserResponse_reflection_;
-  delete ChallengeUserRequest::default_instance_;
-  delete ChallengeUserRequest_reflection_;
-  delete ChallengeResultRequest::default_instance_;
-  delete ChallengeResultRequest_reflection_;
   delete ChallengeExternalRequest::default_instance_;
   delete ChallengeExternalRequest_reflection_;
   delete ChallengeExternalResult::default_instance_;
@@ -357,97 +111,26 @@ void protobuf_AddDesc_challenge_5fservice_2eproto() {
   already_here = true;
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
-  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
-  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
   ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\027challenge_service.proto\022\031bgs.protocol."
-    "challenge.v1\032\025attribute_types.proto\032\022ent"
-    "ity_types.proto\032\017rpc_types.proto\"N\n\tChal"
-    "lenge\022\014\n\004type\030\001 \002(\007\022\014\n\004info\030\002 \001(\t\022\024\n\006ans"
-    "wer\030\003 \001(\tB\004\200\265\030\001\022\017\n\007retries\030\004 \001(\r\"^\n\026Chal"
-    "lengePickedRequest\022\021\n\tchallenge\030\001 \002(\007\022\n\n"
-    "\002id\030\002 \001(\r\022%\n\026new_challenge_protocol\030\003 \001("
-    "\010:\005false\"-\n\027ChallengePickedResponse\022\022\n\004d"
-    "ata\030\001 \001(\014B\004\200\265\030\001\"P\n\030ChallengeAnsweredRequ"
-    "est\022\024\n\006answer\030\001 \002(\tB\004\200\265\030\001\022\022\n\004data\030\002 \001(\014B"
-    "\004\200\265\030\001\022\n\n\002id\030\003 \001(\r\"[\n\031ChallengeAnsweredRe"
-    "sponse\022\022\n\004data\030\001 \001(\014B\004\200\265\030\001\022\020\n\010do_retry\030\002"
-    " \001(\010\022\030\n\020record_not_found\030\003 \001(\010\"\'\n\031Challe"
-    "ngeCancelledRequest\022\n\n\002id\030\001 \001(\r\"\323\002\n\032Send"
-    "ChallengeToUserRequest\022(\n\007peer_id\030\001 \001(\0132"
-    "\027.bgs.protocol.ProcessId\022/\n\017game_account"
-    "_id\030\002 \001(\0132\026.bgs.protocol.EntityId\0228\n\ncha"
-    "llenges\030\003 \003(\0132$.bgs.protocol.challenge.v"
-    "1.Challenge\022\017\n\007context\030\004 \002(\007\022\017\n\007timeout\030"
-    "\005 \001(\004\022+\n\nattributes\030\006 \003(\0132\027.bgs.protocol"
-    ".Attribute\022%\n\004host\030\007 \001(\0132\027.bgs.protocol."
-    "ProcessId\022*\n\naccount_id\030\010 \001(\0132\026.bgs.prot"
-    "ocol.EntityId\")\n\033SendChallengeToUserResp"
-    "onse\022\n\n\002id\030\001 \001(\r\"\335\001\n\024ChallengeUserReques"
-    "t\0228\n\nchallenges\030\001 \003(\0132$.bgs.protocol.cha"
-    "llenge.v1.Challenge\022\017\n\007context\030\002 \002(\007\022\n\n\002"
-    "id\030\003 \001(\r\022\020\n\010deadline\030\004 \001(\004\022+\n\nattributes"
-    "\030\005 \003(\0132\027.bgs.protocol.Attribute\022/\n\017game_"
-    "account_id\030\006 \001(\0132\026.bgs.protocol.EntityId"
-    "\"Z\n\026ChallengeResultRequest\022\n\n\002id\030\001 \001(\r\022\014"
-    "\n\004type\030\002 \001(\007\022\020\n\010error_id\030\003 \001(\r\022\024\n\006answer"
-    "\030\004 \001(\014B\004\200\265\030\001\"X\n\030ChallengeExternalRequest"
-    "\022\025\n\rrequest_token\030\001 \001(\t\022\024\n\014payload_type\030"
-    "\002 \001(\t\022\017\n\007payload\030\003 \001(\014\"F\n\027ChallengeExter"
-    "nalResult\022\025\n\rrequest_token\030\001 \001(\t\022\024\n\006pass"
-    "ed\030\002 \001(\010:\004true2\273\004\n\020ChallengeService\022~\n\017C"
-    "hallengePicked\0221.bgs.protocol.challenge."
-    "v1.ChallengePickedRequest\0322.bgs.protocol"
-    ".challenge.v1.ChallengePickedResponse\"\004\200"
-    "\265\030\001\022\204\001\n\021ChallengeAnswered\0223.bgs.protocol"
-    ".challenge.v1.ChallengeAnsweredRequest\0324"
-    ".bgs.protocol.challenge.v1.ChallengeAnsw"
-    "eredResponse\"\004\200\265\030\002\022f\n\022ChallengeCancelled"
-    "\0224.bgs.protocol.challenge.v1.ChallengeCa"
-    "ncelledRequest\032\024.bgs.protocol.NoData\"\004\200\265"
-    "\030\003\022\212\001\n\023SendChallengeToUser\0225.bgs.protoco"
-    "l.challenge.v1.SendChallengeToUserReques"
-    "t\0326.bgs.protocol.challenge.v1.SendChalle"
-    "ngeToUserResponse\"\004\200\265\030\004\032+\312>(bnet.protoco"
-    "l.challenge.ChallengeService2\354\003\n\021Challen"
-    "geListener\022c\n\017OnChallengeUser\022/.bgs.prot"
-    "ocol.challenge.v1.ChallengeUserRequest\032\031"
-    ".bgs.protocol.NO_RESPONSE\"\004\200\265\030\001\022g\n\021OnCha"
-    "llengeResult\0221.bgs.protocol.challenge.v1"
-    ".ChallengeResultRequest\032\031.bgs.protocol.N"
-    "O_RESPONSE\"\004\200\265\030\002\022k\n\023OnExternalChallenge\022"
-    "3.bgs.protocol.challenge.v1.ChallengeExt"
-    "ernalRequest\032\031.bgs.protocol.NO_RESPONSE\""
-    "\004\200\265\030\003\022p\n\031OnExternalChallengeResult\0222.bgs"
-    ".protocol.challenge.v1.ChallengeExternal"
-    "Result\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\004\032"
-    "*\312>\'bnet.protocol.challenge.ChallengeNot"
-    "ifyB\005H\001\200\001\000", 2490);
+    "challenge.v1\032\017rpc_types.proto\"X\n\030Challen"
+    "geExternalRequest\022\025\n\rrequest_token\030\001 \001(\t"
+    "\022\024\n\014payload_type\030\002 \001(\t\022\017\n\007payload\030\003 \001(\014\""
+    "F\n\027ChallengeExternalResult\022\025\n\rrequest_to"
+    "ken\030\001 \001(\t\022\024\n\006passed\030\002 \001(\010:\004true2\253\002\n\021Chal"
+    "lengeListener\022m\n\023OnExternalChallenge\0223.b"
+    "gs.protocol.challenge.v1.ChallengeExtern"
+    "alRequest\032\031.bgs.protocol.NO_RESPONSE\"\006\202\371"
+    "+\002\010\003\022r\n\031OnExternalChallengeResult\0222.bgs."
+    "protocol.challenge.v1.ChallengeExternalR"
+    "esult\032\031.bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010\004"
+    "\0323\202\371+)\n\'bnet.protocol.challenge.Challeng"
+    "eNotify\212\371+\002\010\001B\005H\001\200\001\000", 540);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "challenge_service.proto", &protobuf_RegisterTypes);
-  Challenge::default_instance_ = new Challenge();
-  ChallengePickedRequest::default_instance_ = new ChallengePickedRequest();
-  ChallengePickedResponse::default_instance_ = new ChallengePickedResponse();
-  ChallengeAnsweredRequest::default_instance_ = new ChallengeAnsweredRequest();
-  ChallengeAnsweredResponse::default_instance_ = new ChallengeAnsweredResponse();
-  ChallengeCancelledRequest::default_instance_ = new ChallengeCancelledRequest();
-  SendChallengeToUserRequest::default_instance_ = new SendChallengeToUserRequest();
-  SendChallengeToUserResponse::default_instance_ = new SendChallengeToUserResponse();
-  ChallengeUserRequest::default_instance_ = new ChallengeUserRequest();
-  ChallengeResultRequest::default_instance_ = new ChallengeResultRequest();
   ChallengeExternalRequest::default_instance_ = new ChallengeExternalRequest();
   ChallengeExternalResult::default_instance_ = new ChallengeExternalResult();
-  Challenge::default_instance_->InitAsDefaultInstance();
-  ChallengePickedRequest::default_instance_->InitAsDefaultInstance();
-  ChallengePickedResponse::default_instance_->InitAsDefaultInstance();
-  ChallengeAnsweredRequest::default_instance_->InitAsDefaultInstance();
-  ChallengeAnsweredResponse::default_instance_->InitAsDefaultInstance();
-  ChallengeCancelledRequest::default_instance_->InitAsDefaultInstance();
-  SendChallengeToUserRequest::default_instance_->InitAsDefaultInstance();
-  SendChallengeToUserResponse::default_instance_->InitAsDefaultInstance();
-  ChallengeUserRequest::default_instance_->InitAsDefaultInstance();
-  ChallengeResultRequest::default_instance_->InitAsDefaultInstance();
   ChallengeExternalRequest::default_instance_->InitAsDefaultInstance();
   ChallengeExternalResult::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_challenge_5fservice_2eproto);
@@ -463,3368 +146,6 @@ struct StaticDescriptorInitializer_challenge_5fservice_2eproto {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int Challenge::kTypeFieldNumber;
-const int Challenge::kInfoFieldNumber;
-const int Challenge::kAnswerFieldNumber;
-const int Challenge::kRetriesFieldNumber;
-#endif  // !_MSC_VER
-
-Challenge::Challenge()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.Challenge)
-}
-
-void Challenge::InitAsDefaultInstance() {
-}
-
-Challenge::Challenge(const Challenge& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.Challenge)
-}
-
-void Challenge::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  type_ = 0u;
-  info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  retries_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-Challenge::~Challenge() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.Challenge)
-  SharedDtor();
-}
-
-void Challenge::SharedDtor() {
-  if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete info_;
-  }
-  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete answer_;
-  }
-  if (this != default_instance_) {
-  }
-}
-
-void Challenge::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* Challenge::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return Challenge_descriptor_;
-}
-
-const Challenge& Challenge::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-Challenge* Challenge::default_instance_ = NULL;
-
-Challenge* Challenge::New() const {
-  return new Challenge;
-}
-
-void Challenge::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<Challenge*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 15) {
-    ZR_(type_, retries_);
-    if (has_info()) {
-      if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        info_->clear();
-      }
-    }
-    if (has_answer()) {
-      if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        answer_->clear();
-      }
-    }
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool Challenge::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.Challenge)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required fixed32 type = 1;
-      case 1: {
-        if (tag == 13) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &type_)));
-          set_has_type();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_info;
-        break;
-      }
-
-      // optional string info = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_info:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_info()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->info().data(), this->info().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "info");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_answer;
-        break;
-      }
-
-      // optional string answer = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_answer:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_answer()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->answer().data(), this->answer().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "answer");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(32)) goto parse_retries;
-        break;
-      }
-
-      // optional uint32 retries = 4;
-      case 4: {
-        if (tag == 32) {
-         parse_retries:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &retries_)));
-          set_has_retries();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.Challenge)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.Challenge)
-  return false;
-#undef DO_
-}
-
-void Challenge::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.Challenge)
-  // required fixed32 type = 1;
-  if (has_type()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->type(), output);
-  }
-
-  // optional string info = 2;
-  if (has_info()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->info().data(), this->info().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "info");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->info(), output);
-  }
-
-  // optional string answer = 3;
-  if (has_answer()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->answer().data(), this->answer().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "answer");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      3, this->answer(), output);
-  }
-
-  // optional uint32 retries = 4;
-  if (has_retries()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->retries(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.Challenge)
-}
-
-::google::protobuf::uint8* Challenge::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.Challenge)
-  // required fixed32 type = 1;
-  if (has_type()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->type(), target);
-  }
-
-  // optional string info = 2;
-  if (has_info()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->info().data(), this->info().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "info");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->info(), target);
-  }
-
-  // optional string answer = 3;
-  if (has_answer()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->answer().data(), this->answer().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "answer");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        3, this->answer(), target);
-  }
-
-  // optional uint32 retries = 4;
-  if (has_retries()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->retries(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.Challenge)
-  return target;
-}
-
-int Challenge::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required fixed32 type = 1;
-    if (has_type()) {
-      total_size += 1 + 4;
-    }
-
-    // optional string info = 2;
-    if (has_info()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->info());
-    }
-
-    // optional string answer = 3;
-    if (has_answer()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->answer());
-    }
-
-    // optional uint32 retries = 4;
-    if (has_retries()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->retries());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void Challenge::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const Challenge* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const Challenge*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void Challenge::MergeFrom(const Challenge& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_type()) {
-      set_type(from.type());
-    }
-    if (from.has_info()) {
-      set_info(from.info());
-    }
-    if (from.has_answer()) {
-      set_answer(from.answer());
-    }
-    if (from.has_retries()) {
-      set_retries(from.retries());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void Challenge::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void Challenge::CopyFrom(const Challenge& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool Challenge::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
-  return true;
-}
-
-void Challenge::Swap(Challenge* other) {
-  if (other != this) {
-    std::swap(type_, other->type_);
-    std::swap(info_, other->info_);
-    std::swap(answer_, other->answer_);
-    std::swap(retries_, other->retries_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata Challenge::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = Challenge_descriptor_;
-  metadata.reflection = Challenge_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int ChallengePickedRequest::kChallengeFieldNumber;
-const int ChallengePickedRequest::kIdFieldNumber;
-const int ChallengePickedRequest::kNewChallengeProtocolFieldNumber;
-#endif  // !_MSC_VER
-
-ChallengePickedRequest::ChallengePickedRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengePickedRequest)
-}
-
-void ChallengePickedRequest::InitAsDefaultInstance() {
-}
-
-ChallengePickedRequest::ChallengePickedRequest(const ChallengePickedRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengePickedRequest)
-}
-
-void ChallengePickedRequest::SharedCtor() {
-  _cached_size_ = 0;
-  challenge_ = 0u;
-  id_ = 0u;
-  new_challenge_protocol_ = false;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ChallengePickedRequest::~ChallengePickedRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengePickedRequest)
-  SharedDtor();
-}
-
-void ChallengePickedRequest::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void ChallengePickedRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ChallengePickedRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChallengePickedRequest_descriptor_;
-}
-
-const ChallengePickedRequest& ChallengePickedRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-ChallengePickedRequest* ChallengePickedRequest::default_instance_ = NULL;
-
-ChallengePickedRequest* ChallengePickedRequest::New() const {
-  return new ChallengePickedRequest;
-}
-
-void ChallengePickedRequest::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<ChallengePickedRequest*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  ZR_(challenge_, new_challenge_protocol_);
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool ChallengePickedRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengePickedRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required fixed32 challenge = 1;
-      case 1: {
-        if (tag == 13) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &challenge_)));
-          set_has_challenge();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(16)) goto parse_id;
-        break;
-      }
-
-      // optional uint32 id = 2;
-      case 2: {
-        if (tag == 16) {
-         parse_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &id_)));
-          set_has_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_new_challenge_protocol;
-        break;
-      }
-
-      // optional bool new_challenge_protocol = 3 [default = false];
-      case 3: {
-        if (tag == 24) {
-         parse_new_challenge_protocol:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &new_challenge_protocol_)));
-          set_has_new_challenge_protocol();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengePickedRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengePickedRequest)
-  return false;
-#undef DO_
-}
-
-void ChallengePickedRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengePickedRequest)
-  // required fixed32 challenge = 1;
-  if (has_challenge()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->challenge(), output);
-  }
-
-  // optional uint32 id = 2;
-  if (has_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->id(), output);
-  }
-
-  // optional bool new_challenge_protocol = 3 [default = false];
-  if (has_new_challenge_protocol()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->new_challenge_protocol(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengePickedRequest)
-}
-
-::google::protobuf::uint8* ChallengePickedRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengePickedRequest)
-  // required fixed32 challenge = 1;
-  if (has_challenge()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->challenge(), target);
-  }
-
-  // optional uint32 id = 2;
-  if (has_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->id(), target);
-  }
-
-  // optional bool new_challenge_protocol = 3 [default = false];
-  if (has_new_challenge_protocol()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->new_challenge_protocol(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengePickedRequest)
-  return target;
-}
-
-int ChallengePickedRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required fixed32 challenge = 1;
-    if (has_challenge()) {
-      total_size += 1 + 4;
-    }
-
-    // optional uint32 id = 2;
-    if (has_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->id());
-    }
-
-    // optional bool new_challenge_protocol = 3 [default = false];
-    if (has_new_challenge_protocol()) {
-      total_size += 1 + 1;
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ChallengePickedRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ChallengePickedRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengePickedRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ChallengePickedRequest::MergeFrom(const ChallengePickedRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_challenge()) {
-      set_challenge(from.challenge());
-    }
-    if (from.has_id()) {
-      set_id(from.id());
-    }
-    if (from.has_new_challenge_protocol()) {
-      set_new_challenge_protocol(from.new_challenge_protocol());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ChallengePickedRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ChallengePickedRequest::CopyFrom(const ChallengePickedRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ChallengePickedRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
-  return true;
-}
-
-void ChallengePickedRequest::Swap(ChallengePickedRequest* other) {
-  if (other != this) {
-    std::swap(challenge_, other->challenge_);
-    std::swap(id_, other->id_);
-    std::swap(new_challenge_protocol_, other->new_challenge_protocol_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ChallengePickedRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ChallengePickedRequest_descriptor_;
-  metadata.reflection = ChallengePickedRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int ChallengePickedResponse::kDataFieldNumber;
-#endif  // !_MSC_VER
-
-ChallengePickedResponse::ChallengePickedResponse()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengePickedResponse)
-}
-
-void ChallengePickedResponse::InitAsDefaultInstance() {
-}
-
-ChallengePickedResponse::ChallengePickedResponse(const ChallengePickedResponse& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengePickedResponse)
-}
-
-void ChallengePickedResponse::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ChallengePickedResponse::~ChallengePickedResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengePickedResponse)
-  SharedDtor();
-}
-
-void ChallengePickedResponse::SharedDtor() {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete data_;
-  }
-  if (this != default_instance_) {
-  }
-}
-
-void ChallengePickedResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ChallengePickedResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChallengePickedResponse_descriptor_;
-}
-
-const ChallengePickedResponse& ChallengePickedResponse::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-ChallengePickedResponse* ChallengePickedResponse::default_instance_ = NULL;
-
-ChallengePickedResponse* ChallengePickedResponse::New() const {
-  return new ChallengePickedResponse;
-}
-
-void ChallengePickedResponse::Clear() {
-  if (has_data()) {
-    if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-      data_->clear();
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool ChallengePickedResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengePickedResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional bytes data = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
-                input, this->mutable_data()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengePickedResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengePickedResponse)
-  return false;
-#undef DO_
-}
-
-void ChallengePickedResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengePickedResponse)
-  // optional bytes data = 1;
-  if (has_data()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
-      1, this->data(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengePickedResponse)
-}
-
-::google::protobuf::uint8* ChallengePickedResponse::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengePickedResponse)
-  // optional bytes data = 1;
-  if (has_data()) {
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
-        1, this->data(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengePickedResponse)
-  return target;
-}
-
-int ChallengePickedResponse::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional bytes data = 1;
-    if (has_data()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::BytesSize(
-          this->data());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ChallengePickedResponse::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ChallengePickedResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengePickedResponse*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ChallengePickedResponse::MergeFrom(const ChallengePickedResponse& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_data()) {
-      set_data(from.data());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ChallengePickedResponse::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ChallengePickedResponse::CopyFrom(const ChallengePickedResponse& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ChallengePickedResponse::IsInitialized() const {
-
-  return true;
-}
-
-void ChallengePickedResponse::Swap(ChallengePickedResponse* other) {
-  if (other != this) {
-    std::swap(data_, other->data_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ChallengePickedResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ChallengePickedResponse_descriptor_;
-  metadata.reflection = ChallengePickedResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int ChallengeAnsweredRequest::kAnswerFieldNumber;
-const int ChallengeAnsweredRequest::kDataFieldNumber;
-const int ChallengeAnsweredRequest::kIdFieldNumber;
-#endif  // !_MSC_VER
-
-ChallengeAnsweredRequest::ChallengeAnsweredRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-}
-
-void ChallengeAnsweredRequest::InitAsDefaultInstance() {
-}
-
-ChallengeAnsweredRequest::ChallengeAnsweredRequest(const ChallengeAnsweredRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-}
-
-void ChallengeAnsweredRequest::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  id_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ChallengeAnsweredRequest::~ChallengeAnsweredRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-  SharedDtor();
-}
-
-void ChallengeAnsweredRequest::SharedDtor() {
-  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete answer_;
-  }
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete data_;
-  }
-  if (this != default_instance_) {
-  }
-}
-
-void ChallengeAnsweredRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ChallengeAnsweredRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChallengeAnsweredRequest_descriptor_;
-}
-
-const ChallengeAnsweredRequest& ChallengeAnsweredRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-ChallengeAnsweredRequest* ChallengeAnsweredRequest::default_instance_ = NULL;
-
-ChallengeAnsweredRequest* ChallengeAnsweredRequest::New() const {
-  return new ChallengeAnsweredRequest;
-}
-
-void ChallengeAnsweredRequest::Clear() {
-  if (_has_bits_[0 / 32] & 7) {
-    if (has_answer()) {
-      if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        answer_->clear();
-      }
-    }
-    if (has_data()) {
-      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        data_->clear();
-      }
-    }
-    id_ = 0u;
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool ChallengeAnsweredRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required string answer = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_answer()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->answer().data(), this->answer().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "answer");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_data;
-        break;
-      }
-
-      // optional bytes data = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_data:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
-                input, this->mutable_data()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_id;
-        break;
-      }
-
-      // optional uint32 id = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &id_)));
-          set_has_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-  return false;
-#undef DO_
-}
-
-void ChallengeAnsweredRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-  // required string answer = 1;
-  if (has_answer()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->answer().data(), this->answer().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "answer");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->answer(), output);
-  }
-
-  // optional bytes data = 2;
-  if (has_data()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
-      2, this->data(), output);
-  }
-
-  // optional uint32 id = 3;
-  if (has_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->id(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-}
-
-::google::protobuf::uint8* ChallengeAnsweredRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-  // required string answer = 1;
-  if (has_answer()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->answer().data(), this->answer().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "answer");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->answer(), target);
-  }
-
-  // optional bytes data = 2;
-  if (has_data()) {
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
-        2, this->data(), target);
-  }
-
-  // optional uint32 id = 3;
-  if (has_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->id(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
-  return target;
-}
-
-int ChallengeAnsweredRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required string answer = 1;
-    if (has_answer()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->answer());
-    }
-
-    // optional bytes data = 2;
-    if (has_data()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::BytesSize(
-          this->data());
-    }
-
-    // optional uint32 id = 3;
-    if (has_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->id());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ChallengeAnsweredRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ChallengeAnsweredRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeAnsweredRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ChallengeAnsweredRequest::MergeFrom(const ChallengeAnsweredRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_answer()) {
-      set_answer(from.answer());
-    }
-    if (from.has_data()) {
-      set_data(from.data());
-    }
-    if (from.has_id()) {
-      set_id(from.id());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ChallengeAnsweredRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ChallengeAnsweredRequest::CopyFrom(const ChallengeAnsweredRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ChallengeAnsweredRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
-  return true;
-}
-
-void ChallengeAnsweredRequest::Swap(ChallengeAnsweredRequest* other) {
-  if (other != this) {
-    std::swap(answer_, other->answer_);
-    std::swap(data_, other->data_);
-    std::swap(id_, other->id_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ChallengeAnsweredRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ChallengeAnsweredRequest_descriptor_;
-  metadata.reflection = ChallengeAnsweredRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int ChallengeAnsweredResponse::kDataFieldNumber;
-const int ChallengeAnsweredResponse::kDoRetryFieldNumber;
-const int ChallengeAnsweredResponse::kRecordNotFoundFieldNumber;
-#endif  // !_MSC_VER
-
-ChallengeAnsweredResponse::ChallengeAnsweredResponse()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-}
-
-void ChallengeAnsweredResponse::InitAsDefaultInstance() {
-}
-
-ChallengeAnsweredResponse::ChallengeAnsweredResponse(const ChallengeAnsweredResponse& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-}
-
-void ChallengeAnsweredResponse::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  do_retry_ = false;
-  record_not_found_ = false;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ChallengeAnsweredResponse::~ChallengeAnsweredResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-  SharedDtor();
-}
-
-void ChallengeAnsweredResponse::SharedDtor() {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete data_;
-  }
-  if (this != default_instance_) {
-  }
-}
-
-void ChallengeAnsweredResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ChallengeAnsweredResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChallengeAnsweredResponse_descriptor_;
-}
-
-const ChallengeAnsweredResponse& ChallengeAnsweredResponse::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-ChallengeAnsweredResponse* ChallengeAnsweredResponse::default_instance_ = NULL;
-
-ChallengeAnsweredResponse* ChallengeAnsweredResponse::New() const {
-  return new ChallengeAnsweredResponse;
-}
-
-void ChallengeAnsweredResponse::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<ChallengeAnsweredResponse*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 7) {
-    ZR_(do_retry_, record_not_found_);
-    if (has_data()) {
-      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        data_->clear();
-      }
-    }
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool ChallengeAnsweredResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional bytes data = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
-                input, this->mutable_data()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(16)) goto parse_do_retry;
-        break;
-      }
-
-      // optional bool do_retry = 2;
-      case 2: {
-        if (tag == 16) {
-         parse_do_retry:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &do_retry_)));
-          set_has_do_retry();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_record_not_found;
-        break;
-      }
-
-      // optional bool record_not_found = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_record_not_found:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &record_not_found_)));
-          set_has_record_not_found();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-  return false;
-#undef DO_
-}
-
-void ChallengeAnsweredResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-  // optional bytes data = 1;
-  if (has_data()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
-      1, this->data(), output);
-  }
-
-  // optional bool do_retry = 2;
-  if (has_do_retry()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->do_retry(), output);
-  }
-
-  // optional bool record_not_found = 3;
-  if (has_record_not_found()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->record_not_found(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-}
-
-::google::protobuf::uint8* ChallengeAnsweredResponse::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-  // optional bytes data = 1;
-  if (has_data()) {
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
-        1, this->data(), target);
-  }
-
-  // optional bool do_retry = 2;
-  if (has_do_retry()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->do_retry(), target);
-  }
-
-  // optional bool record_not_found = 3;
-  if (has_record_not_found()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->record_not_found(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
-  return target;
-}
-
-int ChallengeAnsweredResponse::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional bytes data = 1;
-    if (has_data()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::BytesSize(
-          this->data());
-    }
-
-    // optional bool do_retry = 2;
-    if (has_do_retry()) {
-      total_size += 1 + 1;
-    }
-
-    // optional bool record_not_found = 3;
-    if (has_record_not_found()) {
-      total_size += 1 + 1;
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ChallengeAnsweredResponse::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ChallengeAnsweredResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeAnsweredResponse*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ChallengeAnsweredResponse::MergeFrom(const ChallengeAnsweredResponse& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_data()) {
-      set_data(from.data());
-    }
-    if (from.has_do_retry()) {
-      set_do_retry(from.do_retry());
-    }
-    if (from.has_record_not_found()) {
-      set_record_not_found(from.record_not_found());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ChallengeAnsweredResponse::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ChallengeAnsweredResponse::CopyFrom(const ChallengeAnsweredResponse& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ChallengeAnsweredResponse::IsInitialized() const {
-
-  return true;
-}
-
-void ChallengeAnsweredResponse::Swap(ChallengeAnsweredResponse* other) {
-  if (other != this) {
-    std::swap(data_, other->data_);
-    std::swap(do_retry_, other->do_retry_);
-    std::swap(record_not_found_, other->record_not_found_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ChallengeAnsweredResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ChallengeAnsweredResponse_descriptor_;
-  metadata.reflection = ChallengeAnsweredResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int ChallengeCancelledRequest::kIdFieldNumber;
-#endif  // !_MSC_VER
-
-ChallengeCancelledRequest::ChallengeCancelledRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-}
-
-void ChallengeCancelledRequest::InitAsDefaultInstance() {
-}
-
-ChallengeCancelledRequest::ChallengeCancelledRequest(const ChallengeCancelledRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-}
-
-void ChallengeCancelledRequest::SharedCtor() {
-  _cached_size_ = 0;
-  id_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ChallengeCancelledRequest::~ChallengeCancelledRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-  SharedDtor();
-}
-
-void ChallengeCancelledRequest::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void ChallengeCancelledRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ChallengeCancelledRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChallengeCancelledRequest_descriptor_;
-}
-
-const ChallengeCancelledRequest& ChallengeCancelledRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-ChallengeCancelledRequest* ChallengeCancelledRequest::default_instance_ = NULL;
-
-ChallengeCancelledRequest* ChallengeCancelledRequest::New() const {
-  return new ChallengeCancelledRequest;
-}
-
-void ChallengeCancelledRequest::Clear() {
-  id_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool ChallengeCancelledRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional uint32 id = 1;
-      case 1: {
-        if (tag == 8) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &id_)));
-          set_has_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-  return false;
-#undef DO_
-}
-
-void ChallengeCancelledRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-  // optional uint32 id = 1;
-  if (has_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-}
-
-::google::protobuf::uint8* ChallengeCancelledRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-  // optional uint32 id = 1;
-  if (has_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
-  return target;
-}
-
-int ChallengeCancelledRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional uint32 id = 1;
-    if (has_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->id());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ChallengeCancelledRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ChallengeCancelledRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeCancelledRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ChallengeCancelledRequest::MergeFrom(const ChallengeCancelledRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_id()) {
-      set_id(from.id());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ChallengeCancelledRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ChallengeCancelledRequest::CopyFrom(const ChallengeCancelledRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ChallengeCancelledRequest::IsInitialized() const {
-
-  return true;
-}
-
-void ChallengeCancelledRequest::Swap(ChallengeCancelledRequest* other) {
-  if (other != this) {
-    std::swap(id_, other->id_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ChallengeCancelledRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ChallengeCancelledRequest_descriptor_;
-  metadata.reflection = ChallengeCancelledRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int SendChallengeToUserRequest::kPeerIdFieldNumber;
-const int SendChallengeToUserRequest::kGameAccountIdFieldNumber;
-const int SendChallengeToUserRequest::kChallengesFieldNumber;
-const int SendChallengeToUserRequest::kContextFieldNumber;
-const int SendChallengeToUserRequest::kTimeoutFieldNumber;
-const int SendChallengeToUserRequest::kAttributesFieldNumber;
-const int SendChallengeToUserRequest::kHostFieldNumber;
-const int SendChallengeToUserRequest::kAccountIdFieldNumber;
-#endif  // !_MSC_VER
-
-SendChallengeToUserRequest::SendChallengeToUserRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-}
-
-void SendChallengeToUserRequest::InitAsDefaultInstance() {
-  peer_id_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
-  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
-  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-}
-
-SendChallengeToUserRequest::SendChallengeToUserRequest(const SendChallengeToUserRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-}
-
-void SendChallengeToUserRequest::SharedCtor() {
-  _cached_size_ = 0;
-  peer_id_ = NULL;
-  game_account_id_ = NULL;
-  context_ = 0u;
-  timeout_ = GOOGLE_ULONGLONG(0);
-  host_ = NULL;
-  account_id_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-SendChallengeToUserRequest::~SendChallengeToUserRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-  SharedDtor();
-}
-
-void SendChallengeToUserRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete peer_id_;
-    delete game_account_id_;
-    delete host_;
-    delete account_id_;
-  }
-}
-
-void SendChallengeToUserRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* SendChallengeToUserRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return SendChallengeToUserRequest_descriptor_;
-}
-
-const SendChallengeToUserRequest& SendChallengeToUserRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-SendChallengeToUserRequest* SendChallengeToUserRequest::default_instance_ = NULL;
-
-SendChallengeToUserRequest* SendChallengeToUserRequest::New() const {
-  return new SendChallengeToUserRequest;
-}
-
-void SendChallengeToUserRequest::Clear() {
-  if (_has_bits_[0 / 32] & 219) {
-    if (has_peer_id()) {
-      if (peer_id_ != NULL) peer_id_->::bgs::protocol::ProcessId::Clear();
-    }
-    if (has_game_account_id()) {
-      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
-    }
-    context_ = 0u;
-    timeout_ = GOOGLE_ULONGLONG(0);
-    if (has_host()) {
-      if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
-    }
-    if (has_account_id()) {
-      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
-    }
-  }
-  challenges_.Clear();
-  attributes_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool SendChallengeToUserRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.ProcessId peer_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_peer_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_game_account_id;
-        break;
-      }
-
-      // optional .bgs.protocol.EntityId game_account_id = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_game_account_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_challenges;
-        break;
-      }
-
-      // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_challenges:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_challenges()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_challenges;
-        if (input->ExpectTag(37)) goto parse_context;
-        break;
-      }
-
-      // required fixed32 context = 4;
-      case 4: {
-        if (tag == 37) {
-         parse_context:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &context_)));
-          set_has_context();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(40)) goto parse_timeout;
-        break;
-      }
-
-      // optional uint64 timeout = 5;
-      case 5: {
-        if (tag == 40) {
-         parse_timeout:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &timeout_)));
-          set_has_timeout();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(50)) goto parse_attributes;
-        break;
-      }
-
-      // repeated .bgs.protocol.Attribute attributes = 6;
-      case 6: {
-        if (tag == 50) {
-         parse_attributes:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_attributes()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(50)) goto parse_attributes;
-        if (input->ExpectTag(58)) goto parse_host;
-        break;
-      }
-
-      // optional .bgs.protocol.ProcessId host = 7;
-      case 7: {
-        if (tag == 58) {
-         parse_host:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_host()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(66)) goto parse_account_id;
-        break;
-      }
-
-      // optional .bgs.protocol.EntityId account_id = 8;
-      case 8: {
-        if (tag == 66) {
-         parse_account_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_account_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-  return false;
-#undef DO_
-}
-
-void SendChallengeToUserRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-  // optional .bgs.protocol.ProcessId peer_id = 1;
-  if (has_peer_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->peer_id(), output);
-  }
-
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  if (has_game_account_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->game_account_id(), output);
-  }
-
-  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
-  for (int i = 0; i < this->challenges_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      3, this->challenges(i), output);
-  }
-
-  // required fixed32 context = 4;
-  if (has_context()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->context(), output);
-  }
-
-  // optional uint64 timeout = 5;
-  if (has_timeout()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->timeout(), output);
-  }
-
-  // repeated .bgs.protocol.Attribute attributes = 6;
-  for (int i = 0; i < this->attributes_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      6, this->attributes(i), output);
-  }
-
-  // optional .bgs.protocol.ProcessId host = 7;
-  if (has_host()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      7, this->host(), output);
-  }
-
-  // optional .bgs.protocol.EntityId account_id = 8;
-  if (has_account_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      8, this->account_id(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-}
-
-::google::protobuf::uint8* SendChallengeToUserRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-  // optional .bgs.protocol.ProcessId peer_id = 1;
-  if (has_peer_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->peer_id(), target);
-  }
-
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  if (has_game_account_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->game_account_id(), target);
-  }
-
-  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
-  for (int i = 0; i < this->challenges_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        3, this->challenges(i), target);
-  }
-
-  // required fixed32 context = 4;
-  if (has_context()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->context(), target);
-  }
-
-  // optional uint64 timeout = 5;
-  if (has_timeout()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->timeout(), target);
-  }
-
-  // repeated .bgs.protocol.Attribute attributes = 6;
-  for (int i = 0; i < this->attributes_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        6, this->attributes(i), target);
-  }
-
-  // optional .bgs.protocol.ProcessId host = 7;
-  if (has_host()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        7, this->host(), target);
-  }
-
-  // optional .bgs.protocol.EntityId account_id = 8;
-  if (has_account_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        8, this->account_id(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
-  return target;
-}
-
-int SendChallengeToUserRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.ProcessId peer_id = 1;
-    if (has_peer_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->peer_id());
-    }
-
-    // optional .bgs.protocol.EntityId game_account_id = 2;
-    if (has_game_account_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account_id());
-    }
-
-    // required fixed32 context = 4;
-    if (has_context()) {
-      total_size += 1 + 4;
-    }
-
-    // optional uint64 timeout = 5;
-    if (has_timeout()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->timeout());
-    }
-
-    // optional .bgs.protocol.ProcessId host = 7;
-    if (has_host()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->host());
-    }
-
-    // optional .bgs.protocol.EntityId account_id = 8;
-    if (has_account_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->account_id());
-    }
-
-  }
-  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
-  total_size += 1 * this->challenges_size();
-  for (int i = 0; i < this->challenges_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->challenges(i));
-  }
-
-  // repeated .bgs.protocol.Attribute attributes = 6;
-  total_size += 1 * this->attributes_size();
-  for (int i = 0; i < this->attributes_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->attributes(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void SendChallengeToUserRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const SendChallengeToUserRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const SendChallengeToUserRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void SendChallengeToUserRequest::MergeFrom(const SendChallengeToUserRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  challenges_.MergeFrom(from.challenges_);
-  attributes_.MergeFrom(from.attributes_);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_peer_id()) {
-      mutable_peer_id()->::bgs::protocol::ProcessId::MergeFrom(from.peer_id());
-    }
-    if (from.has_game_account_id()) {
-      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
-    }
-    if (from.has_context()) {
-      set_context(from.context());
-    }
-    if (from.has_timeout()) {
-      set_timeout(from.timeout());
-    }
-    if (from.has_host()) {
-      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
-    }
-    if (from.has_account_id()) {
-      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void SendChallengeToUserRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void SendChallengeToUserRequest::CopyFrom(const SendChallengeToUserRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SendChallengeToUserRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false;
-
-  if (has_peer_id()) {
-    if (!this->peer_id().IsInitialized()) return false;
-  }
-  if (has_game_account_id()) {
-    if (!this->game_account_id().IsInitialized()) return false;
-  }
-  if (!::google::protobuf::internal::AllAreInitialized(this->challenges())) return false;
-  if (!::google::protobuf::internal::AllAreInitialized(this->attributes())) return false;
-  if (has_host()) {
-    if (!this->host().IsInitialized()) return false;
-  }
-  if (has_account_id()) {
-    if (!this->account_id().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void SendChallengeToUserRequest::Swap(SendChallengeToUserRequest* other) {
-  if (other != this) {
-    std::swap(peer_id_, other->peer_id_);
-    std::swap(game_account_id_, other->game_account_id_);
-    challenges_.Swap(&other->challenges_);
-    std::swap(context_, other->context_);
-    std::swap(timeout_, other->timeout_);
-    attributes_.Swap(&other->attributes_);
-    std::swap(host_, other->host_);
-    std::swap(account_id_, other->account_id_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata SendChallengeToUserRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = SendChallengeToUserRequest_descriptor_;
-  metadata.reflection = SendChallengeToUserRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int SendChallengeToUserResponse::kIdFieldNumber;
-#endif  // !_MSC_VER
-
-SendChallengeToUserResponse::SendChallengeToUserResponse()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-}
-
-void SendChallengeToUserResponse::InitAsDefaultInstance() {
-}
-
-SendChallengeToUserResponse::SendChallengeToUserResponse(const SendChallengeToUserResponse& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-}
-
-void SendChallengeToUserResponse::SharedCtor() {
-  _cached_size_ = 0;
-  id_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-SendChallengeToUserResponse::~SendChallengeToUserResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-  SharedDtor();
-}
-
-void SendChallengeToUserResponse::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void SendChallengeToUserResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* SendChallengeToUserResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return SendChallengeToUserResponse_descriptor_;
-}
-
-const SendChallengeToUserResponse& SendChallengeToUserResponse::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-SendChallengeToUserResponse* SendChallengeToUserResponse::default_instance_ = NULL;
-
-SendChallengeToUserResponse* SendChallengeToUserResponse::New() const {
-  return new SendChallengeToUserResponse;
-}
-
-void SendChallengeToUserResponse::Clear() {
-  id_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool SendChallengeToUserResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional uint32 id = 1;
-      case 1: {
-        if (tag == 8) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &id_)));
-          set_has_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-  return false;
-#undef DO_
-}
-
-void SendChallengeToUserResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-  // optional uint32 id = 1;
-  if (has_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-}
-
-::google::protobuf::uint8* SendChallengeToUserResponse::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-  // optional uint32 id = 1;
-  if (has_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
-  return target;
-}
-
-int SendChallengeToUserResponse::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional uint32 id = 1;
-    if (has_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->id());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void SendChallengeToUserResponse::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const SendChallengeToUserResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const SendChallengeToUserResponse*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void SendChallengeToUserResponse::MergeFrom(const SendChallengeToUserResponse& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_id()) {
-      set_id(from.id());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void SendChallengeToUserResponse::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void SendChallengeToUserResponse::CopyFrom(const SendChallengeToUserResponse& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SendChallengeToUserResponse::IsInitialized() const {
-
-  return true;
-}
-
-void SendChallengeToUserResponse::Swap(SendChallengeToUserResponse* other) {
-  if (other != this) {
-    std::swap(id_, other->id_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata SendChallengeToUserResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = SendChallengeToUserResponse_descriptor_;
-  metadata.reflection = SendChallengeToUserResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int ChallengeUserRequest::kChallengesFieldNumber;
-const int ChallengeUserRequest::kContextFieldNumber;
-const int ChallengeUserRequest::kIdFieldNumber;
-const int ChallengeUserRequest::kDeadlineFieldNumber;
-const int ChallengeUserRequest::kAttributesFieldNumber;
-const int ChallengeUserRequest::kGameAccountIdFieldNumber;
-#endif  // !_MSC_VER
-
-ChallengeUserRequest::ChallengeUserRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeUserRequest)
-}
-
-void ChallengeUserRequest::InitAsDefaultInstance() {
-  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-}
-
-ChallengeUserRequest::ChallengeUserRequest(const ChallengeUserRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeUserRequest)
-}
-
-void ChallengeUserRequest::SharedCtor() {
-  _cached_size_ = 0;
-  context_ = 0u;
-  id_ = 0u;
-  deadline_ = GOOGLE_ULONGLONG(0);
-  game_account_id_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ChallengeUserRequest::~ChallengeUserRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeUserRequest)
-  SharedDtor();
-}
-
-void ChallengeUserRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete game_account_id_;
-  }
-}
-
-void ChallengeUserRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ChallengeUserRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChallengeUserRequest_descriptor_;
-}
-
-const ChallengeUserRequest& ChallengeUserRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-ChallengeUserRequest* ChallengeUserRequest::default_instance_ = NULL;
-
-ChallengeUserRequest* ChallengeUserRequest::New() const {
-  return new ChallengeUserRequest;
-}
-
-void ChallengeUserRequest::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<ChallengeUserRequest*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 46) {
-    ZR_(context_, deadline_);
-    if (has_game_account_id()) {
-      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
-    }
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  challenges_.Clear();
-  attributes_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool ChallengeUserRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeUserRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
-      case 1: {
-        if (tag == 10) {
-         parse_challenges:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_challenges()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(10)) goto parse_challenges;
-        if (input->ExpectTag(21)) goto parse_context;
-        break;
-      }
-
-      // required fixed32 context = 2;
-      case 2: {
-        if (tag == 21) {
-         parse_context:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &context_)));
-          set_has_context();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_id;
-        break;
-      }
-
-      // optional uint32 id = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &id_)));
-          set_has_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(32)) goto parse_deadline;
-        break;
-      }
-
-      // optional uint64 deadline = 4;
-      case 4: {
-        if (tag == 32) {
-         parse_deadline:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &deadline_)));
-          set_has_deadline();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_attributes;
-        break;
-      }
-
-      // repeated .bgs.protocol.Attribute attributes = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_attributes:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_attributes()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_attributes;
-        if (input->ExpectTag(50)) goto parse_game_account_id;
-        break;
-      }
-
-      // optional .bgs.protocol.EntityId game_account_id = 6;
-      case 6: {
-        if (tag == 50) {
-         parse_game_account_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeUserRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeUserRequest)
-  return false;
-#undef DO_
-}
-
-void ChallengeUserRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeUserRequest)
-  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
-  for (int i = 0; i < this->challenges_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->challenges(i), output);
-  }
-
-  // required fixed32 context = 2;
-  if (has_context()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->context(), output);
-  }
-
-  // optional uint32 id = 3;
-  if (has_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->id(), output);
-  }
-
-  // optional uint64 deadline = 4;
-  if (has_deadline()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->deadline(), output);
-  }
-
-  // repeated .bgs.protocol.Attribute attributes = 5;
-  for (int i = 0; i < this->attributes_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, this->attributes(i), output);
-  }
-
-  // optional .bgs.protocol.EntityId game_account_id = 6;
-  if (has_game_account_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      6, this->game_account_id(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeUserRequest)
-}
-
-::google::protobuf::uint8* ChallengeUserRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeUserRequest)
-  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
-  for (int i = 0; i < this->challenges_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->challenges(i), target);
-  }
-
-  // required fixed32 context = 2;
-  if (has_context()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->context(), target);
-  }
-
-  // optional uint32 id = 3;
-  if (has_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->id(), target);
-  }
-
-  // optional uint64 deadline = 4;
-  if (has_deadline()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->deadline(), target);
-  }
-
-  // repeated .bgs.protocol.Attribute attributes = 5;
-  for (int i = 0; i < this->attributes_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->attributes(i), target);
-  }
-
-  // optional .bgs.protocol.EntityId game_account_id = 6;
-  if (has_game_account_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        6, this->game_account_id(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeUserRequest)
-  return target;
-}
-
-int ChallengeUserRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
-    // required fixed32 context = 2;
-    if (has_context()) {
-      total_size += 1 + 4;
-    }
-
-    // optional uint32 id = 3;
-    if (has_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->id());
-    }
-
-    // optional uint64 deadline = 4;
-    if (has_deadline()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->deadline());
-    }
-
-    // optional .bgs.protocol.EntityId game_account_id = 6;
-    if (has_game_account_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account_id());
-    }
-
-  }
-  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
-  total_size += 1 * this->challenges_size();
-  for (int i = 0; i < this->challenges_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->challenges(i));
-  }
-
-  // repeated .bgs.protocol.Attribute attributes = 5;
-  total_size += 1 * this->attributes_size();
-  for (int i = 0; i < this->attributes_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->attributes(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ChallengeUserRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ChallengeUserRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeUserRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ChallengeUserRequest::MergeFrom(const ChallengeUserRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  challenges_.MergeFrom(from.challenges_);
-  attributes_.MergeFrom(from.attributes_);
-  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
-    if (from.has_context()) {
-      set_context(from.context());
-    }
-    if (from.has_id()) {
-      set_id(from.id());
-    }
-    if (from.has_deadline()) {
-      set_deadline(from.deadline());
-    }
-    if (from.has_game_account_id()) {
-      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ChallengeUserRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ChallengeUserRequest::CopyFrom(const ChallengeUserRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ChallengeUserRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
-
-  if (!::google::protobuf::internal::AllAreInitialized(this->challenges())) return false;
-  if (!::google::protobuf::internal::AllAreInitialized(this->attributes())) return false;
-  if (has_game_account_id()) {
-    if (!this->game_account_id().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void ChallengeUserRequest::Swap(ChallengeUserRequest* other) {
-  if (other != this) {
-    challenges_.Swap(&other->challenges_);
-    std::swap(context_, other->context_);
-    std::swap(id_, other->id_);
-    std::swap(deadline_, other->deadline_);
-    attributes_.Swap(&other->attributes_);
-    std::swap(game_account_id_, other->game_account_id_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ChallengeUserRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ChallengeUserRequest_descriptor_;
-  metadata.reflection = ChallengeUserRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int ChallengeResultRequest::kIdFieldNumber;
-const int ChallengeResultRequest::kTypeFieldNumber;
-const int ChallengeResultRequest::kErrorIdFieldNumber;
-const int ChallengeResultRequest::kAnswerFieldNumber;
-#endif  // !_MSC_VER
-
-ChallengeResultRequest::ChallengeResultRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeResultRequest)
-}
-
-void ChallengeResultRequest::InitAsDefaultInstance() {
-}
-
-ChallengeResultRequest::ChallengeResultRequest(const ChallengeResultRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeResultRequest)
-}
-
-void ChallengeResultRequest::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  id_ = 0u;
-  type_ = 0u;
-  error_id_ = 0u;
-  answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ChallengeResultRequest::~ChallengeResultRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeResultRequest)
-  SharedDtor();
-}
-
-void ChallengeResultRequest::SharedDtor() {
-  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete answer_;
-  }
-  if (this != default_instance_) {
-  }
-}
-
-void ChallengeResultRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ChallengeResultRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChallengeResultRequest_descriptor_;
-}
-
-const ChallengeResultRequest& ChallengeResultRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
-  return *default_instance_;
-}
-
-ChallengeResultRequest* ChallengeResultRequest::default_instance_ = NULL;
-
-ChallengeResultRequest* ChallengeResultRequest::New() const {
-  return new ChallengeResultRequest;
-}
-
-void ChallengeResultRequest::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<ChallengeResultRequest*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 15) {
-    ZR_(id_, type_);
-    error_id_ = 0u;
-    if (has_answer()) {
-      if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        answer_->clear();
-      }
-    }
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool ChallengeResultRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeResultRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional uint32 id = 1;
-      case 1: {
-        if (tag == 8) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &id_)));
-          set_has_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(21)) goto parse_type;
-        break;
-      }
-
-      // optional fixed32 type = 2;
-      case 2: {
-        if (tag == 21) {
-         parse_type:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &type_)));
-          set_has_type();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_error_id;
-        break;
-      }
-
-      // optional uint32 error_id = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_error_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &error_id_)));
-          set_has_error_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_answer;
-        break;
-      }
-
-      // optional bytes answer = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_answer:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
-                input, this->mutable_answer()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeResultRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeResultRequest)
-  return false;
-#undef DO_
-}
-
-void ChallengeResultRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeResultRequest)
-  // optional uint32 id = 1;
-  if (has_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
-  }
-
-  // optional fixed32 type = 2;
-  if (has_type()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->type(), output);
-  }
-
-  // optional uint32 error_id = 3;
-  if (has_error_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->error_id(), output);
-  }
-
-  // optional bytes answer = 4;
-  if (has_answer()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
-      4, this->answer(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeResultRequest)
-}
-
-::google::protobuf::uint8* ChallengeResultRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeResultRequest)
-  // optional uint32 id = 1;
-  if (has_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
-  }
-
-  // optional fixed32 type = 2;
-  if (has_type()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->type(), target);
-  }
-
-  // optional uint32 error_id = 3;
-  if (has_error_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->error_id(), target);
-  }
-
-  // optional bytes answer = 4;
-  if (has_answer()) {
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
-        4, this->answer(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeResultRequest)
-  return target;
-}
-
-int ChallengeResultRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional uint32 id = 1;
-    if (has_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->id());
-    }
-
-    // optional fixed32 type = 2;
-    if (has_type()) {
-      total_size += 1 + 4;
-    }
-
-    // optional uint32 error_id = 3;
-    if (has_error_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->error_id());
-    }
-
-    // optional bytes answer = 4;
-    if (has_answer()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::BytesSize(
-          this->answer());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ChallengeResultRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ChallengeResultRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeResultRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ChallengeResultRequest::MergeFrom(const ChallengeResultRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_id()) {
-      set_id(from.id());
-    }
-    if (from.has_type()) {
-      set_type(from.type());
-    }
-    if (from.has_error_id()) {
-      set_error_id(from.error_id());
-    }
-    if (from.has_answer()) {
-      set_answer(from.answer());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ChallengeResultRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ChallengeResultRequest::CopyFrom(const ChallengeResultRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ChallengeResultRequest::IsInitialized() const {
-
-  return true;
-}
-
-void ChallengeResultRequest::Swap(ChallengeResultRequest* other) {
-  if (other != this) {
-    std::swap(id_, other->id_);
-    std::swap(type_, other->type_);
-    std::swap(error_id_, other->error_id_);
-    std::swap(answer_, other->answer_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ChallengeResultRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ChallengeResultRequest_descriptor_;
-  metadata.reflection = ChallengeResultRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int ChallengeExternalRequest::kRequestTokenFieldNumber;
 const int ChallengeExternalRequest::kPayloadTypeFieldNumber;
 const int ChallengeExternalRequest::kPayloadFieldNumber;
@@ -4457,200 +778,6 @@ void ChallengeExternalResult::Swap(ChallengeExternalResult* other) {
 
 // ===================================================================
 
-ChallengeService::ChallengeService(bool use_original_hash) : service_hash_(use_original_hash ? OriginalHash::value : NameHash::value) {
-}
-
-ChallengeService::~ChallengeService() {
-}
-
-google::protobuf::ServiceDescriptor const* ChallengeService::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChallengeService_descriptor_;
-}
-
-void ChallengeService::ChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, std::function<void(::bgs::protocol::challenge::v1::ChallengePickedResponse const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.ChallengePicked(bgs.protocol.challenge.v1.ChallengePickedRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::challenge::v1::ChallengePickedResponse response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 1, request, std::move(callback));
-}
-
-void ChallengeService::ChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, std::function<void(::bgs::protocol::challenge::v1::ChallengeAnsweredResponse const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.ChallengeAnswered(bgs.protocol.challenge.v1.ChallengeAnsweredRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 2, request, std::move(callback));
-}
-
-void ChallengeService::ChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.ChallengeCancelled(bgs.protocol.challenge.v1.ChallengeCancelledRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 3, request, std::move(callback));
-}
-
-void ChallengeService::SendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, std::function<void(::bgs::protocol::challenge::v1::SendChallengeToUserResponse const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.SendChallengeToUser(bgs.protocol.challenge.v1.SendChallengeToUserRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::challenge::v1::SendChallengeToUserResponse response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 4, request, std::move(callback));
-}
-
-void ChallengeService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
-  switch(methodId) {
-    case 1: {
-      ::bgs::protocol::challenge::v1::ChallengePickedRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.ChallengePicked server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengePicked(bgs.protocol.challenge.v1.ChallengePickedRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::challenge::v1::ChallengePickedResponse::descriptor());
-        ChallengeService* self = static_cast<ChallengeService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengePicked() returned bgs.protocol.challenge.v1.ChallengePickedResponse{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 1, token, response);
-        else
-          self->SendResponse(self->service_hash_, 1, token, status);
-      };
-      ::bgs::protocol::challenge::v1::ChallengePickedResponse response;
-      uint32 status = HandleChallengePicked(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 2: {
-      ::bgs::protocol::challenge::v1::ChallengeAnsweredRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.ChallengeAnswered server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengeAnswered(bgs.protocol.challenge.v1.ChallengeAnsweredRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse::descriptor());
-        ChallengeService* self = static_cast<ChallengeService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengeAnswered() returned bgs.protocol.challenge.v1.ChallengeAnsweredResponse{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 2, token, response);
-        else
-          self->SendResponse(self->service_hash_, 2, token, status);
-      };
-      ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse response;
-      uint32 status = HandleChallengeAnswered(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 3: {
-      ::bgs::protocol::challenge::v1::ChallengeCancelledRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.ChallengeCancelled server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengeCancelled(bgs.protocol.challenge.v1.ChallengeCancelledRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        ChallengeService* self = static_cast<ChallengeService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengeCancelled() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 3, token, response);
-        else
-          self->SendResponse(self->service_hash_, 3, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleChallengeCancelled(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 4: {
-      ::bgs::protocol::challenge::v1::SendChallengeToUserRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.SendChallengeToUser server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.SendChallengeToUser(bgs.protocol.challenge.v1.SendChallengeToUserRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::challenge::v1::SendChallengeToUserResponse::descriptor());
-        ChallengeService* self = static_cast<ChallengeService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.SendChallengeToUser() returned bgs.protocol.challenge.v1.SendChallengeToUserResponse{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 4, token, response);
-        else
-          self->SendResponse(self->service_hash_, 4, token, status);
-      };
-      ::bgs::protocol::challenge::v1::SendChallengeToUserResponse response;
-      uint32 status = HandleSendChallengeToUser(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    default:
-      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
-      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
-      break;
-    }
-}
-
-uint32 ChallengeService::HandleChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, ::bgs::protocol::challenge::v1::ChallengePickedResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.ChallengePicked({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChallengeService::HandleChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.ChallengeAnswered({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChallengeService::HandleChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.ChallengeCancelled({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChallengeService::HandleSendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, ::bgs::protocol::challenge::v1::SendChallengeToUserResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.SendChallengeToUser({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-// ===================================================================
-
 ChallengeListener::ChallengeListener(bool use_original_hash) : service_hash_(use_original_hash ? OriginalHash::value : NameHash::value) {
 }
 
@@ -4662,18 +789,6 @@ google::protobuf::ServiceDescriptor const* ChallengeListener::descriptor() {
   return ChallengeListener_descriptor_;
 }
 
-void ChallengeListener::OnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnChallengeUser(bgs.protocol.challenge.v1.ChallengeUserRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 1, request);
-}
-
-void ChallengeListener::OnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnChallengeResult(bgs.protocol.challenge.v1.ChallengeResultRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 2, request);
-}
-
 void ChallengeListener::OnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request) {
   TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnExternalChallenge(bgs.protocol.challenge.v1.ChallengeExternalRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
@@ -4688,34 +803,6 @@ void ChallengeListener::OnExternalChallengeResult(::bgs::protocol::challenge::v1
 
 void ChallengeListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
   switch(methodId) {
-    case 1: {
-      ::bgs::protocol::challenge::v1::ChallengeUserRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnChallengeUser server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleOnChallengeUser(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnChallengeUser(bgs.protocol.challenge.v1.ChallengeUserRequest{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 1, token, status);
-      break;
-    }
-    case 2: {
-      ::bgs::protocol::challenge::v1::ChallengeResultRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnChallengeResult server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleOnChallengeResult(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnChallengeResult(bgs.protocol.challenge.v1.ChallengeResultRequest{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 2, token, status);
-      break;
-    }
     case 3: {
       ::bgs::protocol::challenge::v1::ChallengeExternalRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
@@ -4751,18 +838,6 @@ void ChallengeListener::CallServerMethod(uint32 token, uint32 methodId, MessageB
     }
 }
 
-uint32 ChallengeListener::HandleOnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnChallengeUser({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChallengeListener::HandleOnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnChallengeResult({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
 uint32 ChallengeListener::HandleOnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnExternalChallenge({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
diff --git a/src/server/proto/Client/challenge_service.pb.h b/src/server/proto/Client/challenge_service.pb.h
index 842a7e54d5e..fa93153d38c 100644
--- a/src/server/proto/Client/challenge_service.pb.h
+++ b/src/server/proto/Client/challenge_service.pb.h
@@ -24,8 +24,6 @@
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/extension_set.h>
 #include <google/protobuf/unknown_field_set.h>
-#include "attribute_types.pb.h"
-#include "entity_types.pb.h"
 #include "rpc_types.pb.h"
 #include "ServiceBase.h"
 #include "MessageBuffer.h"
@@ -43,1108 +41,11 @@ void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
 void protobuf_AssignDesc_challenge_5fservice_2eproto();
 void protobuf_ShutdownFile_challenge_5fservice_2eproto();
 
-class Challenge;
-class ChallengePickedRequest;
-class ChallengePickedResponse;
-class ChallengeAnsweredRequest;
-class ChallengeAnsweredResponse;
-class ChallengeCancelledRequest;
-class SendChallengeToUserRequest;
-class SendChallengeToUserResponse;
-class ChallengeUserRequest;
-class ChallengeResultRequest;
 class ChallengeExternalRequest;
 class ChallengeExternalResult;
 
 // ===================================================================
 
-class TC_PROTO_API Challenge : public ::google::protobuf::Message {
- public:
-  Challenge();
-  virtual ~Challenge();
-
-  Challenge(const Challenge& from);
-
-  inline Challenge& operator=(const Challenge& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const Challenge& default_instance();
-
-  void Swap(Challenge* other);
-
-  // implements Message ----------------------------------------------
-
-  Challenge* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const Challenge& from);
-  void MergeFrom(const Challenge& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // required fixed32 type = 1;
-  inline bool has_type() const;
-  inline void clear_type();
-  static const int kTypeFieldNumber = 1;
-  inline ::google::protobuf::uint32 type() const;
-  inline void set_type(::google::protobuf::uint32 value);
-
-  // optional string info = 2;
-  inline bool has_info() const;
-  inline void clear_info();
-  static const int kInfoFieldNumber = 2;
-  inline const ::std::string& info() const;
-  inline void set_info(const ::std::string& value);
-  inline void set_info(const char* value);
-  inline void set_info(const char* value, size_t size);
-  inline ::std::string* mutable_info();
-  inline ::std::string* release_info();
-  inline void set_allocated_info(::std::string* info);
-
-  // optional string answer = 3;
-  inline bool has_answer() const;
-  inline void clear_answer();
-  static const int kAnswerFieldNumber = 3;
-  inline const ::std::string& answer() const;
-  inline void set_answer(const ::std::string& value);
-  inline void set_answer(const char* value);
-  inline void set_answer(const char* value, size_t size);
-  inline ::std::string* mutable_answer();
-  inline ::std::string* release_answer();
-  inline void set_allocated_answer(::std::string* answer);
-
-  // optional uint32 retries = 4;
-  inline bool has_retries() const;
-  inline void clear_retries();
-  static const int kRetriesFieldNumber = 4;
-  inline ::google::protobuf::uint32 retries() const;
-  inline void set_retries(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.Challenge)
- private:
-  inline void set_has_type();
-  inline void clear_has_type();
-  inline void set_has_info();
-  inline void clear_has_info();
-  inline void set_has_answer();
-  inline void clear_has_answer();
-  inline void set_has_retries();
-  inline void clear_has_retries();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::std::string* info_;
-  ::google::protobuf::uint32 type_;
-  ::google::protobuf::uint32 retries_;
-  ::std::string* answer_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static Challenge* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ChallengePickedRequest : public ::google::protobuf::Message {
- public:
-  ChallengePickedRequest();
-  virtual ~ChallengePickedRequest();
-
-  ChallengePickedRequest(const ChallengePickedRequest& from);
-
-  inline ChallengePickedRequest& operator=(const ChallengePickedRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ChallengePickedRequest& default_instance();
-
-  void Swap(ChallengePickedRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  ChallengePickedRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ChallengePickedRequest& from);
-  void MergeFrom(const ChallengePickedRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // required fixed32 challenge = 1;
-  inline bool has_challenge() const;
-  inline void clear_challenge();
-  static const int kChallengeFieldNumber = 1;
-  inline ::google::protobuf::uint32 challenge() const;
-  inline void set_challenge(::google::protobuf::uint32 value);
-
-  // optional uint32 id = 2;
-  inline bool has_id() const;
-  inline void clear_id();
-  static const int kIdFieldNumber = 2;
-  inline ::google::protobuf::uint32 id() const;
-  inline void set_id(::google::protobuf::uint32 value);
-
-  // optional bool new_challenge_protocol = 3 [default = false];
-  inline bool has_new_challenge_protocol() const;
-  inline void clear_new_challenge_protocol();
-  static const int kNewChallengeProtocolFieldNumber = 3;
-  inline bool new_challenge_protocol() const;
-  inline void set_new_challenge_protocol(bool value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengePickedRequest)
- private:
-  inline void set_has_challenge();
-  inline void clear_has_challenge();
-  inline void set_has_id();
-  inline void clear_has_id();
-  inline void set_has_new_challenge_protocol();
-  inline void clear_has_new_challenge_protocol();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 challenge_;
-  ::google::protobuf::uint32 id_;
-  bool new_challenge_protocol_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static ChallengePickedRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ChallengePickedResponse : public ::google::protobuf::Message {
- public:
-  ChallengePickedResponse();
-  virtual ~ChallengePickedResponse();
-
-  ChallengePickedResponse(const ChallengePickedResponse& from);
-
-  inline ChallengePickedResponse& operator=(const ChallengePickedResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ChallengePickedResponse& default_instance();
-
-  void Swap(ChallengePickedResponse* other);
-
-  // implements Message ----------------------------------------------
-
-  ChallengePickedResponse* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ChallengePickedResponse& from);
-  void MergeFrom(const ChallengePickedResponse& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional bytes data = 1;
-  inline bool has_data() const;
-  inline void clear_data();
-  static const int kDataFieldNumber = 1;
-  inline const ::std::string& data() const;
-  inline void set_data(const ::std::string& value);
-  inline void set_data(const char* value);
-  inline void set_data(const void* value, size_t size);
-  inline ::std::string* mutable_data();
-  inline ::std::string* release_data();
-  inline void set_allocated_data(::std::string* data);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengePickedResponse)
- private:
-  inline void set_has_data();
-  inline void clear_has_data();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::std::string* data_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static ChallengePickedResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ChallengeAnsweredRequest : public ::google::protobuf::Message {
- public:
-  ChallengeAnsweredRequest();
-  virtual ~ChallengeAnsweredRequest();
-
-  ChallengeAnsweredRequest(const ChallengeAnsweredRequest& from);
-
-  inline ChallengeAnsweredRequest& operator=(const ChallengeAnsweredRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ChallengeAnsweredRequest& default_instance();
-
-  void Swap(ChallengeAnsweredRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  ChallengeAnsweredRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ChallengeAnsweredRequest& from);
-  void MergeFrom(const ChallengeAnsweredRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // required string answer = 1;
-  inline bool has_answer() const;
-  inline void clear_answer();
-  static const int kAnswerFieldNumber = 1;
-  inline const ::std::string& answer() const;
-  inline void set_answer(const ::std::string& value);
-  inline void set_answer(const char* value);
-  inline void set_answer(const char* value, size_t size);
-  inline ::std::string* mutable_answer();
-  inline ::std::string* release_answer();
-  inline void set_allocated_answer(::std::string* answer);
-
-  // optional bytes data = 2;
-  inline bool has_data() const;
-  inline void clear_data();
-  static const int kDataFieldNumber = 2;
-  inline const ::std::string& data() const;
-  inline void set_data(const ::std::string& value);
-  inline void set_data(const char* value);
-  inline void set_data(const void* value, size_t size);
-  inline ::std::string* mutable_data();
-  inline ::std::string* release_data();
-  inline void set_allocated_data(::std::string* data);
-
-  // optional uint32 id = 3;
-  inline bool has_id() const;
-  inline void clear_id();
-  static const int kIdFieldNumber = 3;
-  inline ::google::protobuf::uint32 id() const;
-  inline void set_id(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
- private:
-  inline void set_has_answer();
-  inline void clear_has_answer();
-  inline void set_has_data();
-  inline void clear_has_data();
-  inline void set_has_id();
-  inline void clear_has_id();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::std::string* answer_;
-  ::std::string* data_;
-  ::google::protobuf::uint32 id_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static ChallengeAnsweredRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ChallengeAnsweredResponse : public ::google::protobuf::Message {
- public:
-  ChallengeAnsweredResponse();
-  virtual ~ChallengeAnsweredResponse();
-
-  ChallengeAnsweredResponse(const ChallengeAnsweredResponse& from);
-
-  inline ChallengeAnsweredResponse& operator=(const ChallengeAnsweredResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ChallengeAnsweredResponse& default_instance();
-
-  void Swap(ChallengeAnsweredResponse* other);
-
-  // implements Message ----------------------------------------------
-
-  ChallengeAnsweredResponse* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ChallengeAnsweredResponse& from);
-  void MergeFrom(const ChallengeAnsweredResponse& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional bytes data = 1;
-  inline bool has_data() const;
-  inline void clear_data();
-  static const int kDataFieldNumber = 1;
-  inline const ::std::string& data() const;
-  inline void set_data(const ::std::string& value);
-  inline void set_data(const char* value);
-  inline void set_data(const void* value, size_t size);
-  inline ::std::string* mutable_data();
-  inline ::std::string* release_data();
-  inline void set_allocated_data(::std::string* data);
-
-  // optional bool do_retry = 2;
-  inline bool has_do_retry() const;
-  inline void clear_do_retry();
-  static const int kDoRetryFieldNumber = 2;
-  inline bool do_retry() const;
-  inline void set_do_retry(bool value);
-
-  // optional bool record_not_found = 3;
-  inline bool has_record_not_found() const;
-  inline void clear_record_not_found();
-  static const int kRecordNotFoundFieldNumber = 3;
-  inline bool record_not_found() const;
-  inline void set_record_not_found(bool value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
- private:
-  inline void set_has_data();
-  inline void clear_has_data();
-  inline void set_has_do_retry();
-  inline void clear_has_do_retry();
-  inline void set_has_record_not_found();
-  inline void clear_has_record_not_found();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::std::string* data_;
-  bool do_retry_;
-  bool record_not_found_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static ChallengeAnsweredResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ChallengeCancelledRequest : public ::google::protobuf::Message {
- public:
-  ChallengeCancelledRequest();
-  virtual ~ChallengeCancelledRequest();
-
-  ChallengeCancelledRequest(const ChallengeCancelledRequest& from);
-
-  inline ChallengeCancelledRequest& operator=(const ChallengeCancelledRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ChallengeCancelledRequest& default_instance();
-
-  void Swap(ChallengeCancelledRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  ChallengeCancelledRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ChallengeCancelledRequest& from);
-  void MergeFrom(const ChallengeCancelledRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional uint32 id = 1;
-  inline bool has_id() const;
-  inline void clear_id();
-  static const int kIdFieldNumber = 1;
-  inline ::google::protobuf::uint32 id() const;
-  inline void set_id(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
- private:
-  inline void set_has_id();
-  inline void clear_has_id();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 id_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static ChallengeCancelledRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API SendChallengeToUserRequest : public ::google::protobuf::Message {
- public:
-  SendChallengeToUserRequest();
-  virtual ~SendChallengeToUserRequest();
-
-  SendChallengeToUserRequest(const SendChallengeToUserRequest& from);
-
-  inline SendChallengeToUserRequest& operator=(const SendChallengeToUserRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const SendChallengeToUserRequest& default_instance();
-
-  void Swap(SendChallengeToUserRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  SendChallengeToUserRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const SendChallengeToUserRequest& from);
-  void MergeFrom(const SendChallengeToUserRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.ProcessId peer_id = 1;
-  inline bool has_peer_id() const;
-  inline void clear_peer_id();
-  static const int kPeerIdFieldNumber = 1;
-  inline const ::bgs::protocol::ProcessId& peer_id() const;
-  inline ::bgs::protocol::ProcessId* mutable_peer_id();
-  inline ::bgs::protocol::ProcessId* release_peer_id();
-  inline void set_allocated_peer_id(::bgs::protocol::ProcessId* peer_id);
-
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  inline bool has_game_account_id() const;
-  inline void clear_game_account_id();
-  static const int kGameAccountIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& game_account_id() const;
-  inline ::bgs::protocol::EntityId* mutable_game_account_id();
-  inline ::bgs::protocol::EntityId* release_game_account_id();
-  inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id);
-
-  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
-  inline int challenges_size() const;
-  inline void clear_challenges();
-  static const int kChallengesFieldNumber = 3;
-  inline const ::bgs::protocol::challenge::v1::Challenge& challenges(int index) const;
-  inline ::bgs::protocol::challenge::v1::Challenge* mutable_challenges(int index);
-  inline ::bgs::protocol::challenge::v1::Challenge* add_challenges();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >&
-      challenges() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >*
-      mutable_challenges();
-
-  // required fixed32 context = 4;
-  inline bool has_context() const;
-  inline void clear_context();
-  static const int kContextFieldNumber = 4;
-  inline ::google::protobuf::uint32 context() const;
-  inline void set_context(::google::protobuf::uint32 value);
-
-  // optional uint64 timeout = 5;
-  inline bool has_timeout() const;
-  inline void clear_timeout();
-  static const int kTimeoutFieldNumber = 5;
-  inline ::google::protobuf::uint64 timeout() const;
-  inline void set_timeout(::google::protobuf::uint64 value);
-
-  // repeated .bgs.protocol.Attribute attributes = 6;
-  inline int attributes_size() const;
-  inline void clear_attributes();
-  static const int kAttributesFieldNumber = 6;
-  inline const ::bgs::protocol::Attribute& attributes(int index) const;
-  inline ::bgs::protocol::Attribute* mutable_attributes(int index);
-  inline ::bgs::protocol::Attribute* add_attributes();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
-      attributes() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
-      mutable_attributes();
-
-  // optional .bgs.protocol.ProcessId host = 7;
-  inline bool has_host() const;
-  inline void clear_host();
-  static const int kHostFieldNumber = 7;
-  inline const ::bgs::protocol::ProcessId& host() const;
-  inline ::bgs::protocol::ProcessId* mutable_host();
-  inline ::bgs::protocol::ProcessId* release_host();
-  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
-
-  // optional .bgs.protocol.EntityId account_id = 8;
-  inline bool has_account_id() const;
-  inline void clear_account_id();
-  static const int kAccountIdFieldNumber = 8;
-  inline const ::bgs::protocol::EntityId& account_id() const;
-  inline ::bgs::protocol::EntityId* mutable_account_id();
-  inline ::bgs::protocol::EntityId* release_account_id();
-  inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
- private:
-  inline void set_has_peer_id();
-  inline void clear_has_peer_id();
-  inline void set_has_game_account_id();
-  inline void clear_has_game_account_id();
-  inline void set_has_context();
-  inline void clear_has_context();
-  inline void set_has_timeout();
-  inline void clear_has_timeout();
-  inline void set_has_host();
-  inline void clear_has_host();
-  inline void set_has_account_id();
-  inline void clear_has_account_id();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::ProcessId* peer_id_;
-  ::bgs::protocol::EntityId* game_account_id_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge > challenges_;
-  ::google::protobuf::uint64 timeout_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attributes_;
-  ::bgs::protocol::ProcessId* host_;
-  ::bgs::protocol::EntityId* account_id_;
-  ::google::protobuf::uint32 context_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static SendChallengeToUserRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API SendChallengeToUserResponse : public ::google::protobuf::Message {
- public:
-  SendChallengeToUserResponse();
-  virtual ~SendChallengeToUserResponse();
-
-  SendChallengeToUserResponse(const SendChallengeToUserResponse& from);
-
-  inline SendChallengeToUserResponse& operator=(const SendChallengeToUserResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const SendChallengeToUserResponse& default_instance();
-
-  void Swap(SendChallengeToUserResponse* other);
-
-  // implements Message ----------------------------------------------
-
-  SendChallengeToUserResponse* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const SendChallengeToUserResponse& from);
-  void MergeFrom(const SendChallengeToUserResponse& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional uint32 id = 1;
-  inline bool has_id() const;
-  inline void clear_id();
-  static const int kIdFieldNumber = 1;
-  inline ::google::protobuf::uint32 id() const;
-  inline void set_id(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
- private:
-  inline void set_has_id();
-  inline void clear_has_id();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 id_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static SendChallengeToUserResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ChallengeUserRequest : public ::google::protobuf::Message {
- public:
-  ChallengeUserRequest();
-  virtual ~ChallengeUserRequest();
-
-  ChallengeUserRequest(const ChallengeUserRequest& from);
-
-  inline ChallengeUserRequest& operator=(const ChallengeUserRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ChallengeUserRequest& default_instance();
-
-  void Swap(ChallengeUserRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  ChallengeUserRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ChallengeUserRequest& from);
-  void MergeFrom(const ChallengeUserRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
-  inline int challenges_size() const;
-  inline void clear_challenges();
-  static const int kChallengesFieldNumber = 1;
-  inline const ::bgs::protocol::challenge::v1::Challenge& challenges(int index) const;
-  inline ::bgs::protocol::challenge::v1::Challenge* mutable_challenges(int index);
-  inline ::bgs::protocol::challenge::v1::Challenge* add_challenges();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >&
-      challenges() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >*
-      mutable_challenges();
-
-  // required fixed32 context = 2;
-  inline bool has_context() const;
-  inline void clear_context();
-  static const int kContextFieldNumber = 2;
-  inline ::google::protobuf::uint32 context() const;
-  inline void set_context(::google::protobuf::uint32 value);
-
-  // optional uint32 id = 3;
-  inline bool has_id() const;
-  inline void clear_id();
-  static const int kIdFieldNumber = 3;
-  inline ::google::protobuf::uint32 id() const;
-  inline void set_id(::google::protobuf::uint32 value);
-
-  // optional uint64 deadline = 4;
-  inline bool has_deadline() const;
-  inline void clear_deadline();
-  static const int kDeadlineFieldNumber = 4;
-  inline ::google::protobuf::uint64 deadline() const;
-  inline void set_deadline(::google::protobuf::uint64 value);
-
-  // repeated .bgs.protocol.Attribute attributes = 5;
-  inline int attributes_size() const;
-  inline void clear_attributes();
-  static const int kAttributesFieldNumber = 5;
-  inline const ::bgs::protocol::Attribute& attributes(int index) const;
-  inline ::bgs::protocol::Attribute* mutable_attributes(int index);
-  inline ::bgs::protocol::Attribute* add_attributes();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
-      attributes() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
-      mutable_attributes();
-
-  // optional .bgs.protocol.EntityId game_account_id = 6;
-  inline bool has_game_account_id() const;
-  inline void clear_game_account_id();
-  static const int kGameAccountIdFieldNumber = 6;
-  inline const ::bgs::protocol::EntityId& game_account_id() const;
-  inline ::bgs::protocol::EntityId* mutable_game_account_id();
-  inline ::bgs::protocol::EntityId* release_game_account_id();
-  inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeUserRequest)
- private:
-  inline void set_has_context();
-  inline void clear_has_context();
-  inline void set_has_id();
-  inline void clear_has_id();
-  inline void set_has_deadline();
-  inline void clear_has_deadline();
-  inline void set_has_game_account_id();
-  inline void clear_has_game_account_id();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge > challenges_;
-  ::google::protobuf::uint32 context_;
-  ::google::protobuf::uint32 id_;
-  ::google::protobuf::uint64 deadline_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attributes_;
-  ::bgs::protocol::EntityId* game_account_id_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static ChallengeUserRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ChallengeResultRequest : public ::google::protobuf::Message {
- public:
-  ChallengeResultRequest();
-  virtual ~ChallengeResultRequest();
-
-  ChallengeResultRequest(const ChallengeResultRequest& from);
-
-  inline ChallengeResultRequest& operator=(const ChallengeResultRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ChallengeResultRequest& default_instance();
-
-  void Swap(ChallengeResultRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  ChallengeResultRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ChallengeResultRequest& from);
-  void MergeFrom(const ChallengeResultRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional uint32 id = 1;
-  inline bool has_id() const;
-  inline void clear_id();
-  static const int kIdFieldNumber = 1;
-  inline ::google::protobuf::uint32 id() const;
-  inline void set_id(::google::protobuf::uint32 value);
-
-  // optional fixed32 type = 2;
-  inline bool has_type() const;
-  inline void clear_type();
-  static const int kTypeFieldNumber = 2;
-  inline ::google::protobuf::uint32 type() const;
-  inline void set_type(::google::protobuf::uint32 value);
-
-  // optional uint32 error_id = 3;
-  inline bool has_error_id() const;
-  inline void clear_error_id();
-  static const int kErrorIdFieldNumber = 3;
-  inline ::google::protobuf::uint32 error_id() const;
-  inline void set_error_id(::google::protobuf::uint32 value);
-
-  // optional bytes answer = 4;
-  inline bool has_answer() const;
-  inline void clear_answer();
-  static const int kAnswerFieldNumber = 4;
-  inline const ::std::string& answer() const;
-  inline void set_answer(const ::std::string& value);
-  inline void set_answer(const char* value);
-  inline void set_answer(const void* value, size_t size);
-  inline ::std::string* mutable_answer();
-  inline ::std::string* release_answer();
-  inline void set_allocated_answer(::std::string* answer);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeResultRequest)
- private:
-  inline void set_has_id();
-  inline void clear_has_id();
-  inline void set_has_type();
-  inline void clear_has_type();
-  inline void set_has_error_id();
-  inline void clear_has_error_id();
-  inline void set_has_answer();
-  inline void clear_has_answer();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 id_;
-  ::google::protobuf::uint32 type_;
-  ::std::string* answer_;
-  ::google::protobuf::uint32 error_id_;
-  friend void TC_PROTO_API protobuf_AddDesc_challenge_5fservice_2eproto();
-  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static ChallengeResultRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API ChallengeExternalRequest : public ::google::protobuf::Message {
  public:
   ChallengeExternalRequest();
@@ -1353,42 +254,6 @@ class TC_PROTO_API ChallengeExternalResult : public ::google::protobuf::Message
 };
 // ===================================================================
 
-class TC_PROTO_API ChallengeService : public ServiceBase
-{
- public:
-
-  explicit ChallengeService(bool use_original_hash);
-  virtual ~ChallengeService();
-
-  typedef std::integral_constant<uint32, 0xDBBF6F19u> OriginalHash;
-  typedef std::integral_constant<uint32, 0x71BB6833u> NameHash;
-
-  static google::protobuf::ServiceDescriptor const* descriptor();
-
-  // client methods --------------------------------------------------
-
-  void ChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, std::function<void(::bgs::protocol::challenge::v1::ChallengePickedResponse const*)> responseCallback);
-  void ChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, std::function<void(::bgs::protocol::challenge::v1::ChallengeAnsweredResponse const*)> responseCallback);
-  void ChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void SendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, std::function<void(::bgs::protocol::challenge::v1::SendChallengeToUserResponse const*)> responseCallback);
-  // server methods --------------------------------------------------
-
-  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
-
- protected:
-  virtual uint32 HandleChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, ::bgs::protocol::challenge::v1::ChallengePickedResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleSendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, ::bgs::protocol::challenge::v1::SendChallengeToUserResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-
- private:
-  uint32 service_hash_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChallengeService);
-};
-
-// -------------------------------------------------------------------
-
 class TC_PROTO_API ChallengeListener : public ServiceBase
 {
  public:
@@ -1403,8 +268,6 @@ class TC_PROTO_API ChallengeListener : public ServiceBase
 
   // client methods --------------------------------------------------
 
-  void OnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request);
-  void OnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request);
   void OnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request);
   void OnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request);
   // server methods --------------------------------------------------
@@ -1412,8 +275,6 @@ class TC_PROTO_API ChallengeListener : public ServiceBase
   void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
 
  protected:
-  virtual uint32 HandleOnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request);
-  virtual uint32 HandleOnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request);
   virtual uint32 HandleOnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request);
   virtual uint32 HandleOnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request);
 
@@ -1428,1335 +289,6 @@ class TC_PROTO_API ChallengeListener : public ServiceBase
 
 // ===================================================================
 
-// Challenge
-
-// required fixed32 type = 1;
-inline bool Challenge::has_type() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void Challenge::set_has_type() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void Challenge::clear_has_type() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void Challenge::clear_type() {
-  type_ = 0u;
-  clear_has_type();
-}
-inline ::google::protobuf::uint32 Challenge::type() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.type)
-  return type_;
-}
-inline void Challenge::set_type(::google::protobuf::uint32 value) {
-  set_has_type();
-  type_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.type)
-}
-
-// optional string info = 2;
-inline bool Challenge::has_info() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void Challenge::set_has_info() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void Challenge::clear_has_info() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void Challenge::clear_info() {
-  if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    info_->clear();
-  }
-  clear_has_info();
-}
-inline const ::std::string& Challenge::info() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.info)
-  return *info_;
-}
-inline void Challenge::set_info(const ::std::string& value) {
-  set_has_info();
-  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    info_ = new ::std::string;
-  }
-  info_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.info)
-}
-inline void Challenge::set_info(const char* value) {
-  set_has_info();
-  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    info_ = new ::std::string;
-  }
-  info_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.Challenge.info)
-}
-inline void Challenge::set_info(const char* value, size_t size) {
-  set_has_info();
-  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    info_ = new ::std::string;
-  }
-  info_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.Challenge.info)
-}
-inline ::std::string* Challenge::mutable_info() {
-  set_has_info();
-  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    info_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.Challenge.info)
-  return info_;
-}
-inline ::std::string* Challenge::release_info() {
-  clear_has_info();
-  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = info_;
-    info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void Challenge::set_allocated_info(::std::string* info) {
-  if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete info_;
-  }
-  if (info) {
-    set_has_info();
-    info_ = info;
-  } else {
-    clear_has_info();
-    info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.Challenge.info)
-}
-
-// optional string answer = 3;
-inline bool Challenge::has_answer() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void Challenge::set_has_answer() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void Challenge::clear_has_answer() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void Challenge::clear_answer() {
-  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_->clear();
-  }
-  clear_has_answer();
-}
-inline const ::std::string& Challenge::answer() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.answer)
-  return *answer_;
-}
-inline void Challenge::set_answer(const ::std::string& value) {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  answer_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.answer)
-}
-inline void Challenge::set_answer(const char* value) {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  answer_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.Challenge.answer)
-}
-inline void Challenge::set_answer(const char* value, size_t size) {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  answer_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.Challenge.answer)
-}
-inline ::std::string* Challenge::mutable_answer() {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.Challenge.answer)
-  return answer_;
-}
-inline ::std::string* Challenge::release_answer() {
-  clear_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = answer_;
-    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void Challenge::set_allocated_answer(::std::string* answer) {
-  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete answer_;
-  }
-  if (answer) {
-    set_has_answer();
-    answer_ = answer;
-  } else {
-    clear_has_answer();
-    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.Challenge.answer)
-}
-
-// optional uint32 retries = 4;
-inline bool Challenge::has_retries() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void Challenge::set_has_retries() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void Challenge::clear_has_retries() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void Challenge::clear_retries() {
-  retries_ = 0u;
-  clear_has_retries();
-}
-inline ::google::protobuf::uint32 Challenge::retries() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.retries)
-  return retries_;
-}
-inline void Challenge::set_retries(::google::protobuf::uint32 value) {
-  set_has_retries();
-  retries_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.retries)
-}
-
-// -------------------------------------------------------------------
-
-// ChallengePickedRequest
-
-// required fixed32 challenge = 1;
-inline bool ChallengePickedRequest::has_challenge() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void ChallengePickedRequest::set_has_challenge() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void ChallengePickedRequest::clear_has_challenge() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void ChallengePickedRequest::clear_challenge() {
-  challenge_ = 0u;
-  clear_has_challenge();
-}
-inline ::google::protobuf::uint32 ChallengePickedRequest::challenge() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedRequest.challenge)
-  return challenge_;
-}
-inline void ChallengePickedRequest::set_challenge(::google::protobuf::uint32 value) {
-  set_has_challenge();
-  challenge_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedRequest.challenge)
-}
-
-// optional uint32 id = 2;
-inline bool ChallengePickedRequest::has_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void ChallengePickedRequest::set_has_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void ChallengePickedRequest::clear_has_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void ChallengePickedRequest::clear_id() {
-  id_ = 0u;
-  clear_has_id();
-}
-inline ::google::protobuf::uint32 ChallengePickedRequest::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedRequest.id)
-  return id_;
-}
-inline void ChallengePickedRequest::set_id(::google::protobuf::uint32 value) {
-  set_has_id();
-  id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedRequest.id)
-}
-
-// optional bool new_challenge_protocol = 3 [default = false];
-inline bool ChallengePickedRequest::has_new_challenge_protocol() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void ChallengePickedRequest::set_has_new_challenge_protocol() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void ChallengePickedRequest::clear_has_new_challenge_protocol() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void ChallengePickedRequest::clear_new_challenge_protocol() {
-  new_challenge_protocol_ = false;
-  clear_has_new_challenge_protocol();
-}
-inline bool ChallengePickedRequest::new_challenge_protocol() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedRequest.new_challenge_protocol)
-  return new_challenge_protocol_;
-}
-inline void ChallengePickedRequest::set_new_challenge_protocol(bool value) {
-  set_has_new_challenge_protocol();
-  new_challenge_protocol_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedRequest.new_challenge_protocol)
-}
-
-// -------------------------------------------------------------------
-
-// ChallengePickedResponse
-
-// optional bytes data = 1;
-inline bool ChallengePickedResponse::has_data() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void ChallengePickedResponse::set_has_data() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void ChallengePickedResponse::clear_has_data() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void ChallengePickedResponse::clear_data() {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_->clear();
-  }
-  clear_has_data();
-}
-inline const ::std::string& ChallengePickedResponse::data() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedResponse.data)
-  return *data_;
-}
-inline void ChallengePickedResponse::set_data(const ::std::string& value) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedResponse.data)
-}
-inline void ChallengePickedResponse::set_data(const char* value) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengePickedResponse.data)
-}
-inline void ChallengePickedResponse::set_data(const void* value, size_t size) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengePickedResponse.data)
-}
-inline ::std::string* ChallengePickedResponse::mutable_data() {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengePickedResponse.data)
-  return data_;
-}
-inline ::std::string* ChallengePickedResponse::release_data() {
-  clear_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = data_;
-    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void ChallengePickedResponse::set_allocated_data(::std::string* data) {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete data_;
-  }
-  if (data) {
-    set_has_data();
-    data_ = data;
-  } else {
-    clear_has_data();
-    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengePickedResponse.data)
-}
-
-// -------------------------------------------------------------------
-
-// ChallengeAnsweredRequest
-
-// required string answer = 1;
-inline bool ChallengeAnsweredRequest::has_answer() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void ChallengeAnsweredRequest::set_has_answer() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void ChallengeAnsweredRequest::clear_has_answer() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void ChallengeAnsweredRequest::clear_answer() {
-  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_->clear();
-  }
-  clear_has_answer();
-}
-inline const ::std::string& ChallengeAnsweredRequest::answer() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
-  return *answer_;
-}
-inline void ChallengeAnsweredRequest::set_answer(const ::std::string& value) {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  answer_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
-}
-inline void ChallengeAnsweredRequest::set_answer(const char* value) {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  answer_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
-}
-inline void ChallengeAnsweredRequest::set_answer(const char* value, size_t size) {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  answer_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
-}
-inline ::std::string* ChallengeAnsweredRequest::mutable_answer() {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
-  return answer_;
-}
-inline ::std::string* ChallengeAnsweredRequest::release_answer() {
-  clear_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = answer_;
-    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void ChallengeAnsweredRequest::set_allocated_answer(::std::string* answer) {
-  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete answer_;
-  }
-  if (answer) {
-    set_has_answer();
-    answer_ = answer;
-  } else {
-    clear_has_answer();
-    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
-}
-
-// optional bytes data = 2;
-inline bool ChallengeAnsweredRequest::has_data() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void ChallengeAnsweredRequest::set_has_data() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void ChallengeAnsweredRequest::clear_has_data() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void ChallengeAnsweredRequest::clear_data() {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_->clear();
-  }
-  clear_has_data();
-}
-inline const ::std::string& ChallengeAnsweredRequest::data() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data)
-  return *data_;
-}
-inline void ChallengeAnsweredRequest::set_data(const ::std::string& value) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data)
-}
-inline void ChallengeAnsweredRequest::set_data(const char* value) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data)
-}
-inline void ChallengeAnsweredRequest::set_data(const void* value, size_t size) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data)
-}
-inline ::std::string* ChallengeAnsweredRequest::mutable_data() {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data)
-  return data_;
-}
-inline ::std::string* ChallengeAnsweredRequest::release_data() {
-  clear_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = data_;
-    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void ChallengeAnsweredRequest::set_allocated_data(::std::string* data) {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete data_;
-  }
-  if (data) {
-    set_has_data();
-    data_ = data;
-  } else {
-    clear_has_data();
-    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data)
-}
-
-// optional uint32 id = 3;
-inline bool ChallengeAnsweredRequest::has_id() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void ChallengeAnsweredRequest::set_has_id() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void ChallengeAnsweredRequest::clear_has_id() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void ChallengeAnsweredRequest::clear_id() {
-  id_ = 0u;
-  clear_has_id();
-}
-inline ::google::protobuf::uint32 ChallengeAnsweredRequest::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.id)
-  return id_;
-}
-inline void ChallengeAnsweredRequest::set_id(::google::protobuf::uint32 value) {
-  set_has_id();
-  id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.id)
-}
-
-// -------------------------------------------------------------------
-
-// ChallengeAnsweredResponse
-
-// optional bytes data = 1;
-inline bool ChallengeAnsweredResponse::has_data() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void ChallengeAnsweredResponse::set_has_data() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void ChallengeAnsweredResponse::clear_has_data() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void ChallengeAnsweredResponse::clear_data() {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_->clear();
-  }
-  clear_has_data();
-}
-inline const ::std::string& ChallengeAnsweredResponse::data() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data)
-  return *data_;
-}
-inline void ChallengeAnsweredResponse::set_data(const ::std::string& value) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data)
-}
-inline void ChallengeAnsweredResponse::set_data(const char* value) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data)
-}
-inline void ChallengeAnsweredResponse::set_data(const void* value, size_t size) {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  data_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data)
-}
-inline ::std::string* ChallengeAnsweredResponse::mutable_data() {
-  set_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    data_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data)
-  return data_;
-}
-inline ::std::string* ChallengeAnsweredResponse::release_data() {
-  clear_has_data();
-  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = data_;
-    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void ChallengeAnsweredResponse::set_allocated_data(::std::string* data) {
-  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete data_;
-  }
-  if (data) {
-    set_has_data();
-    data_ = data;
-  } else {
-    clear_has_data();
-    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data)
-}
-
-// optional bool do_retry = 2;
-inline bool ChallengeAnsweredResponse::has_do_retry() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void ChallengeAnsweredResponse::set_has_do_retry() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void ChallengeAnsweredResponse::clear_has_do_retry() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void ChallengeAnsweredResponse::clear_do_retry() {
-  do_retry_ = false;
-  clear_has_do_retry();
-}
-inline bool ChallengeAnsweredResponse::do_retry() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.do_retry)
-  return do_retry_;
-}
-inline void ChallengeAnsweredResponse::set_do_retry(bool value) {
-  set_has_do_retry();
-  do_retry_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.do_retry)
-}
-
-// optional bool record_not_found = 3;
-inline bool ChallengeAnsweredResponse::has_record_not_found() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void ChallengeAnsweredResponse::set_has_record_not_found() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void ChallengeAnsweredResponse::clear_has_record_not_found() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void ChallengeAnsweredResponse::clear_record_not_found() {
-  record_not_found_ = false;
-  clear_has_record_not_found();
-}
-inline bool ChallengeAnsweredResponse::record_not_found() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.record_not_found)
-  return record_not_found_;
-}
-inline void ChallengeAnsweredResponse::set_record_not_found(bool value) {
-  set_has_record_not_found();
-  record_not_found_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.record_not_found)
-}
-
-// -------------------------------------------------------------------
-
-// ChallengeCancelledRequest
-
-// optional uint32 id = 1;
-inline bool ChallengeCancelledRequest::has_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void ChallengeCancelledRequest::set_has_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void ChallengeCancelledRequest::clear_has_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void ChallengeCancelledRequest::clear_id() {
-  id_ = 0u;
-  clear_has_id();
-}
-inline ::google::protobuf::uint32 ChallengeCancelledRequest::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeCancelledRequest.id)
-  return id_;
-}
-inline void ChallengeCancelledRequest::set_id(::google::protobuf::uint32 value) {
-  set_has_id();
-  id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeCancelledRequest.id)
-}
-
-// -------------------------------------------------------------------
-
-// SendChallengeToUserRequest
-
-// optional .bgs.protocol.ProcessId peer_id = 1;
-inline bool SendChallengeToUserRequest::has_peer_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void SendChallengeToUserRequest::set_has_peer_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void SendChallengeToUserRequest::clear_has_peer_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void SendChallengeToUserRequest::clear_peer_id() {
-  if (peer_id_ != NULL) peer_id_->::bgs::protocol::ProcessId::Clear();
-  clear_has_peer_id();
-}
-inline const ::bgs::protocol::ProcessId& SendChallengeToUserRequest::peer_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.peer_id)
-  return peer_id_ != NULL ? *peer_id_ : *default_instance_->peer_id_;
-}
-inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::mutable_peer_id() {
-  set_has_peer_id();
-  if (peer_id_ == NULL) peer_id_ = new ::bgs::protocol::ProcessId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.peer_id)
-  return peer_id_;
-}
-inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::release_peer_id() {
-  clear_has_peer_id();
-  ::bgs::protocol::ProcessId* temp = peer_id_;
-  peer_id_ = NULL;
-  return temp;
-}
-inline void SendChallengeToUserRequest::set_allocated_peer_id(::bgs::protocol::ProcessId* peer_id) {
-  delete peer_id_;
-  peer_id_ = peer_id;
-  if (peer_id) {
-    set_has_peer_id();
-  } else {
-    clear_has_peer_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.peer_id)
-}
-
-// optional .bgs.protocol.EntityId game_account_id = 2;
-inline bool SendChallengeToUserRequest::has_game_account_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void SendChallengeToUserRequest::set_has_game_account_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void SendChallengeToUserRequest::clear_has_game_account_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void SendChallengeToUserRequest::clear_game_account_id() {
-  if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_game_account_id();
-}
-inline const ::bgs::protocol::EntityId& SendChallengeToUserRequest::game_account_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.game_account_id)
-  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
-}
-inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::mutable_game_account_id() {
-  set_has_game_account_id();
-  if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.game_account_id)
-  return game_account_id_;
-}
-inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::release_game_account_id() {
-  clear_has_game_account_id();
-  ::bgs::protocol::EntityId* temp = game_account_id_;
-  game_account_id_ = NULL;
-  return temp;
-}
-inline void SendChallengeToUserRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) {
-  delete game_account_id_;
-  game_account_id_ = game_account_id;
-  if (game_account_id) {
-    set_has_game_account_id();
-  } else {
-    clear_has_game_account_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.game_account_id)
-}
-
-// repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
-inline int SendChallengeToUserRequest::challenges_size() const {
-  return challenges_.size();
-}
-inline void SendChallengeToUserRequest::clear_challenges() {
-  challenges_.Clear();
-}
-inline const ::bgs::protocol::challenge::v1::Challenge& SendChallengeToUserRequest::challenges(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
-  return challenges_.Get(index);
-}
-inline ::bgs::protocol::challenge::v1::Challenge* SendChallengeToUserRequest::mutable_challenges(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
-  return challenges_.Mutable(index);
-}
-inline ::bgs::protocol::challenge::v1::Challenge* SendChallengeToUserRequest::add_challenges() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
-  return challenges_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >&
-SendChallengeToUserRequest::challenges() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
-  return challenges_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >*
-SendChallengeToUserRequest::mutable_challenges() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
-  return &challenges_;
-}
-
-// required fixed32 context = 4;
-inline bool SendChallengeToUserRequest::has_context() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void SendChallengeToUserRequest::set_has_context() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void SendChallengeToUserRequest::clear_has_context() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void SendChallengeToUserRequest::clear_context() {
-  context_ = 0u;
-  clear_has_context();
-}
-inline ::google::protobuf::uint32 SendChallengeToUserRequest::context() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.context)
-  return context_;
-}
-inline void SendChallengeToUserRequest::set_context(::google::protobuf::uint32 value) {
-  set_has_context();
-  context_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.SendChallengeToUserRequest.context)
-}
-
-// optional uint64 timeout = 5;
-inline bool SendChallengeToUserRequest::has_timeout() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void SendChallengeToUserRequest::set_has_timeout() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void SendChallengeToUserRequest::clear_has_timeout() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void SendChallengeToUserRequest::clear_timeout() {
-  timeout_ = GOOGLE_ULONGLONG(0);
-  clear_has_timeout();
-}
-inline ::google::protobuf::uint64 SendChallengeToUserRequest::timeout() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.timeout)
-  return timeout_;
-}
-inline void SendChallengeToUserRequest::set_timeout(::google::protobuf::uint64 value) {
-  set_has_timeout();
-  timeout_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.SendChallengeToUserRequest.timeout)
-}
-
-// repeated .bgs.protocol.Attribute attributes = 6;
-inline int SendChallengeToUserRequest::attributes_size() const {
-  return attributes_.size();
-}
-inline void SendChallengeToUserRequest::clear_attributes() {
-  attributes_.Clear();
-}
-inline const ::bgs::protocol::Attribute& SendChallengeToUserRequest::attributes(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
-  return attributes_.Get(index);
-}
-inline ::bgs::protocol::Attribute* SendChallengeToUserRequest::mutable_attributes(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
-  return attributes_.Mutable(index);
-}
-inline ::bgs::protocol::Attribute* SendChallengeToUserRequest::add_attributes() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
-  return attributes_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
-SendChallengeToUserRequest::attributes() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
-  return attributes_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
-SendChallengeToUserRequest::mutable_attributes() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
-  return &attributes_;
-}
-
-// optional .bgs.protocol.ProcessId host = 7;
-inline bool SendChallengeToUserRequest::has_host() const {
-  return (_has_bits_[0] & 0x00000040u) != 0;
-}
-inline void SendChallengeToUserRequest::set_has_host() {
-  _has_bits_[0] |= 0x00000040u;
-}
-inline void SendChallengeToUserRequest::clear_has_host() {
-  _has_bits_[0] &= ~0x00000040u;
-}
-inline void SendChallengeToUserRequest::clear_host() {
-  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
-  clear_has_host();
-}
-inline const ::bgs::protocol::ProcessId& SendChallengeToUserRequest::host() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.host)
-  return host_ != NULL ? *host_ : *default_instance_->host_;
-}
-inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::mutable_host() {
-  set_has_host();
-  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.host)
-  return host_;
-}
-inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::release_host() {
-  clear_has_host();
-  ::bgs::protocol::ProcessId* temp = host_;
-  host_ = NULL;
-  return temp;
-}
-inline void SendChallengeToUserRequest::set_allocated_host(::bgs::protocol::ProcessId* host) {
-  delete host_;
-  host_ = host;
-  if (host) {
-    set_has_host();
-  } else {
-    clear_has_host();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.host)
-}
-
-// optional .bgs.protocol.EntityId account_id = 8;
-inline bool SendChallengeToUserRequest::has_account_id() const {
-  return (_has_bits_[0] & 0x00000080u) != 0;
-}
-inline void SendChallengeToUserRequest::set_has_account_id() {
-  _has_bits_[0] |= 0x00000080u;
-}
-inline void SendChallengeToUserRequest::clear_has_account_id() {
-  _has_bits_[0] &= ~0x00000080u;
-}
-inline void SendChallengeToUserRequest::clear_account_id() {
-  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_account_id();
-}
-inline const ::bgs::protocol::EntityId& SendChallengeToUserRequest::account_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.account_id)
-  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
-}
-inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::mutable_account_id() {
-  set_has_account_id();
-  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.account_id)
-  return account_id_;
-}
-inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::release_account_id() {
-  clear_has_account_id();
-  ::bgs::protocol::EntityId* temp = account_id_;
-  account_id_ = NULL;
-  return temp;
-}
-inline void SendChallengeToUserRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
-  delete account_id_;
-  account_id_ = account_id;
-  if (account_id) {
-    set_has_account_id();
-  } else {
-    clear_has_account_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.account_id)
-}
-
-// -------------------------------------------------------------------
-
-// SendChallengeToUserResponse
-
-// optional uint32 id = 1;
-inline bool SendChallengeToUserResponse::has_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void SendChallengeToUserResponse::set_has_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void SendChallengeToUserResponse::clear_has_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void SendChallengeToUserResponse::clear_id() {
-  id_ = 0u;
-  clear_has_id();
-}
-inline ::google::protobuf::uint32 SendChallengeToUserResponse::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserResponse.id)
-  return id_;
-}
-inline void SendChallengeToUserResponse::set_id(::google::protobuf::uint32 value) {
-  set_has_id();
-  id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.SendChallengeToUserResponse.id)
-}
-
-// -------------------------------------------------------------------
-
-// ChallengeUserRequest
-
-// repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
-inline int ChallengeUserRequest::challenges_size() const {
-  return challenges_.size();
-}
-inline void ChallengeUserRequest::clear_challenges() {
-  challenges_.Clear();
-}
-inline const ::bgs::protocol::challenge::v1::Challenge& ChallengeUserRequest::challenges(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
-  return challenges_.Get(index);
-}
-inline ::bgs::protocol::challenge::v1::Challenge* ChallengeUserRequest::mutable_challenges(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
-  return challenges_.Mutable(index);
-}
-inline ::bgs::protocol::challenge::v1::Challenge* ChallengeUserRequest::add_challenges() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
-  return challenges_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >&
-ChallengeUserRequest::challenges() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
-  return challenges_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >*
-ChallengeUserRequest::mutable_challenges() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
-  return &challenges_;
-}
-
-// required fixed32 context = 2;
-inline bool ChallengeUserRequest::has_context() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void ChallengeUserRequest::set_has_context() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void ChallengeUserRequest::clear_has_context() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void ChallengeUserRequest::clear_context() {
-  context_ = 0u;
-  clear_has_context();
-}
-inline ::google::protobuf::uint32 ChallengeUserRequest::context() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.context)
-  return context_;
-}
-inline void ChallengeUserRequest::set_context(::google::protobuf::uint32 value) {
-  set_has_context();
-  context_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeUserRequest.context)
-}
-
-// optional uint32 id = 3;
-inline bool ChallengeUserRequest::has_id() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void ChallengeUserRequest::set_has_id() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void ChallengeUserRequest::clear_has_id() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void ChallengeUserRequest::clear_id() {
-  id_ = 0u;
-  clear_has_id();
-}
-inline ::google::protobuf::uint32 ChallengeUserRequest::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.id)
-  return id_;
-}
-inline void ChallengeUserRequest::set_id(::google::protobuf::uint32 value) {
-  set_has_id();
-  id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeUserRequest.id)
-}
-
-// optional uint64 deadline = 4;
-inline bool ChallengeUserRequest::has_deadline() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void ChallengeUserRequest::set_has_deadline() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void ChallengeUserRequest::clear_has_deadline() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void ChallengeUserRequest::clear_deadline() {
-  deadline_ = GOOGLE_ULONGLONG(0);
-  clear_has_deadline();
-}
-inline ::google::protobuf::uint64 ChallengeUserRequest::deadline() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.deadline)
-  return deadline_;
-}
-inline void ChallengeUserRequest::set_deadline(::google::protobuf::uint64 value) {
-  set_has_deadline();
-  deadline_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeUserRequest.deadline)
-}
-
-// repeated .bgs.protocol.Attribute attributes = 5;
-inline int ChallengeUserRequest::attributes_size() const {
-  return attributes_.size();
-}
-inline void ChallengeUserRequest::clear_attributes() {
-  attributes_.Clear();
-}
-inline const ::bgs::protocol::Attribute& ChallengeUserRequest::attributes(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
-  return attributes_.Get(index);
-}
-inline ::bgs::protocol::Attribute* ChallengeUserRequest::mutable_attributes(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
-  return attributes_.Mutable(index);
-}
-inline ::bgs::protocol::Attribute* ChallengeUserRequest::add_attributes() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
-  return attributes_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
-ChallengeUserRequest::attributes() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
-  return attributes_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
-ChallengeUserRequest::mutable_attributes() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
-  return &attributes_;
-}
-
-// optional .bgs.protocol.EntityId game_account_id = 6;
-inline bool ChallengeUserRequest::has_game_account_id() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
-}
-inline void ChallengeUserRequest::set_has_game_account_id() {
-  _has_bits_[0] |= 0x00000020u;
-}
-inline void ChallengeUserRequest::clear_has_game_account_id() {
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline void ChallengeUserRequest::clear_game_account_id() {
-  if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_game_account_id();
-}
-inline const ::bgs::protocol::EntityId& ChallengeUserRequest::game_account_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.game_account_id)
-  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
-}
-inline ::bgs::protocol::EntityId* ChallengeUserRequest::mutable_game_account_id() {
-  set_has_game_account_id();
-  if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeUserRequest.game_account_id)
-  return game_account_id_;
-}
-inline ::bgs::protocol::EntityId* ChallengeUserRequest::release_game_account_id() {
-  clear_has_game_account_id();
-  ::bgs::protocol::EntityId* temp = game_account_id_;
-  game_account_id_ = NULL;
-  return temp;
-}
-inline void ChallengeUserRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) {
-  delete game_account_id_;
-  game_account_id_ = game_account_id;
-  if (game_account_id) {
-    set_has_game_account_id();
-  } else {
-    clear_has_game_account_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeUserRequest.game_account_id)
-}
-
-// -------------------------------------------------------------------
-
-// ChallengeResultRequest
-
-// optional uint32 id = 1;
-inline bool ChallengeResultRequest::has_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void ChallengeResultRequest::set_has_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void ChallengeResultRequest::clear_has_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void ChallengeResultRequest::clear_id() {
-  id_ = 0u;
-  clear_has_id();
-}
-inline ::google::protobuf::uint32 ChallengeResultRequest::id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.id)
-  return id_;
-}
-inline void ChallengeResultRequest::set_id(::google::protobuf::uint32 value) {
-  set_has_id();
-  id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.id)
-}
-
-// optional fixed32 type = 2;
-inline bool ChallengeResultRequest::has_type() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void ChallengeResultRequest::set_has_type() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void ChallengeResultRequest::clear_has_type() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void ChallengeResultRequest::clear_type() {
-  type_ = 0u;
-  clear_has_type();
-}
-inline ::google::protobuf::uint32 ChallengeResultRequest::type() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.type)
-  return type_;
-}
-inline void ChallengeResultRequest::set_type(::google::protobuf::uint32 value) {
-  set_has_type();
-  type_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.type)
-}
-
-// optional uint32 error_id = 3;
-inline bool ChallengeResultRequest::has_error_id() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void ChallengeResultRequest::set_has_error_id() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void ChallengeResultRequest::clear_has_error_id() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void ChallengeResultRequest::clear_error_id() {
-  error_id_ = 0u;
-  clear_has_error_id();
-}
-inline ::google::protobuf::uint32 ChallengeResultRequest::error_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.error_id)
-  return error_id_;
-}
-inline void ChallengeResultRequest::set_error_id(::google::protobuf::uint32 value) {
-  set_has_error_id();
-  error_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.error_id)
-}
-
-// optional bytes answer = 4;
-inline bool ChallengeResultRequest::has_answer() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void ChallengeResultRequest::set_has_answer() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void ChallengeResultRequest::clear_has_answer() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void ChallengeResultRequest::clear_answer() {
-  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_->clear();
-  }
-  clear_has_answer();
-}
-inline const ::std::string& ChallengeResultRequest::answer() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
-  return *answer_;
-}
-inline void ChallengeResultRequest::set_answer(const ::std::string& value) {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  answer_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
-}
-inline void ChallengeResultRequest::set_answer(const char* value) {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  answer_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
-}
-inline void ChallengeResultRequest::set_answer(const void* value, size_t size) {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  answer_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
-}
-inline ::std::string* ChallengeResultRequest::mutable_answer() {
-  set_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    answer_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
-  return answer_;
-}
-inline ::std::string* ChallengeResultRequest::release_answer() {
-  clear_has_answer();
-  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = answer_;
-    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void ChallengeResultRequest::set_allocated_answer(::std::string* answer) {
-  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete answer_;
-  }
-  if (answer) {
-    set_has_answer();
-    answer_ = answer;
-  } else {
-    clear_has_answer();
-    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
-}
-
-// -------------------------------------------------------------------
-
 // ChallengeExternalRequest
 
 // optional string request_token = 1;
diff --git a/src/server/proto/Client/channel_service.pb.cc b/src/server/proto/Client/channel_service.pb.cc
deleted file mode 100644
index f7b8092af7f..00000000000
--- a/src/server/proto/Client/channel_service.pb.cc
+++ /dev/null
@@ -1,5254 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: channel_service.proto
-
-#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
-#include "channel_service.pb.h"
-
-#include <algorithm>
-#include <utility>
-
-#include <google/protobuf/stubs/common.h>
-#include <google/protobuf/stubs/once.h>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/wire_format_lite_inl.h>
-#include <google/protobuf/descriptor.h>
-#include <google/protobuf/generated_message_reflection.h>
-#include <google/protobuf/reflection_ops.h>
-#include <google/protobuf/wire_format.h>
-#include "Log.h"
-#include "Errors.h"
-#include "BattlenetRpcErrorCodes.h"
-// @@protoc_insertion_point(includes)
-
-namespace bgs {
-namespace protocol {
-namespace channel {
-namespace v1 {
-
-namespace {
-
-const ::google::protobuf::Descriptor* RemoveMemberRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  RemoveMemberRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* SendMessageRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  SendMessageRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* UpdateChannelStateRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  UpdateChannelStateRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* UpdateMemberStateRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  UpdateMemberStateRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* DissolveRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  DissolveRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* JoinNotification_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  JoinNotification_reflection_ = NULL;
-const ::google::protobuf::Descriptor* MemberAddedNotification_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  MemberAddedNotification_reflection_ = NULL;
-const ::google::protobuf::Descriptor* LeaveNotification_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  LeaveNotification_reflection_ = NULL;
-const ::google::protobuf::Descriptor* MemberRemovedNotification_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  MemberRemovedNotification_reflection_ = NULL;
-const ::google::protobuf::Descriptor* SendMessageNotification_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  SendMessageNotification_reflection_ = NULL;
-const ::google::protobuf::Descriptor* UpdateChannelStateNotification_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  UpdateChannelStateNotification_reflection_ = NULL;
-const ::google::protobuf::Descriptor* UpdateMemberStateNotification_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  UpdateMemberStateNotification_reflection_ = NULL;
-const ::google::protobuf::ServiceDescriptor* ChannelService_descriptor_ = NULL;
-const ::google::protobuf::ServiceDescriptor* ChannelListener_descriptor_ = NULL;
-
-}  // namespace
-
-
-void protobuf_AssignDesc_channel_5fservice_2eproto() {
-  protobuf_AddDesc_channel_5fservice_2eproto();
-  const ::google::protobuf::FileDescriptor* file =
-    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
-      "channel_service.proto");
-  GOOGLE_CHECK(file != NULL);
-  RemoveMemberRequest_descriptor_ = file->message_type(0);
-  static const int RemoveMemberRequest_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, member_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, reason_),
-  };
-  RemoveMemberRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      RemoveMemberRequest_descriptor_,
-      RemoveMemberRequest::default_instance_,
-      RemoveMemberRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(RemoveMemberRequest));
-  SendMessageRequest_descriptor_ = file->message_type(1);
-  static const int SendMessageRequest_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, message_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, required_privileges_),
-  };
-  SendMessageRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      SendMessageRequest_descriptor_,
-      SendMessageRequest::default_instance_,
-      SendMessageRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(SendMessageRequest));
-  UpdateChannelStateRequest_descriptor_ = file->message_type(2);
-  static const int UpdateChannelStateRequest_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, state_change_),
-  };
-  UpdateChannelStateRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      UpdateChannelStateRequest_descriptor_,
-      UpdateChannelStateRequest::default_instance_,
-      UpdateChannelStateRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(UpdateChannelStateRequest));
-  UpdateMemberStateRequest_descriptor_ = file->message_type(3);
-  static const int UpdateMemberStateRequest_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, state_change_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, removed_role_),
-  };
-  UpdateMemberStateRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      UpdateMemberStateRequest_descriptor_,
-      UpdateMemberStateRequest::default_instance_,
-      UpdateMemberStateRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(UpdateMemberStateRequest));
-  DissolveRequest_descriptor_ = file->message_type(4);
-  static const int DissolveRequest_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, reason_),
-  };
-  DissolveRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      DissolveRequest_descriptor_,
-      DissolveRequest::default_instance_,
-      DissolveRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(DissolveRequest));
-  JoinNotification_descriptor_ = file->message_type(5);
-  static const int JoinNotification_offsets_[5] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, self_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, member_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, channel_state_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, channel_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, subscriber_),
-  };
-  JoinNotification_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      JoinNotification_descriptor_,
-      JoinNotification::default_instance_,
-      JoinNotification_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(JoinNotification));
-  MemberAddedNotification_descriptor_ = file->message_type(6);
-  static const int MemberAddedNotification_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, member_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, channel_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, subscriber_),
-  };
-  MemberAddedNotification_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      MemberAddedNotification_descriptor_,
-      MemberAddedNotification::default_instance_,
-      MemberAddedNotification_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(MemberAddedNotification));
-  LeaveNotification_descriptor_ = file->message_type(7);
-  static const int LeaveNotification_offsets_[5] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, member_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, reason_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, channel_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, subscriber_),
-  };
-  LeaveNotification_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      LeaveNotification_descriptor_,
-      LeaveNotification::default_instance_,
-      LeaveNotification_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(LeaveNotification));
-  MemberRemovedNotification_descriptor_ = file->message_type(8);
-  static const int MemberRemovedNotification_offsets_[5] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, member_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, reason_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, channel_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, subscriber_),
-  };
-  MemberRemovedNotification_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      MemberRemovedNotification_descriptor_,
-      MemberRemovedNotification::default_instance_,
-      MemberRemovedNotification_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(MemberRemovedNotification));
-  SendMessageNotification_descriptor_ = file->message_type(9);
-  static const int SendMessageNotification_offsets_[6] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, message_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, required_privileges_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, battle_tag_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, channel_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, subscriber_),
-  };
-  SendMessageNotification_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      SendMessageNotification_descriptor_,
-      SendMessageNotification::default_instance_,
-      SendMessageNotification_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(SendMessageNotification));
-  UpdateChannelStateNotification_descriptor_ = file->message_type(10);
-  static const int UpdateChannelStateNotification_offsets_[4] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, state_change_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, channel_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, subscriber_),
-  };
-  UpdateChannelStateNotification_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      UpdateChannelStateNotification_descriptor_,
-      UpdateChannelStateNotification::default_instance_,
-      UpdateChannelStateNotification_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(UpdateChannelStateNotification));
-  UpdateMemberStateNotification_descriptor_ = file->message_type(11);
-  static const int UpdateMemberStateNotification_offsets_[4] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, state_change_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, channel_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, subscriber_),
-  };
-  UpdateMemberStateNotification_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      UpdateMemberStateNotification_descriptor_,
-      UpdateMemberStateNotification::default_instance_,
-      UpdateMemberStateNotification_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(UpdateMemberStateNotification));
-  ChannelService_descriptor_ = file->service(0);
-  ChannelListener_descriptor_ = file->service(1);
-}
-
-namespace {
-
-GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
-inline void protobuf_AssignDescriptorsOnce() {
-  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
-                 &protobuf_AssignDesc_channel_5fservice_2eproto);
-}
-
-void protobuf_RegisterTypes(const ::std::string&) {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    RemoveMemberRequest_descriptor_, &RemoveMemberRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    SendMessageRequest_descriptor_, &SendMessageRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    UpdateChannelStateRequest_descriptor_, &UpdateChannelStateRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    UpdateMemberStateRequest_descriptor_, &UpdateMemberStateRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    DissolveRequest_descriptor_, &DissolveRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    JoinNotification_descriptor_, &JoinNotification::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    MemberAddedNotification_descriptor_, &MemberAddedNotification::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    LeaveNotification_descriptor_, &LeaveNotification::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    MemberRemovedNotification_descriptor_, &MemberRemovedNotification::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    SendMessageNotification_descriptor_, &SendMessageNotification::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    UpdateChannelStateNotification_descriptor_, &UpdateChannelStateNotification::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    UpdateMemberStateNotification_descriptor_, &UpdateMemberStateNotification::default_instance());
-}
-
-}  // namespace
-
-void protobuf_ShutdownFile_channel_5fservice_2eproto() {
-  delete RemoveMemberRequest::default_instance_;
-  delete RemoveMemberRequest_reflection_;
-  delete SendMessageRequest::default_instance_;
-  delete SendMessageRequest_reflection_;
-  delete UpdateChannelStateRequest::default_instance_;
-  delete UpdateChannelStateRequest_reflection_;
-  delete UpdateMemberStateRequest::default_instance_;
-  delete UpdateMemberStateRequest_reflection_;
-  delete DissolveRequest::default_instance_;
-  delete DissolveRequest_reflection_;
-  delete JoinNotification::default_instance_;
-  delete JoinNotification_reflection_;
-  delete MemberAddedNotification::default_instance_;
-  delete MemberAddedNotification_reflection_;
-  delete LeaveNotification::default_instance_;
-  delete LeaveNotification_reflection_;
-  delete MemberRemovedNotification::default_instance_;
-  delete MemberRemovedNotification_reflection_;
-  delete SendMessageNotification::default_instance_;
-  delete SendMessageNotification_reflection_;
-  delete UpdateChannelStateNotification::default_instance_;
-  delete UpdateChannelStateNotification_reflection_;
-  delete UpdateMemberStateNotification::default_instance_;
-  delete UpdateMemberStateNotification_reflection_;
-}
-
-void protobuf_AddDesc_channel_5fservice_2eproto() {
-  static bool already_here = false;
-  if (already_here) return;
-  already_here = true;
-  GOOGLE_PROTOBUF_VERIFY_VERSION;
-
-  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
-  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
-  ::bgs::protocol::channel::v1::protobuf_AddDesc_channel_5ftypes_2eproto();
-  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
-  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-    "\n\025channel_service.proto\022\027bgs.protocol.ch"
-    "annel.v1\032\023account_types.proto\032\022entity_ty"
-    "pes.proto\032\023channel_types.proto\032\017rpc_type"
-    "s.proto\"z\n\023RemoveMemberRequest\022(\n\010agent_"
-    "id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\tmemb"
-    "er_id\030\002 \002(\0132\026.bgs.protocol.EntityId\022\016\n\006r"
-    "eason\030\003 \001(\r\"\221\001\n\022SendMessageRequest\022(\n\010ag"
-    "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\0221\n\007"
-    "message\030\002 \002(\0132 .bgs.protocol.channel.v1."
-    "Message\022\036\n\023required_privileges\030\003 \001(\004:\0010\""
-    "\202\001\n\031UpdateChannelStateRequest\022(\n\010agent_i"
-    "d\030\001 \001(\0132\026.bgs.protocol.EntityId\022;\n\014state"
-    "_change\030\002 \002(\0132%.bgs.protocol.channel.v1."
-    "ChannelState\"\225\001\n\030UpdateMemberStateReques"
-    "t\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.Entit"
-    "yId\0225\n\014state_change\030\002 \003(\0132\037.bgs.protocol"
-    ".channel.v1.Member\022\030\n\014removed_role\030\003 \003(\r"
-    "B\002\020\001\"K\n\017DissolveRequest\022(\n\010agent_id\030\001 \001("
-    "\0132\026.bgs.protocol.EntityId\022\016\n\006reason\030\002 \001("
-    "\r\"\237\002\n\020JoinNotification\022-\n\004self\030\001 \001(\0132\037.b"
-    "gs.protocol.channel.v1.Member\022/\n\006member\030"
-    "\002 \003(\0132\037.bgs.protocol.channel.v1.Member\022<"
-    "\n\rchannel_state\030\003 \002(\0132%.bgs.protocol.cha"
-    "nnel.v1.ChannelState\0226\n\nchannel_id\030\004 \001(\013"
-    "2\".bgs.protocol.channel.v1.ChannelId\0225\n\n"
-    "subscriber\030\005 \001(\0132!.bgs.protocol.account."
-    "v1.Identity\"\271\001\n\027MemberAddedNotification\022"
-    "/\n\006member\030\001 \002(\0132\037.bgs.protocol.channel.v"
-    "1.Member\0226\n\nchannel_id\030\002 \001(\0132\".bgs.proto"
-    "col.channel.v1.ChannelId\0225\n\nsubscriber\030\003"
-    " \001(\0132!.bgs.protocol.account.v1.Identity\""
-    "\353\001\n\021LeaveNotification\022(\n\010agent_id\030\001 \001(\0132"
-    "\026.bgs.protocol.EntityId\022-\n\tmember_id\030\002 \002"
-    "(\0132\026.bgs.protocol.EntityIdB\002\030\001\022\016\n\006reason"
-    "\030\003 \001(\r\0226\n\nchannel_id\030\004 \001(\0132\".bgs.protoco"
-    "l.channel.v1.ChannelId\0225\n\nsubscriber\030\005 \001"
-    "(\0132!.bgs.protocol.account.v1.Identity\"\357\001"
-    "\n\031MemberRemovedNotification\022(\n\010agent_id\030"
-    "\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\tmember_"
-    "id\030\002 \002(\0132\026.bgs.protocol.EntityId\022\016\n\006reas"
-    "on\030\003 \001(\r\0226\n\nchannel_id\030\004 \001(\0132\".bgs.proto"
-    "col.channel.v1.ChannelId\0225\n\nsubscriber\030\005"
-    " \001(\0132!.bgs.protocol.account.v1.Identity\""
-    "\231\002\n\027SendMessageNotification\022(\n\010agent_id\030"
-    "\001 \001(\0132\026.bgs.protocol.EntityId\0221\n\007message"
-    "\030\002 \002(\0132 .bgs.protocol.channel.v1.Message"
-    "\022\036\n\023required_privileges\030\003 \001(\004:\0010\022\022\n\nbatt"
-    "le_tag\030\004 \001(\t\0226\n\nchannel_id\030\005 \001(\0132\".bgs.p"
-    "rotocol.channel.v1.ChannelId\0225\n\nsubscrib"
-    "er\030\006 \001(\0132!.bgs.protocol.account.v1.Ident"
-    "ity\"\366\001\n\036UpdateChannelStateNotification\022("
-    "\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.EntityId"
-    "\022;\n\014state_change\030\002 \002(\0132%.bgs.protocol.ch"
-    "annel.v1.ChannelState\0226\n\nchannel_id\030\003 \001("
-    "\0132\".bgs.protocol.channel.v1.ChannelId\0225\n"
-    "\nsubscriber\030\004 \001(\0132!.bgs.protocol.account"
-    ".v1.Identity\"\357\001\n\035UpdateMemberStateNotifi"
-    "cation\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol."
-    "EntityId\0225\n\014state_change\030\002 \003(\0132\037.bgs.pro"
-    "tocol.channel.v1.Member\0226\n\nchannel_id\030\004 "
-    "\001(\0132\".bgs.protocol.channel.v1.ChannelId\022"
-    "5\n\nsubscriber\030\005 \001(\0132!.bgs.protocol.accou"
-    "nt.v1.Identity2\200\004\n\016ChannelService\022X\n\014Rem"
-    "oveMember\022,.bgs.protocol.channel.v1.Remo"
-    "veMemberRequest\032\024.bgs.protocol.NoData\"\004\200"
-    "\265\030\002\022V\n\013SendMessage\022+.bgs.protocol.channe"
-    "l.v1.SendMessageRequest\032\024.bgs.protocol.N"
-    "oData\"\004\200\265\030\003\022d\n\022UpdateChannelState\0222.bgs."
-    "protocol.channel.v1.UpdateChannelStateRe"
-    "quest\032\024.bgs.protocol.NoData\"\004\200\265\030\004\022b\n\021Upd"
-    "ateMemberState\0221.bgs.protocol.channel.v1"
-    ".UpdateMemberStateRequest\032\024.bgs.protocol"
-    ".NoData\"\004\200\265\030\005\022P\n\010Dissolve\022(.bgs.protocol"
-    ".channel.v1.DissolveRequest\032\024.bgs.protoc"
-    "ol.NoData\"\004\200\265\030\006\032 \312>\035bnet.protocol.channe"
-    "l.Channel2\375\005\n\017ChannelListener\022T\n\006OnJoin\022"
-    ").bgs.protocol.channel.v1.JoinNotificati"
-    "on\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\001\022b\n\rO"
-    "nMemberAdded\0220.bgs.protocol.channel.v1.M"
-    "emberAddedNotification\032\031.bgs.protocol.NO"
-    "_RESPONSE\"\004\200\265\030\002\022V\n\007OnLeave\022*.bgs.protoco"
-    "l.channel.v1.LeaveNotification\032\031.bgs.pro"
-    "tocol.NO_RESPONSE\"\004\200\265\030\003\022f\n\017OnMemberRemov"
-    "ed\0222.bgs.protocol.channel.v1.MemberRemov"
-    "edNotification\032\031.bgs.protocol.NO_RESPONS"
-    "E\"\004\200\265\030\004\022b\n\rOnSendMessage\0220.bgs.protocol."
-    "channel.v1.SendMessageNotification\032\031.bgs"
-    ".protocol.NO_RESPONSE\"\004\200\265\030\005\022p\n\024OnUpdateC"
-    "hannelState\0227.bgs.protocol.channel.v1.Up"
-    "dateChannelStateNotification\032\031.bgs.proto"
-    "col.NO_RESPONSE\"\004\200\265\030\006\022n\n\023OnUpdateMemberS"
-    "tate\0226.bgs.protocol.channel.v1.UpdateMem"
-    "berStateNotification\032\031.bgs.protocol.NO_R"
-    "ESPONSE\"\004\200\265\030\007\032*\312>\'bnet.protocol.channel."
-    "ChannelSubscriberB\005H\001\200\001\000", 3784);
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
-    "channel_service.proto", &protobuf_RegisterTypes);
-  RemoveMemberRequest::default_instance_ = new RemoveMemberRequest();
-  SendMessageRequest::default_instance_ = new SendMessageRequest();
-  UpdateChannelStateRequest::default_instance_ = new UpdateChannelStateRequest();
-  UpdateMemberStateRequest::default_instance_ = new UpdateMemberStateRequest();
-  DissolveRequest::default_instance_ = new DissolveRequest();
-  JoinNotification::default_instance_ = new JoinNotification();
-  MemberAddedNotification::default_instance_ = new MemberAddedNotification();
-  LeaveNotification::default_instance_ = new LeaveNotification();
-  MemberRemovedNotification::default_instance_ = new MemberRemovedNotification();
-  SendMessageNotification::default_instance_ = new SendMessageNotification();
-  UpdateChannelStateNotification::default_instance_ = new UpdateChannelStateNotification();
-  UpdateMemberStateNotification::default_instance_ = new UpdateMemberStateNotification();
-  RemoveMemberRequest::default_instance_->InitAsDefaultInstance();
-  SendMessageRequest::default_instance_->InitAsDefaultInstance();
-  UpdateChannelStateRequest::default_instance_->InitAsDefaultInstance();
-  UpdateMemberStateRequest::default_instance_->InitAsDefaultInstance();
-  DissolveRequest::default_instance_->InitAsDefaultInstance();
-  JoinNotification::default_instance_->InitAsDefaultInstance();
-  MemberAddedNotification::default_instance_->InitAsDefaultInstance();
-  LeaveNotification::default_instance_->InitAsDefaultInstance();
-  MemberRemovedNotification::default_instance_->InitAsDefaultInstance();
-  SendMessageNotification::default_instance_->InitAsDefaultInstance();
-  UpdateChannelStateNotification::default_instance_->InitAsDefaultInstance();
-  UpdateMemberStateNotification::default_instance_->InitAsDefaultInstance();
-  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_channel_5fservice_2eproto);
-}
-
-// Force AddDescriptors() to be called at static initialization time.
-struct StaticDescriptorInitializer_channel_5fservice_2eproto {
-  StaticDescriptorInitializer_channel_5fservice_2eproto() {
-    protobuf_AddDesc_channel_5fservice_2eproto();
-  }
-} static_descriptor_initializer_channel_5fservice_2eproto_;
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int RemoveMemberRequest::kAgentIdFieldNumber;
-const int RemoveMemberRequest::kMemberIdFieldNumber;
-const int RemoveMemberRequest::kReasonFieldNumber;
-#endif  // !_MSC_VER
-
-RemoveMemberRequest::RemoveMemberRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.RemoveMemberRequest)
-}
-
-void RemoveMemberRequest::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-}
-
-RemoveMemberRequest::RemoveMemberRequest(const RemoveMemberRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.RemoveMemberRequest)
-}
-
-void RemoveMemberRequest::SharedCtor() {
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  member_id_ = NULL;
-  reason_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-RemoveMemberRequest::~RemoveMemberRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.RemoveMemberRequest)
-  SharedDtor();
-}
-
-void RemoveMemberRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_id_;
-    delete member_id_;
-  }
-}
-
-void RemoveMemberRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* RemoveMemberRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return RemoveMemberRequest_descriptor_;
-}
-
-const RemoveMemberRequest& RemoveMemberRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-RemoveMemberRequest* RemoveMemberRequest::default_instance_ = NULL;
-
-RemoveMemberRequest* RemoveMemberRequest::New() const {
-  return new RemoveMemberRequest;
-}
-
-void RemoveMemberRequest::Clear() {
-  if (_has_bits_[0 / 32] & 7) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_member_id()) {
-      if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
-    }
-    reason_ = 0u;
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool RemoveMemberRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.RemoveMemberRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_member_id;
-        break;
-      }
-
-      // required .bgs.protocol.EntityId member_id = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_member_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_member_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_reason;
-        break;
-      }
-
-      // optional uint32 reason = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_reason:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &reason_)));
-          set_has_reason();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.RemoveMemberRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.RemoveMemberRequest)
-  return false;
-#undef DO_
-}
-
-void RemoveMemberRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.RemoveMemberRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // required .bgs.protocol.EntityId member_id = 2;
-  if (has_member_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->member_id(), output);
-  }
-
-  // optional uint32 reason = 3;
-  if (has_reason()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.RemoveMemberRequest)
-}
-
-::google::protobuf::uint8* RemoveMemberRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.RemoveMemberRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // required .bgs.protocol.EntityId member_id = 2;
-  if (has_member_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->member_id(), target);
-  }
-
-  // optional uint32 reason = 3;
-  if (has_reason()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.RemoveMemberRequest)
-  return target;
-}
-
-int RemoveMemberRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // required .bgs.protocol.EntityId member_id = 2;
-    if (has_member_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->member_id());
-    }
-
-    // optional uint32 reason = 3;
-    if (has_reason()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->reason());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void RemoveMemberRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const RemoveMemberRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const RemoveMemberRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void RemoveMemberRequest::MergeFrom(const RemoveMemberRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_member_id()) {
-      mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id());
-    }
-    if (from.has_reason()) {
-      set_reason(from.reason());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void RemoveMemberRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void RemoveMemberRequest::CopyFrom(const RemoveMemberRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool RemoveMemberRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (has_member_id()) {
-    if (!this->member_id().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void RemoveMemberRequest::Swap(RemoveMemberRequest* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    std::swap(member_id_, other->member_id_);
-    std::swap(reason_, other->reason_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata RemoveMemberRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = RemoveMemberRequest_descriptor_;
-  metadata.reflection = RemoveMemberRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int SendMessageRequest::kAgentIdFieldNumber;
-const int SendMessageRequest::kMessageFieldNumber;
-const int SendMessageRequest::kRequiredPrivilegesFieldNumber;
-#endif  // !_MSC_VER
-
-SendMessageRequest::SendMessageRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.SendMessageRequest)
-}
-
-void SendMessageRequest::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  message_ = const_cast< ::bgs::protocol::channel::v1::Message*>(&::bgs::protocol::channel::v1::Message::default_instance());
-}
-
-SendMessageRequest::SendMessageRequest(const SendMessageRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.SendMessageRequest)
-}
-
-void SendMessageRequest::SharedCtor() {
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  message_ = NULL;
-  required_privileges_ = GOOGLE_ULONGLONG(0);
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-SendMessageRequest::~SendMessageRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.SendMessageRequest)
-  SharedDtor();
-}
-
-void SendMessageRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_id_;
-    delete message_;
-  }
-}
-
-void SendMessageRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* SendMessageRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return SendMessageRequest_descriptor_;
-}
-
-const SendMessageRequest& SendMessageRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-SendMessageRequest* SendMessageRequest::default_instance_ = NULL;
-
-SendMessageRequest* SendMessageRequest::New() const {
-  return new SendMessageRequest;
-}
-
-void SendMessageRequest::Clear() {
-  if (_has_bits_[0 / 32] & 7) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_message()) {
-      if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear();
-    }
-    required_privileges_ = GOOGLE_ULONGLONG(0);
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool SendMessageRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.SendMessageRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_message;
-        break;
-      }
-
-      // required .bgs.protocol.channel.v1.Message message = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_message:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_message()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_required_privileges;
-        break;
-      }
-
-      // optional uint64 required_privileges = 3 [default = 0];
-      case 3: {
-        if (tag == 24) {
-         parse_required_privileges:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &required_privileges_)));
-          set_has_required_privileges();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.SendMessageRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.SendMessageRequest)
-  return false;
-#undef DO_
-}
-
-void SendMessageRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.SendMessageRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // required .bgs.protocol.channel.v1.Message message = 2;
-  if (has_message()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->message(), output);
-  }
-
-  // optional uint64 required_privileges = 3 [default = 0];
-  if (has_required_privileges()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->required_privileges(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.SendMessageRequest)
-}
-
-::google::protobuf::uint8* SendMessageRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.SendMessageRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // required .bgs.protocol.channel.v1.Message message = 2;
-  if (has_message()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->message(), target);
-  }
-
-  // optional uint64 required_privileges = 3 [default = 0];
-  if (has_required_privileges()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->required_privileges(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.SendMessageRequest)
-  return target;
-}
-
-int SendMessageRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // required .bgs.protocol.channel.v1.Message message = 2;
-    if (has_message()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->message());
-    }
-
-    // optional uint64 required_privileges = 3 [default = 0];
-    if (has_required_privileges()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->required_privileges());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void SendMessageRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const SendMessageRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const SendMessageRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void SendMessageRequest::MergeFrom(const SendMessageRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_message()) {
-      mutable_message()->::bgs::protocol::channel::v1::Message::MergeFrom(from.message());
-    }
-    if (from.has_required_privileges()) {
-      set_required_privileges(from.required_privileges());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void SendMessageRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void SendMessageRequest::CopyFrom(const SendMessageRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SendMessageRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (has_message()) {
-    if (!this->message().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void SendMessageRequest::Swap(SendMessageRequest* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    std::swap(message_, other->message_);
-    std::swap(required_privileges_, other->required_privileges_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata SendMessageRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = SendMessageRequest_descriptor_;
-  metadata.reflection = SendMessageRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int UpdateChannelStateRequest::kAgentIdFieldNumber;
-const int UpdateChannelStateRequest::kStateChangeFieldNumber;
-#endif  // !_MSC_VER
-
-UpdateChannelStateRequest::UpdateChannelStateRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-}
-
-void UpdateChannelStateRequest::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  state_change_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance());
-}
-
-UpdateChannelStateRequest::UpdateChannelStateRequest(const UpdateChannelStateRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-}
-
-void UpdateChannelStateRequest::SharedCtor() {
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  state_change_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-UpdateChannelStateRequest::~UpdateChannelStateRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-  SharedDtor();
-}
-
-void UpdateChannelStateRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_id_;
-    delete state_change_;
-  }
-}
-
-void UpdateChannelStateRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* UpdateChannelStateRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return UpdateChannelStateRequest_descriptor_;
-}
-
-const UpdateChannelStateRequest& UpdateChannelStateRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-UpdateChannelStateRequest* UpdateChannelStateRequest::default_instance_ = NULL;
-
-UpdateChannelStateRequest* UpdateChannelStateRequest::New() const {
-  return new UpdateChannelStateRequest;
-}
-
-void UpdateChannelStateRequest::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_state_change()) {
-      if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear();
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool UpdateChannelStateRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_state_change;
-        break;
-      }
-
-      // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_state_change:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_state_change()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-  return false;
-#undef DO_
-}
-
-void UpdateChannelStateRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-  if (has_state_change()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->state_change(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-}
-
-::google::protobuf::uint8* UpdateChannelStateRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-  if (has_state_change()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->state_change(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateChannelStateRequest)
-  return target;
-}
-
-int UpdateChannelStateRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-    if (has_state_change()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->state_change());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void UpdateChannelStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const UpdateChannelStateRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateChannelStateRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void UpdateChannelStateRequest::MergeFrom(const UpdateChannelStateRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_state_change()) {
-      mutable_state_change()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.state_change());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void UpdateChannelStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void UpdateChannelStateRequest::CopyFrom(const UpdateChannelStateRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool UpdateChannelStateRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (has_state_change()) {
-    if (!this->state_change().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void UpdateChannelStateRequest::Swap(UpdateChannelStateRequest* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    std::swap(state_change_, other->state_change_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata UpdateChannelStateRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = UpdateChannelStateRequest_descriptor_;
-  metadata.reflection = UpdateChannelStateRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int UpdateMemberStateRequest::kAgentIdFieldNumber;
-const int UpdateMemberStateRequest::kStateChangeFieldNumber;
-const int UpdateMemberStateRequest::kRemovedRoleFieldNumber;
-#endif  // !_MSC_VER
-
-UpdateMemberStateRequest::UpdateMemberStateRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-}
-
-void UpdateMemberStateRequest::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-}
-
-UpdateMemberStateRequest::UpdateMemberStateRequest(const UpdateMemberStateRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-}
-
-void UpdateMemberStateRequest::SharedCtor() {
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  _removed_role_cached_byte_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-UpdateMemberStateRequest::~UpdateMemberStateRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-  SharedDtor();
-}
-
-void UpdateMemberStateRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_id_;
-  }
-}
-
-void UpdateMemberStateRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* UpdateMemberStateRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return UpdateMemberStateRequest_descriptor_;
-}
-
-const UpdateMemberStateRequest& UpdateMemberStateRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-UpdateMemberStateRequest* UpdateMemberStateRequest::default_instance_ = NULL;
-
-UpdateMemberStateRequest* UpdateMemberStateRequest::New() const {
-  return new UpdateMemberStateRequest;
-}
-
-void UpdateMemberStateRequest::Clear() {
-  if (has_agent_id()) {
-    if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  }
-  state_change_.Clear();
-  removed_role_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool UpdateMemberStateRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_state_change;
-        break;
-      }
-
-      // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_state_change:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_state_change()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_state_change;
-        if (input->ExpectTag(26)) goto parse_removed_role;
-        break;
-      }
-
-      // repeated uint32 removed_role = 3 [packed = true];
-      case 3: {
-        if (tag == 26) {
-         parse_removed_role:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, this->mutable_removed_role())));
-        } else if (tag == 24) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 1, 26, input, this->mutable_removed_role())));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-  return false;
-#undef DO_
-}
-
-void UpdateMemberStateRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-  for (int i = 0; i < this->state_change_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->state_change(i), output);
-  }
-
-  // repeated uint32 removed_role = 3 [packed = true];
-  if (this->removed_role_size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
-    output->WriteVarint32(_removed_role_cached_byte_size_);
-  }
-  for (int i = 0; i < this->removed_role_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
-      this->removed_role(i), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-}
-
-::google::protobuf::uint8* UpdateMemberStateRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-  for (int i = 0; i < this->state_change_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->state_change(i), target);
-  }
-
-  // repeated uint32 removed_role = 3 [packed = true];
-  if (this->removed_role_size() > 0) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
-      3,
-      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
-      target);
-    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
-      _removed_role_cached_byte_size_, target);
-  }
-  for (int i = 0; i < this->removed_role_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteUInt32NoTagToArray(this->removed_role(i), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateMemberStateRequest)
-  return target;
-}
-
-int UpdateMemberStateRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-  }
-  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-  total_size += 1 * this->state_change_size();
-  for (int i = 0; i < this->state_change_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->state_change(i));
-  }
-
-  // repeated uint32 removed_role = 3 [packed = true];
-  {
-    int data_size = 0;
-    for (int i = 0; i < this->removed_role_size(); i++) {
-      data_size += ::google::protobuf::internal::WireFormatLite::
-        UInt32Size(this->removed_role(i));
-    }
-    if (data_size > 0) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
-    }
-    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-    _removed_role_cached_byte_size_ = data_size;
-    GOOGLE_SAFE_CONCURRENT_WRITES_END();
-    total_size += data_size;
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void UpdateMemberStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const UpdateMemberStateRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateMemberStateRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void UpdateMemberStateRequest::MergeFrom(const UpdateMemberStateRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  state_change_.MergeFrom(from.state_change_);
-  removed_role_.MergeFrom(from.removed_role_);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void UpdateMemberStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void UpdateMemberStateRequest::CopyFrom(const UpdateMemberStateRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool UpdateMemberStateRequest::IsInitialized() const {
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (!::google::protobuf::internal::AllAreInitialized(this->state_change())) return false;
-  return true;
-}
-
-void UpdateMemberStateRequest::Swap(UpdateMemberStateRequest* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    state_change_.Swap(&other->state_change_);
-    removed_role_.Swap(&other->removed_role_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata UpdateMemberStateRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = UpdateMemberStateRequest_descriptor_;
-  metadata.reflection = UpdateMemberStateRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int DissolveRequest::kAgentIdFieldNumber;
-const int DissolveRequest::kReasonFieldNumber;
-#endif  // !_MSC_VER
-
-DissolveRequest::DissolveRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.DissolveRequest)
-}
-
-void DissolveRequest::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-}
-
-DissolveRequest::DissolveRequest(const DissolveRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.DissolveRequest)
-}
-
-void DissolveRequest::SharedCtor() {
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  reason_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-DissolveRequest::~DissolveRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.DissolveRequest)
-  SharedDtor();
-}
-
-void DissolveRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_id_;
-  }
-}
-
-void DissolveRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* DissolveRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return DissolveRequest_descriptor_;
-}
-
-const DissolveRequest& DissolveRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-DissolveRequest* DissolveRequest::default_instance_ = NULL;
-
-DissolveRequest* DissolveRequest::New() const {
-  return new DissolveRequest;
-}
-
-void DissolveRequest::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    reason_ = 0u;
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool DissolveRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.DissolveRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(16)) goto parse_reason;
-        break;
-      }
-
-      // optional uint32 reason = 2;
-      case 2: {
-        if (tag == 16) {
-         parse_reason:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &reason_)));
-          set_has_reason();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.DissolveRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.DissolveRequest)
-  return false;
-#undef DO_
-}
-
-void DissolveRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.DissolveRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // optional uint32 reason = 2;
-  if (has_reason()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->reason(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.DissolveRequest)
-}
-
-::google::protobuf::uint8* DissolveRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.DissolveRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // optional uint32 reason = 2;
-  if (has_reason()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->reason(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.DissolveRequest)
-  return target;
-}
-
-int DissolveRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // optional uint32 reason = 2;
-    if (has_reason()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->reason());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void DissolveRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const DissolveRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const DissolveRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void DissolveRequest::MergeFrom(const DissolveRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_reason()) {
-      set_reason(from.reason());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void DissolveRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void DissolveRequest::CopyFrom(const DissolveRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool DissolveRequest::IsInitialized() const {
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void DissolveRequest::Swap(DissolveRequest* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    std::swap(reason_, other->reason_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata DissolveRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = DissolveRequest_descriptor_;
-  metadata.reflection = DissolveRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int JoinNotification::kSelfFieldNumber;
-const int JoinNotification::kMemberFieldNumber;
-const int JoinNotification::kChannelStateFieldNumber;
-const int JoinNotification::kChannelIdFieldNumber;
-const int JoinNotification::kSubscriberFieldNumber;
-#endif  // !_MSC_VER
-
-JoinNotification::JoinNotification()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.JoinNotification)
-}
-
-void JoinNotification::InitAsDefaultInstance() {
-  self_ = const_cast< ::bgs::protocol::channel::v1::Member*>(&::bgs::protocol::channel::v1::Member::default_instance());
-  channel_state_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance());
-  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
-  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
-}
-
-JoinNotification::JoinNotification(const JoinNotification& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.JoinNotification)
-}
-
-void JoinNotification::SharedCtor() {
-  _cached_size_ = 0;
-  self_ = NULL;
-  channel_state_ = NULL;
-  channel_id_ = NULL;
-  subscriber_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-JoinNotification::~JoinNotification() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.JoinNotification)
-  SharedDtor();
-}
-
-void JoinNotification::SharedDtor() {
-  if (this != default_instance_) {
-    delete self_;
-    delete channel_state_;
-    delete channel_id_;
-    delete subscriber_;
-  }
-}
-
-void JoinNotification::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* JoinNotification::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return JoinNotification_descriptor_;
-}
-
-const JoinNotification& JoinNotification::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-JoinNotification* JoinNotification::default_instance_ = NULL;
-
-JoinNotification* JoinNotification::New() const {
-  return new JoinNotification;
-}
-
-void JoinNotification::Clear() {
-  if (_has_bits_[0 / 32] & 29) {
-    if (has_self()) {
-      if (self_ != NULL) self_->::bgs::protocol::channel::v1::Member::Clear();
-    }
-    if (has_channel_state()) {
-      if (channel_state_ != NULL) channel_state_->::bgs::protocol::channel::v1::ChannelState::Clear();
-    }
-    if (has_channel_id()) {
-      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-    }
-    if (has_subscriber()) {
-      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-    }
-  }
-  member_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool JoinNotification::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.JoinNotification)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.channel.v1.Member self = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_self()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_member;
-        break;
-      }
-
-      // repeated .bgs.protocol.channel.v1.Member member = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_member:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_member()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_member;
-        if (input->ExpectTag(26)) goto parse_channel_state;
-        break;
-      }
-
-      // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_channel_state:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_channel_state()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_channel_id;
-        break;
-      }
-
-      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_channel_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_channel_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_subscriber;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_subscriber:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_subscriber()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.JoinNotification)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.JoinNotification)
-  return false;
-#undef DO_
-}
-
-void JoinNotification::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.JoinNotification)
-  // optional .bgs.protocol.channel.v1.Member self = 1;
-  if (has_self()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->self(), output);
-  }
-
-  // repeated .bgs.protocol.channel.v1.Member member = 2;
-  for (int i = 0; i < this->member_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->member(i), output);
-  }
-
-  // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
-  if (has_channel_state()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      3, this->channel_state(), output);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  if (has_channel_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, this->channel_id(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  if (has_subscriber()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, this->subscriber(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.JoinNotification)
-}
-
-::google::protobuf::uint8* JoinNotification::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.JoinNotification)
-  // optional .bgs.protocol.channel.v1.Member self = 1;
-  if (has_self()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->self(), target);
-  }
-
-  // repeated .bgs.protocol.channel.v1.Member member = 2;
-  for (int i = 0; i < this->member_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->member(i), target);
-  }
-
-  // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
-  if (has_channel_state()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        3, this->channel_state(), target);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  if (has_channel_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        4, this->channel_id(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  if (has_subscriber()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->subscriber(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.JoinNotification)
-  return target;
-}
-
-int JoinNotification::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.channel.v1.Member self = 1;
-    if (has_self()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->self());
-    }
-
-    // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
-    if (has_channel_state()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->channel_state());
-    }
-
-    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-    if (has_channel_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->channel_id());
-    }
-
-    // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-    if (has_subscriber()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->subscriber());
-    }
-
-  }
-  // repeated .bgs.protocol.channel.v1.Member member = 2;
-  total_size += 1 * this->member_size();
-  for (int i = 0; i < this->member_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->member(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void JoinNotification::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const JoinNotification* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const JoinNotification*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void JoinNotification::MergeFrom(const JoinNotification& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  member_.MergeFrom(from.member_);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_self()) {
-      mutable_self()->::bgs::protocol::channel::v1::Member::MergeFrom(from.self());
-    }
-    if (from.has_channel_state()) {
-      mutable_channel_state()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.channel_state());
-    }
-    if (from.has_channel_id()) {
-      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
-    }
-    if (from.has_subscriber()) {
-      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void JoinNotification::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void JoinNotification::CopyFrom(const JoinNotification& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool JoinNotification::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false;
-
-  if (has_self()) {
-    if (!this->self().IsInitialized()) return false;
-  }
-  if (!::google::protobuf::internal::AllAreInitialized(this->member())) return false;
-  if (has_channel_state()) {
-    if (!this->channel_state().IsInitialized()) return false;
-  }
-  if (has_channel_id()) {
-    if (!this->channel_id().IsInitialized()) return false;
-  }
-  if (has_subscriber()) {
-    if (!this->subscriber().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void JoinNotification::Swap(JoinNotification* other) {
-  if (other != this) {
-    std::swap(self_, other->self_);
-    member_.Swap(&other->member_);
-    std::swap(channel_state_, other->channel_state_);
-    std::swap(channel_id_, other->channel_id_);
-    std::swap(subscriber_, other->subscriber_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata JoinNotification::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = JoinNotification_descriptor_;
-  metadata.reflection = JoinNotification_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int MemberAddedNotification::kMemberFieldNumber;
-const int MemberAddedNotification::kChannelIdFieldNumber;
-const int MemberAddedNotification::kSubscriberFieldNumber;
-#endif  // !_MSC_VER
-
-MemberAddedNotification::MemberAddedNotification()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.MemberAddedNotification)
-}
-
-void MemberAddedNotification::InitAsDefaultInstance() {
-  member_ = const_cast< ::bgs::protocol::channel::v1::Member*>(&::bgs::protocol::channel::v1::Member::default_instance());
-  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
-  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
-}
-
-MemberAddedNotification::MemberAddedNotification(const MemberAddedNotification& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.MemberAddedNotification)
-}
-
-void MemberAddedNotification::SharedCtor() {
-  _cached_size_ = 0;
-  member_ = NULL;
-  channel_id_ = NULL;
-  subscriber_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-MemberAddedNotification::~MemberAddedNotification() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.MemberAddedNotification)
-  SharedDtor();
-}
-
-void MemberAddedNotification::SharedDtor() {
-  if (this != default_instance_) {
-    delete member_;
-    delete channel_id_;
-    delete subscriber_;
-  }
-}
-
-void MemberAddedNotification::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* MemberAddedNotification::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return MemberAddedNotification_descriptor_;
-}
-
-const MemberAddedNotification& MemberAddedNotification::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-MemberAddedNotification* MemberAddedNotification::default_instance_ = NULL;
-
-MemberAddedNotification* MemberAddedNotification::New() const {
-  return new MemberAddedNotification;
-}
-
-void MemberAddedNotification::Clear() {
-  if (_has_bits_[0 / 32] & 7) {
-    if (has_member()) {
-      if (member_ != NULL) member_->::bgs::protocol::channel::v1::Member::Clear();
-    }
-    if (has_channel_id()) {
-      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-    }
-    if (has_subscriber()) {
-      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool MemberAddedNotification::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.MemberAddedNotification)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required .bgs.protocol.channel.v1.Member member = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_member()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_channel_id;
-        break;
-      }
-
-      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_channel_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_channel_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_subscriber;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.Identity subscriber = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_subscriber:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_subscriber()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.MemberAddedNotification)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.MemberAddedNotification)
-  return false;
-#undef DO_
-}
-
-void MemberAddedNotification::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.MemberAddedNotification)
-  // required .bgs.protocol.channel.v1.Member member = 1;
-  if (has_member()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->member(), output);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
-  if (has_channel_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->channel_id(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 3;
-  if (has_subscriber()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      3, this->subscriber(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.MemberAddedNotification)
-}
-
-::google::protobuf::uint8* MemberAddedNotification::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.MemberAddedNotification)
-  // required .bgs.protocol.channel.v1.Member member = 1;
-  if (has_member()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->member(), target);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
-  if (has_channel_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->channel_id(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 3;
-  if (has_subscriber()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        3, this->subscriber(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.MemberAddedNotification)
-  return target;
-}
-
-int MemberAddedNotification::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required .bgs.protocol.channel.v1.Member member = 1;
-    if (has_member()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->member());
-    }
-
-    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
-    if (has_channel_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->channel_id());
-    }
-
-    // optional .bgs.protocol.account.v1.Identity subscriber = 3;
-    if (has_subscriber()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->subscriber());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void MemberAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const MemberAddedNotification* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const MemberAddedNotification*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void MemberAddedNotification::MergeFrom(const MemberAddedNotification& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_member()) {
-      mutable_member()->::bgs::protocol::channel::v1::Member::MergeFrom(from.member());
-    }
-    if (from.has_channel_id()) {
-      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
-    }
-    if (from.has_subscriber()) {
-      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void MemberAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void MemberAddedNotification::CopyFrom(const MemberAddedNotification& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool MemberAddedNotification::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
-
-  if (has_member()) {
-    if (!this->member().IsInitialized()) return false;
-  }
-  if (has_channel_id()) {
-    if (!this->channel_id().IsInitialized()) return false;
-  }
-  if (has_subscriber()) {
-    if (!this->subscriber().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void MemberAddedNotification::Swap(MemberAddedNotification* other) {
-  if (other != this) {
-    std::swap(member_, other->member_);
-    std::swap(channel_id_, other->channel_id_);
-    std::swap(subscriber_, other->subscriber_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata MemberAddedNotification::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = MemberAddedNotification_descriptor_;
-  metadata.reflection = MemberAddedNotification_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int LeaveNotification::kAgentIdFieldNumber;
-const int LeaveNotification::kMemberIdFieldNumber;
-const int LeaveNotification::kReasonFieldNumber;
-const int LeaveNotification::kChannelIdFieldNumber;
-const int LeaveNotification::kSubscriberFieldNumber;
-#endif  // !_MSC_VER
-
-LeaveNotification::LeaveNotification()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.LeaveNotification)
-}
-
-void LeaveNotification::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
-  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
-}
-
-LeaveNotification::LeaveNotification(const LeaveNotification& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.LeaveNotification)
-}
-
-void LeaveNotification::SharedCtor() {
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  member_id_ = NULL;
-  reason_ = 0u;
-  channel_id_ = NULL;
-  subscriber_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-LeaveNotification::~LeaveNotification() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.LeaveNotification)
-  SharedDtor();
-}
-
-void LeaveNotification::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_id_;
-    delete member_id_;
-    delete channel_id_;
-    delete subscriber_;
-  }
-}
-
-void LeaveNotification::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* LeaveNotification::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return LeaveNotification_descriptor_;
-}
-
-const LeaveNotification& LeaveNotification::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-LeaveNotification* LeaveNotification::default_instance_ = NULL;
-
-LeaveNotification* LeaveNotification::New() const {
-  return new LeaveNotification;
-}
-
-void LeaveNotification::Clear() {
-  if (_has_bits_[0 / 32] & 31) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_member_id()) {
-      if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
-    }
-    reason_ = 0u;
-    if (has_channel_id()) {
-      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-    }
-    if (has_subscriber()) {
-      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool LeaveNotification::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.LeaveNotification)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_member_id;
-        break;
-      }
-
-      // required .bgs.protocol.EntityId member_id = 2 [deprecated = true];
-      case 2: {
-        if (tag == 18) {
-         parse_member_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_member_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_reason;
-        break;
-      }
-
-      // optional uint32 reason = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_reason:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &reason_)));
-          set_has_reason();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_channel_id;
-        break;
-      }
-
-      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_channel_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_channel_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_subscriber;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_subscriber:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_subscriber()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.LeaveNotification)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.LeaveNotification)
-  return false;
-#undef DO_
-}
-
-void LeaveNotification::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.LeaveNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // required .bgs.protocol.EntityId member_id = 2 [deprecated = true];
-  if (has_member_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->member_id(), output);
-  }
-
-  // optional uint32 reason = 3;
-  if (has_reason()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  if (has_channel_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, this->channel_id(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  if (has_subscriber()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, this->subscriber(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.LeaveNotification)
-}
-
-::google::protobuf::uint8* LeaveNotification::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.LeaveNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // required .bgs.protocol.EntityId member_id = 2 [deprecated = true];
-  if (has_member_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->member_id(), target);
-  }
-
-  // optional uint32 reason = 3;
-  if (has_reason()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  if (has_channel_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        4, this->channel_id(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  if (has_subscriber()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->subscriber(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.LeaveNotification)
-  return target;
-}
-
-int LeaveNotification::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // required .bgs.protocol.EntityId member_id = 2 [deprecated = true];
-    if (has_member_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->member_id());
-    }
-
-    // optional uint32 reason = 3;
-    if (has_reason()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->reason());
-    }
-
-    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-    if (has_channel_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->channel_id());
-    }
-
-    // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-    if (has_subscriber()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->subscriber());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void LeaveNotification::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const LeaveNotification* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const LeaveNotification*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void LeaveNotification::MergeFrom(const LeaveNotification& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_member_id()) {
-      mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id());
-    }
-    if (from.has_reason()) {
-      set_reason(from.reason());
-    }
-    if (from.has_channel_id()) {
-      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
-    }
-    if (from.has_subscriber()) {
-      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void LeaveNotification::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void LeaveNotification::CopyFrom(const LeaveNotification& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool LeaveNotification::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (has_member_id()) {
-    if (!this->member_id().IsInitialized()) return false;
-  }
-  if (has_channel_id()) {
-    if (!this->channel_id().IsInitialized()) return false;
-  }
-  if (has_subscriber()) {
-    if (!this->subscriber().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void LeaveNotification::Swap(LeaveNotification* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    std::swap(member_id_, other->member_id_);
-    std::swap(reason_, other->reason_);
-    std::swap(channel_id_, other->channel_id_);
-    std::swap(subscriber_, other->subscriber_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata LeaveNotification::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = LeaveNotification_descriptor_;
-  metadata.reflection = LeaveNotification_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int MemberRemovedNotification::kAgentIdFieldNumber;
-const int MemberRemovedNotification::kMemberIdFieldNumber;
-const int MemberRemovedNotification::kReasonFieldNumber;
-const int MemberRemovedNotification::kChannelIdFieldNumber;
-const int MemberRemovedNotification::kSubscriberFieldNumber;
-#endif  // !_MSC_VER
-
-MemberRemovedNotification::MemberRemovedNotification()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.MemberRemovedNotification)
-}
-
-void MemberRemovedNotification::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
-  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
-}
-
-MemberRemovedNotification::MemberRemovedNotification(const MemberRemovedNotification& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.MemberRemovedNotification)
-}
-
-void MemberRemovedNotification::SharedCtor() {
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  member_id_ = NULL;
-  reason_ = 0u;
-  channel_id_ = NULL;
-  subscriber_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-MemberRemovedNotification::~MemberRemovedNotification() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.MemberRemovedNotification)
-  SharedDtor();
-}
-
-void MemberRemovedNotification::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_id_;
-    delete member_id_;
-    delete channel_id_;
-    delete subscriber_;
-  }
-}
-
-void MemberRemovedNotification::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* MemberRemovedNotification::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return MemberRemovedNotification_descriptor_;
-}
-
-const MemberRemovedNotification& MemberRemovedNotification::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-MemberRemovedNotification* MemberRemovedNotification::default_instance_ = NULL;
-
-MemberRemovedNotification* MemberRemovedNotification::New() const {
-  return new MemberRemovedNotification;
-}
-
-void MemberRemovedNotification::Clear() {
-  if (_has_bits_[0 / 32] & 31) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_member_id()) {
-      if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
-    }
-    reason_ = 0u;
-    if (has_channel_id()) {
-      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-    }
-    if (has_subscriber()) {
-      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool MemberRemovedNotification::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.MemberRemovedNotification)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_member_id;
-        break;
-      }
-
-      // required .bgs.protocol.EntityId member_id = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_member_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_member_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_reason;
-        break;
-      }
-
-      // optional uint32 reason = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_reason:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &reason_)));
-          set_has_reason();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_channel_id;
-        break;
-      }
-
-      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_channel_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_channel_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_subscriber;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_subscriber:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_subscriber()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.MemberRemovedNotification)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.MemberRemovedNotification)
-  return false;
-#undef DO_
-}
-
-void MemberRemovedNotification::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.MemberRemovedNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // required .bgs.protocol.EntityId member_id = 2;
-  if (has_member_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->member_id(), output);
-  }
-
-  // optional uint32 reason = 3;
-  if (has_reason()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  if (has_channel_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, this->channel_id(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  if (has_subscriber()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, this->subscriber(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.MemberRemovedNotification)
-}
-
-::google::protobuf::uint8* MemberRemovedNotification::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.MemberRemovedNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // required .bgs.protocol.EntityId member_id = 2;
-  if (has_member_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->member_id(), target);
-  }
-
-  // optional uint32 reason = 3;
-  if (has_reason()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  if (has_channel_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        4, this->channel_id(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  if (has_subscriber()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->subscriber(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.MemberRemovedNotification)
-  return target;
-}
-
-int MemberRemovedNotification::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // required .bgs.protocol.EntityId member_id = 2;
-    if (has_member_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->member_id());
-    }
-
-    // optional uint32 reason = 3;
-    if (has_reason()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->reason());
-    }
-
-    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-    if (has_channel_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->channel_id());
-    }
-
-    // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-    if (has_subscriber()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->subscriber());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void MemberRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const MemberRemovedNotification* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const MemberRemovedNotification*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void MemberRemovedNotification::MergeFrom(const MemberRemovedNotification& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_member_id()) {
-      mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id());
-    }
-    if (from.has_reason()) {
-      set_reason(from.reason());
-    }
-    if (from.has_channel_id()) {
-      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
-    }
-    if (from.has_subscriber()) {
-      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void MemberRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void MemberRemovedNotification::CopyFrom(const MemberRemovedNotification& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool MemberRemovedNotification::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (has_member_id()) {
-    if (!this->member_id().IsInitialized()) return false;
-  }
-  if (has_channel_id()) {
-    if (!this->channel_id().IsInitialized()) return false;
-  }
-  if (has_subscriber()) {
-    if (!this->subscriber().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void MemberRemovedNotification::Swap(MemberRemovedNotification* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    std::swap(member_id_, other->member_id_);
-    std::swap(reason_, other->reason_);
-    std::swap(channel_id_, other->channel_id_);
-    std::swap(subscriber_, other->subscriber_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata MemberRemovedNotification::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = MemberRemovedNotification_descriptor_;
-  metadata.reflection = MemberRemovedNotification_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int SendMessageNotification::kAgentIdFieldNumber;
-const int SendMessageNotification::kMessageFieldNumber;
-const int SendMessageNotification::kRequiredPrivilegesFieldNumber;
-const int SendMessageNotification::kBattleTagFieldNumber;
-const int SendMessageNotification::kChannelIdFieldNumber;
-const int SendMessageNotification::kSubscriberFieldNumber;
-#endif  // !_MSC_VER
-
-SendMessageNotification::SendMessageNotification()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.SendMessageNotification)
-}
-
-void SendMessageNotification::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  message_ = const_cast< ::bgs::protocol::channel::v1::Message*>(&::bgs::protocol::channel::v1::Message::default_instance());
-  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
-  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
-}
-
-SendMessageNotification::SendMessageNotification(const SendMessageNotification& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.SendMessageNotification)
-}
-
-void SendMessageNotification::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  message_ = NULL;
-  required_privileges_ = GOOGLE_ULONGLONG(0);
-  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  channel_id_ = NULL;
-  subscriber_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-SendMessageNotification::~SendMessageNotification() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.SendMessageNotification)
-  SharedDtor();
-}
-
-void SendMessageNotification::SharedDtor() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (this != default_instance_) {
-    delete agent_id_;
-    delete message_;
-    delete channel_id_;
-    delete subscriber_;
-  }
-}
-
-void SendMessageNotification::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* SendMessageNotification::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return SendMessageNotification_descriptor_;
-}
-
-const SendMessageNotification& SendMessageNotification::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-SendMessageNotification* SendMessageNotification::default_instance_ = NULL;
-
-SendMessageNotification* SendMessageNotification::New() const {
-  return new SendMessageNotification;
-}
-
-void SendMessageNotification::Clear() {
-  if (_has_bits_[0 / 32] & 63) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_message()) {
-      if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear();
-    }
-    required_privileges_ = GOOGLE_ULONGLONG(0);
-    if (has_battle_tag()) {
-      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        battle_tag_->clear();
-      }
-    }
-    if (has_channel_id()) {
-      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-    }
-    if (has_subscriber()) {
-      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool SendMessageNotification::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.SendMessageNotification)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_message;
-        break;
-      }
-
-      // required .bgs.protocol.channel.v1.Message message = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_message:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_message()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_required_privileges;
-        break;
-      }
-
-      // optional uint64 required_privileges = 3 [default = 0];
-      case 3: {
-        if (tag == 24) {
-         parse_required_privileges:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &required_privileges_)));
-          set_has_required_privileges();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_battle_tag;
-        break;
-      }
-
-      // optional string battle_tag = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_battle_tag:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_battle_tag()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->battle_tag().data(), this->battle_tag().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "battle_tag");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_channel_id;
-        break;
-      }
-
-      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_channel_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_channel_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(50)) goto parse_subscriber;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.Identity subscriber = 6;
-      case 6: {
-        if (tag == 50) {
-         parse_subscriber:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_subscriber()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.SendMessageNotification)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.SendMessageNotification)
-  return false;
-#undef DO_
-}
-
-void SendMessageNotification::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.SendMessageNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // required .bgs.protocol.channel.v1.Message message = 2;
-  if (has_message()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->message(), output);
-  }
-
-  // optional uint64 required_privileges = 3 [default = 0];
-  if (has_required_privileges()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->required_privileges(), output);
-  }
-
-  // optional string battle_tag = 4;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      4, this->battle_tag(), output);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
-  if (has_channel_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, this->channel_id(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 6;
-  if (has_subscriber()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      6, this->subscriber(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.SendMessageNotification)
-}
-
-::google::protobuf::uint8* SendMessageNotification::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.SendMessageNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // required .bgs.protocol.channel.v1.Message message = 2;
-  if (has_message()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->message(), target);
-  }
-
-  // optional uint64 required_privileges = 3 [default = 0];
-  if (has_required_privileges()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->required_privileges(), target);
-  }
-
-  // optional string battle_tag = 4;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        4, this->battle_tag(), target);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
-  if (has_channel_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->channel_id(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 6;
-  if (has_subscriber()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        6, this->subscriber(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.SendMessageNotification)
-  return target;
-}
-
-int SendMessageNotification::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // required .bgs.protocol.channel.v1.Message message = 2;
-    if (has_message()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->message());
-    }
-
-    // optional uint64 required_privileges = 3 [default = 0];
-    if (has_required_privileges()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->required_privileges());
-    }
-
-    // optional string battle_tag = 4;
-    if (has_battle_tag()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->battle_tag());
-    }
-
-    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
-    if (has_channel_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->channel_id());
-    }
-
-    // optional .bgs.protocol.account.v1.Identity subscriber = 6;
-    if (has_subscriber()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->subscriber());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void SendMessageNotification::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const SendMessageNotification* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const SendMessageNotification*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void SendMessageNotification::MergeFrom(const SendMessageNotification& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_message()) {
-      mutable_message()->::bgs::protocol::channel::v1::Message::MergeFrom(from.message());
-    }
-    if (from.has_required_privileges()) {
-      set_required_privileges(from.required_privileges());
-    }
-    if (from.has_battle_tag()) {
-      set_battle_tag(from.battle_tag());
-    }
-    if (from.has_channel_id()) {
-      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
-    }
-    if (from.has_subscriber()) {
-      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void SendMessageNotification::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void SendMessageNotification::CopyFrom(const SendMessageNotification& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SendMessageNotification::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (has_message()) {
-    if (!this->message().IsInitialized()) return false;
-  }
-  if (has_channel_id()) {
-    if (!this->channel_id().IsInitialized()) return false;
-  }
-  if (has_subscriber()) {
-    if (!this->subscriber().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void SendMessageNotification::Swap(SendMessageNotification* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    std::swap(message_, other->message_);
-    std::swap(required_privileges_, other->required_privileges_);
-    std::swap(battle_tag_, other->battle_tag_);
-    std::swap(channel_id_, other->channel_id_);
-    std::swap(subscriber_, other->subscriber_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata SendMessageNotification::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = SendMessageNotification_descriptor_;
-  metadata.reflection = SendMessageNotification_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int UpdateChannelStateNotification::kAgentIdFieldNumber;
-const int UpdateChannelStateNotification::kStateChangeFieldNumber;
-const int UpdateChannelStateNotification::kChannelIdFieldNumber;
-const int UpdateChannelStateNotification::kSubscriberFieldNumber;
-#endif  // !_MSC_VER
-
-UpdateChannelStateNotification::UpdateChannelStateNotification()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-}
-
-void UpdateChannelStateNotification::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  state_change_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance());
-  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
-  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
-}
-
-UpdateChannelStateNotification::UpdateChannelStateNotification(const UpdateChannelStateNotification& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-}
-
-void UpdateChannelStateNotification::SharedCtor() {
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  state_change_ = NULL;
-  channel_id_ = NULL;
-  subscriber_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-UpdateChannelStateNotification::~UpdateChannelStateNotification() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-  SharedDtor();
-}
-
-void UpdateChannelStateNotification::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_id_;
-    delete state_change_;
-    delete channel_id_;
-    delete subscriber_;
-  }
-}
-
-void UpdateChannelStateNotification::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* UpdateChannelStateNotification::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return UpdateChannelStateNotification_descriptor_;
-}
-
-const UpdateChannelStateNotification& UpdateChannelStateNotification::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-UpdateChannelStateNotification* UpdateChannelStateNotification::default_instance_ = NULL;
-
-UpdateChannelStateNotification* UpdateChannelStateNotification::New() const {
-  return new UpdateChannelStateNotification;
-}
-
-void UpdateChannelStateNotification::Clear() {
-  if (_has_bits_[0 / 32] & 15) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_state_change()) {
-      if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear();
-    }
-    if (has_channel_id()) {
-      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-    }
-    if (has_subscriber()) {
-      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool UpdateChannelStateNotification::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_state_change;
-        break;
-      }
-
-      // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_state_change:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_state_change()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_channel_id;
-        break;
-      }
-
-      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_channel_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_channel_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_subscriber;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.Identity subscriber = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_subscriber:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_subscriber()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-  return false;
-#undef DO_
-}
-
-void UpdateChannelStateNotification::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-  if (has_state_change()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->state_change(), output);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
-  if (has_channel_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      3, this->channel_id(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 4;
-  if (has_subscriber()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, this->subscriber(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-}
-
-::google::protobuf::uint8* UpdateChannelStateNotification::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-  if (has_state_change()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->state_change(), target);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
-  if (has_channel_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        3, this->channel_id(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 4;
-  if (has_subscriber()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        4, this->subscriber(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateChannelStateNotification)
-  return target;
-}
-
-int UpdateChannelStateNotification::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-    if (has_state_change()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->state_change());
-    }
-
-    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
-    if (has_channel_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->channel_id());
-    }
-
-    // optional .bgs.protocol.account.v1.Identity subscriber = 4;
-    if (has_subscriber()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->subscriber());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void UpdateChannelStateNotification::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const UpdateChannelStateNotification* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateChannelStateNotification*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void UpdateChannelStateNotification::MergeFrom(const UpdateChannelStateNotification& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_state_change()) {
-      mutable_state_change()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.state_change());
-    }
-    if (from.has_channel_id()) {
-      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
-    }
-    if (from.has_subscriber()) {
-      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void UpdateChannelStateNotification::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void UpdateChannelStateNotification::CopyFrom(const UpdateChannelStateNotification& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool UpdateChannelStateNotification::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (has_state_change()) {
-    if (!this->state_change().IsInitialized()) return false;
-  }
-  if (has_channel_id()) {
-    if (!this->channel_id().IsInitialized()) return false;
-  }
-  if (has_subscriber()) {
-    if (!this->subscriber().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void UpdateChannelStateNotification::Swap(UpdateChannelStateNotification* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    std::swap(state_change_, other->state_change_);
-    std::swap(channel_id_, other->channel_id_);
-    std::swap(subscriber_, other->subscriber_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata UpdateChannelStateNotification::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = UpdateChannelStateNotification_descriptor_;
-  metadata.reflection = UpdateChannelStateNotification_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int UpdateMemberStateNotification::kAgentIdFieldNumber;
-const int UpdateMemberStateNotification::kStateChangeFieldNumber;
-const int UpdateMemberStateNotification::kChannelIdFieldNumber;
-const int UpdateMemberStateNotification::kSubscriberFieldNumber;
-#endif  // !_MSC_VER
-
-UpdateMemberStateNotification::UpdateMemberStateNotification()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-}
-
-void UpdateMemberStateNotification::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
-  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
-}
-
-UpdateMemberStateNotification::UpdateMemberStateNotification(const UpdateMemberStateNotification& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-}
-
-void UpdateMemberStateNotification::SharedCtor() {
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  channel_id_ = NULL;
-  subscriber_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-UpdateMemberStateNotification::~UpdateMemberStateNotification() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-  SharedDtor();
-}
-
-void UpdateMemberStateNotification::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_id_;
-    delete channel_id_;
-    delete subscriber_;
-  }
-}
-
-void UpdateMemberStateNotification::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* UpdateMemberStateNotification::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return UpdateMemberStateNotification_descriptor_;
-}
-
-const UpdateMemberStateNotification& UpdateMemberStateNotification::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
-  return *default_instance_;
-}
-
-UpdateMemberStateNotification* UpdateMemberStateNotification::default_instance_ = NULL;
-
-UpdateMemberStateNotification* UpdateMemberStateNotification::New() const {
-  return new UpdateMemberStateNotification;
-}
-
-void UpdateMemberStateNotification::Clear() {
-  if (_has_bits_[0 / 32] & 13) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_channel_id()) {
-      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-    }
-    if (has_subscriber()) {
-      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-    }
-  }
-  state_change_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool UpdateMemberStateNotification::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_state_change;
-        break;
-      }
-
-      // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_state_change:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_state_change()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_state_change;
-        if (input->ExpectTag(34)) goto parse_channel_id;
-        break;
-      }
-
-      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_channel_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_channel_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_subscriber;
-        break;
-      }
-
-      // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_subscriber:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_subscriber()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-  return false;
-#undef DO_
-}
-
-void UpdateMemberStateNotification::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-  for (int i = 0; i < this->state_change_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->state_change(i), output);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  if (has_channel_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, this->channel_id(), output);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  if (has_subscriber()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, this->subscriber(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-}
-
-::google::protobuf::uint8* UpdateMemberStateNotification::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-  for (int i = 0; i < this->state_change_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->state_change(i), target);
-  }
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  if (has_channel_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        4, this->channel_id(), target);
-  }
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  if (has_subscriber()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->subscriber(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateMemberStateNotification)
-  return target;
-}
-
-int UpdateMemberStateNotification::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-    if (has_channel_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->channel_id());
-    }
-
-    // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-    if (has_subscriber()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->subscriber());
-    }
-
-  }
-  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-  total_size += 1 * this->state_change_size();
-  for (int i = 0; i < this->state_change_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->state_change(i));
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void UpdateMemberStateNotification::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const UpdateMemberStateNotification* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateMemberStateNotification*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void UpdateMemberStateNotification::MergeFrom(const UpdateMemberStateNotification& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  state_change_.MergeFrom(from.state_change_);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_channel_id()) {
-      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
-    }
-    if (from.has_subscriber()) {
-      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void UpdateMemberStateNotification::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void UpdateMemberStateNotification::CopyFrom(const UpdateMemberStateNotification& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool UpdateMemberStateNotification::IsInitialized() const {
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (!::google::protobuf::internal::AllAreInitialized(this->state_change())) return false;
-  if (has_channel_id()) {
-    if (!this->channel_id().IsInitialized()) return false;
-  }
-  if (has_subscriber()) {
-    if (!this->subscriber().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void UpdateMemberStateNotification::Swap(UpdateMemberStateNotification* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    state_change_.Swap(&other->state_change_);
-    std::swap(channel_id_, other->channel_id_);
-    std::swap(subscriber_, other->subscriber_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata UpdateMemberStateNotification::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = UpdateMemberStateNotification_descriptor_;
-  metadata.reflection = UpdateMemberStateNotification_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-ChannelService::ChannelService(bool use_original_hash) : service_hash_(use_original_hash ? OriginalHash::value : NameHash::value) {
-}
-
-ChannelService::~ChannelService() {
-}
-
-google::protobuf::ServiceDescriptor const* ChannelService::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChannelService_descriptor_;
-}
-
-void ChannelService::RemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.RemoveMember(bgs.protocol.channel.v1.RemoveMemberRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 2, request, std::move(callback));
-}
-
-void ChannelService::SendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.SendMessage(bgs.protocol.channel.v1.SendMessageRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 3, request, std::move(callback));
-}
-
-void ChannelService::UpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.UpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 4, request, std::move(callback));
-}
-
-void ChannelService::UpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.UpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 5, request, std::move(callback));
-}
-
-void ChannelService::Dissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.Dissolve(bgs.protocol.channel.v1.DissolveRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 6, request, std::move(callback));
-}
-
-void ChannelService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
-  switch(methodId) {
-    case 2: {
-      ::bgs::protocol::channel::v1::RemoveMemberRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.RemoveMember server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.RemoveMember(bgs.protocol.channel.v1.RemoveMemberRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        ChannelService* self = static_cast<ChannelService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.RemoveMember() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 2, token, response);
-        else
-          self->SendResponse(self->service_hash_, 2, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleRemoveMember(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 3: {
-      ::bgs::protocol::channel::v1::SendMessageRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.SendMessage server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.SendMessage(bgs.protocol.channel.v1.SendMessageRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        ChannelService* self = static_cast<ChannelService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.SendMessage() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 3, token, response);
-        else
-          self->SendResponse(self->service_hash_, 3, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleSendMessage(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 4: {
-      ::bgs::protocol::channel::v1::UpdateChannelStateRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.UpdateChannelState server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        ChannelService* self = static_cast<ChannelService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UpdateChannelState() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 4, token, response);
-        else
-          self->SendResponse(self->service_hash_, 4, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleUpdateChannelState(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 5: {
-      ::bgs::protocol::channel::v1::UpdateMemberStateRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.UpdateMemberState server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        ChannelService* self = static_cast<ChannelService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UpdateMemberState() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 5, token, response);
-        else
-          self->SendResponse(self->service_hash_, 5, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleUpdateMemberState(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    case 6: {
-      ::bgs::protocol::channel::v1::DissolveRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.Dissolve server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.Dissolve(bgs.protocol.channel.v1.DissolveRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        ChannelService* self = static_cast<ChannelService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.Dissolve() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 6, token, response);
-        else
-          self->SendResponse(self->service_hash_, 6, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleDissolve(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
-    default:
-      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
-      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
-      break;
-    }
-}
-
-uint32 ChannelService::HandleRemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.RemoveMember({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelService::HandleSendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.SendMessage({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelService::HandleUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.UpdateChannelState({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelService::HandleUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.UpdateMemberState({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelService::HandleDissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.Dissolve({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-// ===================================================================
-
-ChannelListener::ChannelListener(bool use_original_hash) : service_hash_(use_original_hash ? OriginalHash::value : NameHash::value) {
-}
-
-ChannelListener::~ChannelListener() {
-}
-
-google::protobuf::ServiceDescriptor const* ChannelListener::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ChannelListener_descriptor_;
-}
-
-void ChannelListener::OnJoin(::bgs::protocol::channel::v1::JoinNotification const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnJoin(bgs.protocol.channel.v1.JoinNotification{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 1, request);
-}
-
-void ChannelListener::OnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnMemberAdded(bgs.protocol.channel.v1.MemberAddedNotification{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 2, request);
-}
-
-void ChannelListener::OnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnLeave(bgs.protocol.channel.v1.LeaveNotification{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 3, request);
-}
-
-void ChannelListener::OnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnMemberRemoved(bgs.protocol.channel.v1.MemberRemovedNotification{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 4, request);
-}
-
-void ChannelListener::OnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnSendMessage(bgs.protocol.channel.v1.SendMessageNotification{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 5, request);
-}
-
-void ChannelListener::OnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnUpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateNotification{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 6, request);
-}
-
-void ChannelListener::OnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnUpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateNotification{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  SendRequest(service_hash_, 7, request);
-}
-
-void ChannelListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
-  switch(methodId) {
-    case 1: {
-      ::bgs::protocol::channel::v1::JoinNotification request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnJoin server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleOnJoin(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnJoin(bgs.protocol.channel.v1.JoinNotification{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 1, token, status);
-      break;
-    }
-    case 2: {
-      ::bgs::protocol::channel::v1::MemberAddedNotification request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnMemberAdded server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleOnMemberAdded(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnMemberAdded(bgs.protocol.channel.v1.MemberAddedNotification{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 2, token, status);
-      break;
-    }
-    case 3: {
-      ::bgs::protocol::channel::v1::LeaveNotification request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnLeave server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleOnLeave(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnLeave(bgs.protocol.channel.v1.LeaveNotification{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 3, token, status);
-      break;
-    }
-    case 4: {
-      ::bgs::protocol::channel::v1::MemberRemovedNotification request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnMemberRemoved server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleOnMemberRemoved(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnMemberRemoved(bgs.protocol.channel.v1.MemberRemovedNotification{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 4, token, status);
-      break;
-    }
-    case 5: {
-      ::bgs::protocol::channel::v1::SendMessageNotification request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnSendMessage server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleOnSendMessage(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnSendMessage(bgs.protocol.channel.v1.SendMessageNotification{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 5, token, status);
-      break;
-    }
-    case 6: {
-      ::bgs::protocol::channel::v1::UpdateChannelStateNotification request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnUpdateChannelState server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleOnUpdateChannelState(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnUpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateNotification{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 6, token, status);
-      break;
-    }
-    case 7: {
-      ::bgs::protocol::channel::v1::UpdateMemberStateNotification request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnUpdateMemberState server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      uint32 status = HandleOnUpdateMemberState(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnUpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateNotification{ %s }) status %u.",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
-      if (status)
-        SendResponse(service_hash_, 7, token, status);
-      break;
-    }
-    default:
-      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
-      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
-      break;
-    }
-}
-
-uint32 ChannelListener::HandleOnJoin(::bgs::protocol::channel::v1::JoinNotification const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnJoin({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelListener::HandleOnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnMemberAdded({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelListener::HandleOnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnLeave({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelListener::HandleOnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnMemberRemoved({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelListener::HandleOnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnSendMessage({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelListener::HandleOnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnUpdateChannelState({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 ChannelListener::HandleOnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnUpdateMemberState({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-
-// @@protoc_insertion_point(namespace_scope)
-
-}  // namespace v1
-}  // namespace channel
-}  // namespace protocol
-}  // namespace bgs
-
-// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/channel_service.pb.h b/src/server/proto/Client/channel_service.pb.h
deleted file mode 100644
index db49cd98a3a..00000000000
--- a/src/server/proto/Client/channel_service.pb.h
+++ /dev/null
@@ -1,3308 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: channel_service.proto
-
-#ifndef PROTOBUF_channel_5fservice_2eproto__INCLUDED
-#define PROTOBUF_channel_5fservice_2eproto__INCLUDED
-
-#include <string>
-
-#include <google/protobuf/stubs/common.h>
-
-#if GOOGLE_PROTOBUF_VERSION < 2006000
-#error This file was generated by a newer version of protoc which is
-#error incompatible with your Protocol Buffer headers.  Please update
-#error your headers.
-#endif
-#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
-#error This file was generated by an older version of protoc which is
-#error incompatible with your Protocol Buffer headers.  Please
-#error regenerate this file with a newer version of protoc.
-#endif
-
-#include <google/protobuf/generated_message_util.h>
-#include <google/protobuf/message.h>
-#include <google/protobuf/repeated_field.h>
-#include <google/protobuf/extension_set.h>
-#include <google/protobuf/unknown_field_set.h>
-#include "account_types.pb.h"
-#include "entity_types.pb.h"
-#include "channel_types.pb.h"
-#include "rpc_types.pb.h"
-#include "ServiceBase.h"
-#include "MessageBuffer.h"
-#include <functional>
-#include <type_traits>
-// @@protoc_insertion_point(includes)
-
-namespace bgs {
-namespace protocol {
-namespace channel {
-namespace v1 {
-
-// Internal implementation detail -- do not call these.
-void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-void protobuf_AssignDesc_channel_5fservice_2eproto();
-void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-class RemoveMemberRequest;
-class SendMessageRequest;
-class UpdateChannelStateRequest;
-class UpdateMemberStateRequest;
-class DissolveRequest;
-class JoinNotification;
-class MemberAddedNotification;
-class LeaveNotification;
-class MemberRemovedNotification;
-class SendMessageNotification;
-class UpdateChannelStateNotification;
-class UpdateMemberStateNotification;
-
-// ===================================================================
-
-class TC_PROTO_API RemoveMemberRequest : public ::google::protobuf::Message {
- public:
-  RemoveMemberRequest();
-  virtual ~RemoveMemberRequest();
-
-  RemoveMemberRequest(const RemoveMemberRequest& from);
-
-  inline RemoveMemberRequest& operator=(const RemoveMemberRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const RemoveMemberRequest& default_instance();
-
-  void Swap(RemoveMemberRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  RemoveMemberRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const RemoveMemberRequest& from);
-  void MergeFrom(const RemoveMemberRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // required .bgs.protocol.EntityId member_id = 2;
-  inline bool has_member_id() const;
-  inline void clear_member_id();
-  static const int kMemberIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& member_id() const;
-  inline ::bgs::protocol::EntityId* mutable_member_id();
-  inline ::bgs::protocol::EntityId* release_member_id();
-  inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id);
-
-  // optional uint32 reason = 3;
-  inline bool has_reason() const;
-  inline void clear_reason();
-  static const int kReasonFieldNumber = 3;
-  inline ::google::protobuf::uint32 reason() const;
-  inline void set_reason(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.RemoveMemberRequest)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_member_id();
-  inline void clear_has_member_id();
-  inline void set_has_reason();
-  inline void clear_has_reason();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::bgs::protocol::EntityId* member_id_;
-  ::google::protobuf::uint32 reason_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static RemoveMemberRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API SendMessageRequest : public ::google::protobuf::Message {
- public:
-  SendMessageRequest();
-  virtual ~SendMessageRequest();
-
-  SendMessageRequest(const SendMessageRequest& from);
-
-  inline SendMessageRequest& operator=(const SendMessageRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const SendMessageRequest& default_instance();
-
-  void Swap(SendMessageRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  SendMessageRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const SendMessageRequest& from);
-  void MergeFrom(const SendMessageRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // required .bgs.protocol.channel.v1.Message message = 2;
-  inline bool has_message() const;
-  inline void clear_message();
-  static const int kMessageFieldNumber = 2;
-  inline const ::bgs::protocol::channel::v1::Message& message() const;
-  inline ::bgs::protocol::channel::v1::Message* mutable_message();
-  inline ::bgs::protocol::channel::v1::Message* release_message();
-  inline void set_allocated_message(::bgs::protocol::channel::v1::Message* message);
-
-  // optional uint64 required_privileges = 3 [default = 0];
-  inline bool has_required_privileges() const;
-  inline void clear_required_privileges();
-  static const int kRequiredPrivilegesFieldNumber = 3;
-  inline ::google::protobuf::uint64 required_privileges() const;
-  inline void set_required_privileges(::google::protobuf::uint64 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.SendMessageRequest)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_message();
-  inline void clear_has_message();
-  inline void set_has_required_privileges();
-  inline void clear_has_required_privileges();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::bgs::protocol::channel::v1::Message* message_;
-  ::google::protobuf::uint64 required_privileges_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static SendMessageRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API UpdateChannelStateRequest : public ::google::protobuf::Message {
- public:
-  UpdateChannelStateRequest();
-  virtual ~UpdateChannelStateRequest();
-
-  UpdateChannelStateRequest(const UpdateChannelStateRequest& from);
-
-  inline UpdateChannelStateRequest& operator=(const UpdateChannelStateRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const UpdateChannelStateRequest& default_instance();
-
-  void Swap(UpdateChannelStateRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  UpdateChannelStateRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const UpdateChannelStateRequest& from);
-  void MergeFrom(const UpdateChannelStateRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-  inline bool has_state_change() const;
-  inline void clear_state_change();
-  static const int kStateChangeFieldNumber = 2;
-  inline const ::bgs::protocol::channel::v1::ChannelState& state_change() const;
-  inline ::bgs::protocol::channel::v1::ChannelState* mutable_state_change();
-  inline ::bgs::protocol::channel::v1::ChannelState* release_state_change();
-  inline void set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateChannelStateRequest)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_state_change();
-  inline void clear_has_state_change();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::bgs::protocol::channel::v1::ChannelState* state_change_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static UpdateChannelStateRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API UpdateMemberStateRequest : public ::google::protobuf::Message {
- public:
-  UpdateMemberStateRequest();
-  virtual ~UpdateMemberStateRequest();
-
-  UpdateMemberStateRequest(const UpdateMemberStateRequest& from);
-
-  inline UpdateMemberStateRequest& operator=(const UpdateMemberStateRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const UpdateMemberStateRequest& default_instance();
-
-  void Swap(UpdateMemberStateRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  UpdateMemberStateRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const UpdateMemberStateRequest& from);
-  void MergeFrom(const UpdateMemberStateRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-  inline int state_change_size() const;
-  inline void clear_state_change();
-  static const int kStateChangeFieldNumber = 2;
-  inline const ::bgs::protocol::channel::v1::Member& state_change(int index) const;
-  inline ::bgs::protocol::channel::v1::Member* mutable_state_change(int index);
-  inline ::bgs::protocol::channel::v1::Member* add_state_change();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
-      state_change() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
-      mutable_state_change();
-
-  // repeated uint32 removed_role = 3 [packed = true];
-  inline int removed_role_size() const;
-  inline void clear_removed_role();
-  static const int kRemovedRoleFieldNumber = 3;
-  inline ::google::protobuf::uint32 removed_role(int index) const;
-  inline void set_removed_role(int index, ::google::protobuf::uint32 value);
-  inline void add_removed_role(::google::protobuf::uint32 value);
-  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-      removed_role() const;
-  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-      mutable_removed_role();
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateMemberStateRequest)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > state_change_;
-  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > removed_role_;
-  mutable int _removed_role_cached_byte_size_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static UpdateMemberStateRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API DissolveRequest : public ::google::protobuf::Message {
- public:
-  DissolveRequest();
-  virtual ~DissolveRequest();
-
-  DissolveRequest(const DissolveRequest& from);
-
-  inline DissolveRequest& operator=(const DissolveRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const DissolveRequest& default_instance();
-
-  void Swap(DissolveRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  DissolveRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const DissolveRequest& from);
-  void MergeFrom(const DissolveRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // optional uint32 reason = 2;
-  inline bool has_reason() const;
-  inline void clear_reason();
-  static const int kReasonFieldNumber = 2;
-  inline ::google::protobuf::uint32 reason() const;
-  inline void set_reason(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.DissolveRequest)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_reason();
-  inline void clear_has_reason();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::google::protobuf::uint32 reason_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static DissolveRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API JoinNotification : public ::google::protobuf::Message {
- public:
-  JoinNotification();
-  virtual ~JoinNotification();
-
-  JoinNotification(const JoinNotification& from);
-
-  inline JoinNotification& operator=(const JoinNotification& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const JoinNotification& default_instance();
-
-  void Swap(JoinNotification* other);
-
-  // implements Message ----------------------------------------------
-
-  JoinNotification* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const JoinNotification& from);
-  void MergeFrom(const JoinNotification& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.channel.v1.Member self = 1;
-  inline bool has_self() const;
-  inline void clear_self();
-  static const int kSelfFieldNumber = 1;
-  inline const ::bgs::protocol::channel::v1::Member& self() const;
-  inline ::bgs::protocol::channel::v1::Member* mutable_self();
-  inline ::bgs::protocol::channel::v1::Member* release_self();
-  inline void set_allocated_self(::bgs::protocol::channel::v1::Member* self);
-
-  // repeated .bgs.protocol.channel.v1.Member member = 2;
-  inline int member_size() const;
-  inline void clear_member();
-  static const int kMemberFieldNumber = 2;
-  inline const ::bgs::protocol::channel::v1::Member& member(int index) const;
-  inline ::bgs::protocol::channel::v1::Member* mutable_member(int index);
-  inline ::bgs::protocol::channel::v1::Member* add_member();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
-      member() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
-      mutable_member();
-
-  // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
-  inline bool has_channel_state() const;
-  inline void clear_channel_state();
-  static const int kChannelStateFieldNumber = 3;
-  inline const ::bgs::protocol::channel::v1::ChannelState& channel_state() const;
-  inline ::bgs::protocol::channel::v1::ChannelState* mutable_channel_state();
-  inline ::bgs::protocol::channel::v1::ChannelState* release_channel_state();
-  inline void set_allocated_channel_state(::bgs::protocol::channel::v1::ChannelState* channel_state);
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  inline bool has_channel_id() const;
-  inline void clear_channel_id();
-  static const int kChannelIdFieldNumber = 4;
-  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
-  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
-  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
-  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  inline bool has_subscriber() const;
-  inline void clear_subscriber();
-  static const int kSubscriberFieldNumber = 5;
-  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
-  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
-  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
-  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.JoinNotification)
- private:
-  inline void set_has_self();
-  inline void clear_has_self();
-  inline void set_has_channel_state();
-  inline void clear_has_channel_state();
-  inline void set_has_channel_id();
-  inline void clear_has_channel_id();
-  inline void set_has_subscriber();
-  inline void clear_has_subscriber();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::channel::v1::Member* self_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > member_;
-  ::bgs::protocol::channel::v1::ChannelState* channel_state_;
-  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
-  ::bgs::protocol::account::v1::Identity* subscriber_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static JoinNotification* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API MemberAddedNotification : public ::google::protobuf::Message {
- public:
-  MemberAddedNotification();
-  virtual ~MemberAddedNotification();
-
-  MemberAddedNotification(const MemberAddedNotification& from);
-
-  inline MemberAddedNotification& operator=(const MemberAddedNotification& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const MemberAddedNotification& default_instance();
-
-  void Swap(MemberAddedNotification* other);
-
-  // implements Message ----------------------------------------------
-
-  MemberAddedNotification* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const MemberAddedNotification& from);
-  void MergeFrom(const MemberAddedNotification& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // required .bgs.protocol.channel.v1.Member member = 1;
-  inline bool has_member() const;
-  inline void clear_member();
-  static const int kMemberFieldNumber = 1;
-  inline const ::bgs::protocol::channel::v1::Member& member() const;
-  inline ::bgs::protocol::channel::v1::Member* mutable_member();
-  inline ::bgs::protocol::channel::v1::Member* release_member();
-  inline void set_allocated_member(::bgs::protocol::channel::v1::Member* member);
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
-  inline bool has_channel_id() const;
-  inline void clear_channel_id();
-  static const int kChannelIdFieldNumber = 2;
-  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
-  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
-  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
-  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 3;
-  inline bool has_subscriber() const;
-  inline void clear_subscriber();
-  static const int kSubscriberFieldNumber = 3;
-  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
-  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
-  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
-  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberAddedNotification)
- private:
-  inline void set_has_member();
-  inline void clear_has_member();
-  inline void set_has_channel_id();
-  inline void clear_has_channel_id();
-  inline void set_has_subscriber();
-  inline void clear_has_subscriber();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::channel::v1::Member* member_;
-  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
-  ::bgs::protocol::account::v1::Identity* subscriber_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static MemberAddedNotification* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API LeaveNotification : public ::google::protobuf::Message {
- public:
-  LeaveNotification();
-  virtual ~LeaveNotification();
-
-  LeaveNotification(const LeaveNotification& from);
-
-  inline LeaveNotification& operator=(const LeaveNotification& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const LeaveNotification& default_instance();
-
-  void Swap(LeaveNotification* other);
-
-  // implements Message ----------------------------------------------
-
-  LeaveNotification* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const LeaveNotification& from);
-  void MergeFrom(const LeaveNotification& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // required .bgs.protocol.EntityId member_id = 2 [deprecated = true];
-  inline bool has_member_id() const PROTOBUF_DEPRECATED;
-  inline void clear_member_id() PROTOBUF_DEPRECATED;
-  static const int kMemberIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& member_id() const PROTOBUF_DEPRECATED;
-  inline ::bgs::protocol::EntityId* mutable_member_id() PROTOBUF_DEPRECATED;
-  inline ::bgs::protocol::EntityId* release_member_id() PROTOBUF_DEPRECATED;
-  inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id) PROTOBUF_DEPRECATED;
-
-  // optional uint32 reason = 3;
-  inline bool has_reason() const;
-  inline void clear_reason();
-  static const int kReasonFieldNumber = 3;
-  inline ::google::protobuf::uint32 reason() const;
-  inline void set_reason(::google::protobuf::uint32 value);
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  inline bool has_channel_id() const;
-  inline void clear_channel_id();
-  static const int kChannelIdFieldNumber = 4;
-  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
-  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
-  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
-  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  inline bool has_subscriber() const;
-  inline void clear_subscriber();
-  static const int kSubscriberFieldNumber = 5;
-  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
-  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
-  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
-  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.LeaveNotification)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_member_id();
-  inline void clear_has_member_id();
-  inline void set_has_reason();
-  inline void clear_has_reason();
-  inline void set_has_channel_id();
-  inline void clear_has_channel_id();
-  inline void set_has_subscriber();
-  inline void clear_has_subscriber();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::bgs::protocol::EntityId* member_id_;
-  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
-  ::bgs::protocol::account::v1::Identity* subscriber_;
-  ::google::protobuf::uint32 reason_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static LeaveNotification* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API MemberRemovedNotification : public ::google::protobuf::Message {
- public:
-  MemberRemovedNotification();
-  virtual ~MemberRemovedNotification();
-
-  MemberRemovedNotification(const MemberRemovedNotification& from);
-
-  inline MemberRemovedNotification& operator=(const MemberRemovedNotification& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const MemberRemovedNotification& default_instance();
-
-  void Swap(MemberRemovedNotification* other);
-
-  // implements Message ----------------------------------------------
-
-  MemberRemovedNotification* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const MemberRemovedNotification& from);
-  void MergeFrom(const MemberRemovedNotification& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // required .bgs.protocol.EntityId member_id = 2;
-  inline bool has_member_id() const;
-  inline void clear_member_id();
-  static const int kMemberIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& member_id() const;
-  inline ::bgs::protocol::EntityId* mutable_member_id();
-  inline ::bgs::protocol::EntityId* release_member_id();
-  inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id);
-
-  // optional uint32 reason = 3;
-  inline bool has_reason() const;
-  inline void clear_reason();
-  static const int kReasonFieldNumber = 3;
-  inline ::google::protobuf::uint32 reason() const;
-  inline void set_reason(::google::protobuf::uint32 value);
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  inline bool has_channel_id() const;
-  inline void clear_channel_id();
-  static const int kChannelIdFieldNumber = 4;
-  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
-  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
-  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
-  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  inline bool has_subscriber() const;
-  inline void clear_subscriber();
-  static const int kSubscriberFieldNumber = 5;
-  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
-  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
-  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
-  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberRemovedNotification)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_member_id();
-  inline void clear_has_member_id();
-  inline void set_has_reason();
-  inline void clear_has_reason();
-  inline void set_has_channel_id();
-  inline void clear_has_channel_id();
-  inline void set_has_subscriber();
-  inline void clear_has_subscriber();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::bgs::protocol::EntityId* member_id_;
-  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
-  ::bgs::protocol::account::v1::Identity* subscriber_;
-  ::google::protobuf::uint32 reason_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static MemberRemovedNotification* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API SendMessageNotification : public ::google::protobuf::Message {
- public:
-  SendMessageNotification();
-  virtual ~SendMessageNotification();
-
-  SendMessageNotification(const SendMessageNotification& from);
-
-  inline SendMessageNotification& operator=(const SendMessageNotification& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const SendMessageNotification& default_instance();
-
-  void Swap(SendMessageNotification* other);
-
-  // implements Message ----------------------------------------------
-
-  SendMessageNotification* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const SendMessageNotification& from);
-  void MergeFrom(const SendMessageNotification& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // required .bgs.protocol.channel.v1.Message message = 2;
-  inline bool has_message() const;
-  inline void clear_message();
-  static const int kMessageFieldNumber = 2;
-  inline const ::bgs::protocol::channel::v1::Message& message() const;
-  inline ::bgs::protocol::channel::v1::Message* mutable_message();
-  inline ::bgs::protocol::channel::v1::Message* release_message();
-  inline void set_allocated_message(::bgs::protocol::channel::v1::Message* message);
-
-  // optional uint64 required_privileges = 3 [default = 0];
-  inline bool has_required_privileges() const;
-  inline void clear_required_privileges();
-  static const int kRequiredPrivilegesFieldNumber = 3;
-  inline ::google::protobuf::uint64 required_privileges() const;
-  inline void set_required_privileges(::google::protobuf::uint64 value);
-
-  // optional string battle_tag = 4;
-  inline bool has_battle_tag() const;
-  inline void clear_battle_tag();
-  static const int kBattleTagFieldNumber = 4;
-  inline const ::std::string& battle_tag() const;
-  inline void set_battle_tag(const ::std::string& value);
-  inline void set_battle_tag(const char* value);
-  inline void set_battle_tag(const char* value, size_t size);
-  inline ::std::string* mutable_battle_tag();
-  inline ::std::string* release_battle_tag();
-  inline void set_allocated_battle_tag(::std::string* battle_tag);
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
-  inline bool has_channel_id() const;
-  inline void clear_channel_id();
-  static const int kChannelIdFieldNumber = 5;
-  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
-  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
-  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
-  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 6;
-  inline bool has_subscriber() const;
-  inline void clear_subscriber();
-  static const int kSubscriberFieldNumber = 6;
-  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
-  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
-  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
-  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.SendMessageNotification)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_message();
-  inline void clear_has_message();
-  inline void set_has_required_privileges();
-  inline void clear_has_required_privileges();
-  inline void set_has_battle_tag();
-  inline void clear_has_battle_tag();
-  inline void set_has_channel_id();
-  inline void clear_has_channel_id();
-  inline void set_has_subscriber();
-  inline void clear_has_subscriber();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::bgs::protocol::channel::v1::Message* message_;
-  ::google::protobuf::uint64 required_privileges_;
-  ::std::string* battle_tag_;
-  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
-  ::bgs::protocol::account::v1::Identity* subscriber_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static SendMessageNotification* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API UpdateChannelStateNotification : public ::google::protobuf::Message {
- public:
-  UpdateChannelStateNotification();
-  virtual ~UpdateChannelStateNotification();
-
-  UpdateChannelStateNotification(const UpdateChannelStateNotification& from);
-
-  inline UpdateChannelStateNotification& operator=(const UpdateChannelStateNotification& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const UpdateChannelStateNotification& default_instance();
-
-  void Swap(UpdateChannelStateNotification* other);
-
-  // implements Message ----------------------------------------------
-
-  UpdateChannelStateNotification* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const UpdateChannelStateNotification& from);
-  void MergeFrom(const UpdateChannelStateNotification& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-  inline bool has_state_change() const;
-  inline void clear_state_change();
-  static const int kStateChangeFieldNumber = 2;
-  inline const ::bgs::protocol::channel::v1::ChannelState& state_change() const;
-  inline ::bgs::protocol::channel::v1::ChannelState* mutable_state_change();
-  inline ::bgs::protocol::channel::v1::ChannelState* release_state_change();
-  inline void set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change);
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
-  inline bool has_channel_id() const;
-  inline void clear_channel_id();
-  static const int kChannelIdFieldNumber = 3;
-  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
-  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
-  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
-  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 4;
-  inline bool has_subscriber() const;
-  inline void clear_subscriber();
-  static const int kSubscriberFieldNumber = 4;
-  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
-  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
-  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
-  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateChannelStateNotification)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_state_change();
-  inline void clear_has_state_change();
-  inline void set_has_channel_id();
-  inline void clear_has_channel_id();
-  inline void set_has_subscriber();
-  inline void clear_has_subscriber();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::bgs::protocol::channel::v1::ChannelState* state_change_;
-  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
-  ::bgs::protocol::account::v1::Identity* subscriber_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static UpdateChannelStateNotification* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API UpdateMemberStateNotification : public ::google::protobuf::Message {
- public:
-  UpdateMemberStateNotification();
-  virtual ~UpdateMemberStateNotification();
-
-  UpdateMemberStateNotification(const UpdateMemberStateNotification& from);
-
-  inline UpdateMemberStateNotification& operator=(const UpdateMemberStateNotification& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const UpdateMemberStateNotification& default_instance();
-
-  void Swap(UpdateMemberStateNotification* other);
-
-  // implements Message ----------------------------------------------
-
-  UpdateMemberStateNotification* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const UpdateMemberStateNotification& from);
-  void MergeFrom(const UpdateMemberStateNotification& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
-  inline int state_change_size() const;
-  inline void clear_state_change();
-  static const int kStateChangeFieldNumber = 2;
-  inline const ::bgs::protocol::channel::v1::Member& state_change(int index) const;
-  inline ::bgs::protocol::channel::v1::Member* mutable_state_change(int index);
-  inline ::bgs::protocol::channel::v1::Member* add_state_change();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
-      state_change() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
-      mutable_state_change();
-
-  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-  inline bool has_channel_id() const;
-  inline void clear_channel_id();
-  static const int kChannelIdFieldNumber = 4;
-  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
-  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
-  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
-  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
-
-  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
-  inline bool has_subscriber() const;
-  inline void clear_subscriber();
-  static const int kSubscriberFieldNumber = 5;
-  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
-  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
-  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
-  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateMemberStateNotification)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_channel_id();
-  inline void clear_has_channel_id();
-  inline void set_has_subscriber();
-  inline void clear_has_subscriber();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > state_change_;
-  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
-  ::bgs::protocol::account::v1::Identity* subscriber_;
-  friend void TC_PROTO_API protobuf_AddDesc_channel_5fservice_2eproto();
-  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static UpdateMemberStateNotification* default_instance_;
-};
-// ===================================================================
-
-class TC_PROTO_API ChannelService : public ServiceBase
-{
- public:
-
-  explicit ChannelService(bool use_original_hash);
-  virtual ~ChannelService();
-
-  typedef std::integral_constant<uint32, 0xB732DB32u> OriginalHash;
-  typedef std::integral_constant<uint32, 0xA913A87Bu> NameHash;
-
-  static google::protobuf::ServiceDescriptor const* descriptor();
-
-  // client methods --------------------------------------------------
-
-  void RemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void SendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void UpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void UpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void Dissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  // server methods --------------------------------------------------
-
-  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
-
- protected:
-  virtual uint32 HandleRemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleSendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleDissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-
- private:
-  uint32 service_hash_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChannelService);
-};
-
-// -------------------------------------------------------------------
-
-class TC_PROTO_API ChannelListener : public ServiceBase
-{
- public:
-
-  explicit ChannelListener(bool use_original_hash);
-  virtual ~ChannelListener();
-
-  typedef std::integral_constant<uint32, 0xBF8C8094u> OriginalHash;
-  typedef std::integral_constant<uint32, 0xDA660990u> NameHash;
-
-  static google::protobuf::ServiceDescriptor const* descriptor();
-
-  // client methods --------------------------------------------------
-
-  void OnJoin(::bgs::protocol::channel::v1::JoinNotification const* request);
-  void OnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request);
-  void OnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request);
-  void OnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request);
-  void OnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request);
-  void OnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request);
-  void OnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request);
-  // server methods --------------------------------------------------
-
-  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
-
- protected:
-  virtual uint32 HandleOnJoin(::bgs::protocol::channel::v1::JoinNotification const* request);
-  virtual uint32 HandleOnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request);
-  virtual uint32 HandleOnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request);
-  virtual uint32 HandleOnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request);
-  virtual uint32 HandleOnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request);
-  virtual uint32 HandleOnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request);
-  virtual uint32 HandleOnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request);
-
- private:
-  uint32 service_hash_;
-
-  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChannelListener);
-};
-
-// ===================================================================
-
-
-// ===================================================================
-
-// RemoveMemberRequest
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool RemoveMemberRequest::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void RemoveMemberRequest::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void RemoveMemberRequest::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void RemoveMemberRequest::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& RemoveMemberRequest::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.RemoveMemberRequest.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* RemoveMemberRequest::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.RemoveMemberRequest.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* RemoveMemberRequest::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void RemoveMemberRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.RemoveMemberRequest.agent_id)
-}
-
-// required .bgs.protocol.EntityId member_id = 2;
-inline bool RemoveMemberRequest::has_member_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void RemoveMemberRequest::set_has_member_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void RemoveMemberRequest::clear_has_member_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void RemoveMemberRequest::clear_member_id() {
-  if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_member_id();
-}
-inline const ::bgs::protocol::EntityId& RemoveMemberRequest::member_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.RemoveMemberRequest.member_id)
-  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
-}
-inline ::bgs::protocol::EntityId* RemoveMemberRequest::mutable_member_id() {
-  set_has_member_id();
-  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.RemoveMemberRequest.member_id)
-  return member_id_;
-}
-inline ::bgs::protocol::EntityId* RemoveMemberRequest::release_member_id() {
-  clear_has_member_id();
-  ::bgs::protocol::EntityId* temp = member_id_;
-  member_id_ = NULL;
-  return temp;
-}
-inline void RemoveMemberRequest::set_allocated_member_id(::bgs::protocol::EntityId* member_id) {
-  delete member_id_;
-  member_id_ = member_id;
-  if (member_id) {
-    set_has_member_id();
-  } else {
-    clear_has_member_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.RemoveMemberRequest.member_id)
-}
-
-// optional uint32 reason = 3;
-inline bool RemoveMemberRequest::has_reason() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void RemoveMemberRequest::set_has_reason() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void RemoveMemberRequest::clear_has_reason() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void RemoveMemberRequest::clear_reason() {
-  reason_ = 0u;
-  clear_has_reason();
-}
-inline ::google::protobuf::uint32 RemoveMemberRequest::reason() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.RemoveMemberRequest.reason)
-  return reason_;
-}
-inline void RemoveMemberRequest::set_reason(::google::protobuf::uint32 value) {
-  set_has_reason();
-  reason_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.RemoveMemberRequest.reason)
-}
-
-// -------------------------------------------------------------------
-
-// SendMessageRequest
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool SendMessageRequest::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void SendMessageRequest::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void SendMessageRequest::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void SendMessageRequest::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& SendMessageRequest::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageRequest.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* SendMessageRequest::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageRequest.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* SendMessageRequest::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void SendMessageRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageRequest.agent_id)
-}
-
-// required .bgs.protocol.channel.v1.Message message = 2;
-inline bool SendMessageRequest::has_message() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void SendMessageRequest::set_has_message() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void SendMessageRequest::clear_has_message() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void SendMessageRequest::clear_message() {
-  if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear();
-  clear_has_message();
-}
-inline const ::bgs::protocol::channel::v1::Message& SendMessageRequest::message() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageRequest.message)
-  return message_ != NULL ? *message_ : *default_instance_->message_;
-}
-inline ::bgs::protocol::channel::v1::Message* SendMessageRequest::mutable_message() {
-  set_has_message();
-  if (message_ == NULL) message_ = new ::bgs::protocol::channel::v1::Message;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageRequest.message)
-  return message_;
-}
-inline ::bgs::protocol::channel::v1::Message* SendMessageRequest::release_message() {
-  clear_has_message();
-  ::bgs::protocol::channel::v1::Message* temp = message_;
-  message_ = NULL;
-  return temp;
-}
-inline void SendMessageRequest::set_allocated_message(::bgs::protocol::channel::v1::Message* message) {
-  delete message_;
-  message_ = message;
-  if (message) {
-    set_has_message();
-  } else {
-    clear_has_message();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageRequest.message)
-}
-
-// optional uint64 required_privileges = 3 [default = 0];
-inline bool SendMessageRequest::has_required_privileges() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void SendMessageRequest::set_has_required_privileges() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void SendMessageRequest::clear_has_required_privileges() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void SendMessageRequest::clear_required_privileges() {
-  required_privileges_ = GOOGLE_ULONGLONG(0);
-  clear_has_required_privileges();
-}
-inline ::google::protobuf::uint64 SendMessageRequest::required_privileges() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageRequest.required_privileges)
-  return required_privileges_;
-}
-inline void SendMessageRequest::set_required_privileges(::google::protobuf::uint64 value) {
-  set_has_required_privileges();
-  required_privileges_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SendMessageRequest.required_privileges)
-}
-
-// -------------------------------------------------------------------
-
-// UpdateChannelStateRequest
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool UpdateChannelStateRequest::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void UpdateChannelStateRequest::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void UpdateChannelStateRequest::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void UpdateChannelStateRequest::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& UpdateChannelStateRequest::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateRequest.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateChannelStateRequest::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateRequest.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateChannelStateRequest::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void UpdateChannelStateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateRequest.agent_id)
-}
-
-// required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-inline bool UpdateChannelStateRequest::has_state_change() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void UpdateChannelStateRequest::set_has_state_change() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void UpdateChannelStateRequest::clear_has_state_change() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void UpdateChannelStateRequest::clear_state_change() {
-  if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear();
-  clear_has_state_change();
-}
-inline const ::bgs::protocol::channel::v1::ChannelState& UpdateChannelStateRequest::state_change() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateRequest.state_change)
-  return state_change_ != NULL ? *state_change_ : *default_instance_->state_change_;
-}
-inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateRequest::mutable_state_change() {
-  set_has_state_change();
-  if (state_change_ == NULL) state_change_ = new ::bgs::protocol::channel::v1::ChannelState;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateRequest.state_change)
-  return state_change_;
-}
-inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateRequest::release_state_change() {
-  clear_has_state_change();
-  ::bgs::protocol::channel::v1::ChannelState* temp = state_change_;
-  state_change_ = NULL;
-  return temp;
-}
-inline void UpdateChannelStateRequest::set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change) {
-  delete state_change_;
-  state_change_ = state_change;
-  if (state_change) {
-    set_has_state_change();
-  } else {
-    clear_has_state_change();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateRequest.state_change)
-}
-
-// -------------------------------------------------------------------
-
-// UpdateMemberStateRequest
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool UpdateMemberStateRequest::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void UpdateMemberStateRequest::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void UpdateMemberStateRequest::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void UpdateMemberStateRequest::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& UpdateMemberStateRequest::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateRequest.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateMemberStateRequest::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateRequest.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateMemberStateRequest::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void UpdateMemberStateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateRequest.agent_id)
-}
-
-// repeated .bgs.protocol.channel.v1.Member state_change = 2;
-inline int UpdateMemberStateRequest::state_change_size() const {
-  return state_change_.size();
-}
-inline void UpdateMemberStateRequest::clear_state_change() {
-  state_change_.Clear();
-}
-inline const ::bgs::protocol::channel::v1::Member& UpdateMemberStateRequest::state_change(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
-  return state_change_.Get(index);
-}
-inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateRequest::mutable_state_change(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
-  return state_change_.Mutable(index);
-}
-inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateRequest::add_state_change() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
-  return state_change_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
-UpdateMemberStateRequest::state_change() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
-  return state_change_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
-UpdateMemberStateRequest::mutable_state_change() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
-  return &state_change_;
-}
-
-// repeated uint32 removed_role = 3 [packed = true];
-inline int UpdateMemberStateRequest::removed_role_size() const {
-  return removed_role_.size();
-}
-inline void UpdateMemberStateRequest::clear_removed_role() {
-  removed_role_.Clear();
-}
-inline ::google::protobuf::uint32 UpdateMemberStateRequest::removed_role(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
-  return removed_role_.Get(index);
-}
-inline void UpdateMemberStateRequest::set_removed_role(int index, ::google::protobuf::uint32 value) {
-  removed_role_.Set(index, value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
-}
-inline void UpdateMemberStateRequest::add_removed_role(::google::protobuf::uint32 value) {
-  removed_role_.Add(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
-}
-inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-UpdateMemberStateRequest::removed_role() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
-  return removed_role_;
-}
-inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-UpdateMemberStateRequest::mutable_removed_role() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
-  return &removed_role_;
-}
-
-// -------------------------------------------------------------------
-
-// DissolveRequest
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool DissolveRequest::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void DissolveRequest::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void DissolveRequest::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void DissolveRequest::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& DissolveRequest::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.DissolveRequest.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* DissolveRequest::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.DissolveRequest.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* DissolveRequest::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void DissolveRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.DissolveRequest.agent_id)
-}
-
-// optional uint32 reason = 2;
-inline bool DissolveRequest::has_reason() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void DissolveRequest::set_has_reason() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void DissolveRequest::clear_has_reason() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void DissolveRequest::clear_reason() {
-  reason_ = 0u;
-  clear_has_reason();
-}
-inline ::google::protobuf::uint32 DissolveRequest::reason() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.DissolveRequest.reason)
-  return reason_;
-}
-inline void DissolveRequest::set_reason(::google::protobuf::uint32 value) {
-  set_has_reason();
-  reason_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.DissolveRequest.reason)
-}
-
-// -------------------------------------------------------------------
-
-// JoinNotification
-
-// optional .bgs.protocol.channel.v1.Member self = 1;
-inline bool JoinNotification::has_self() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void JoinNotification::set_has_self() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void JoinNotification::clear_has_self() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void JoinNotification::clear_self() {
-  if (self_ != NULL) self_->::bgs::protocol::channel::v1::Member::Clear();
-  clear_has_self();
-}
-inline const ::bgs::protocol::channel::v1::Member& JoinNotification::self() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.self)
-  return self_ != NULL ? *self_ : *default_instance_->self_;
-}
-inline ::bgs::protocol::channel::v1::Member* JoinNotification::mutable_self() {
-  set_has_self();
-  if (self_ == NULL) self_ = new ::bgs::protocol::channel::v1::Member;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.self)
-  return self_;
-}
-inline ::bgs::protocol::channel::v1::Member* JoinNotification::release_self() {
-  clear_has_self();
-  ::bgs::protocol::channel::v1::Member* temp = self_;
-  self_ = NULL;
-  return temp;
-}
-inline void JoinNotification::set_allocated_self(::bgs::protocol::channel::v1::Member* self) {
-  delete self_;
-  self_ = self;
-  if (self) {
-    set_has_self();
-  } else {
-    clear_has_self();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.self)
-}
-
-// repeated .bgs.protocol.channel.v1.Member member = 2;
-inline int JoinNotification::member_size() const {
-  return member_.size();
-}
-inline void JoinNotification::clear_member() {
-  member_.Clear();
-}
-inline const ::bgs::protocol::channel::v1::Member& JoinNotification::member(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.member)
-  return member_.Get(index);
-}
-inline ::bgs::protocol::channel::v1::Member* JoinNotification::mutable_member(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.member)
-  return member_.Mutable(index);
-}
-inline ::bgs::protocol::channel::v1::Member* JoinNotification::add_member() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.JoinNotification.member)
-  return member_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
-JoinNotification::member() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.JoinNotification.member)
-  return member_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
-JoinNotification::mutable_member() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.JoinNotification.member)
-  return &member_;
-}
-
-// required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
-inline bool JoinNotification::has_channel_state() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void JoinNotification::set_has_channel_state() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void JoinNotification::clear_has_channel_state() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void JoinNotification::clear_channel_state() {
-  if (channel_state_ != NULL) channel_state_->::bgs::protocol::channel::v1::ChannelState::Clear();
-  clear_has_channel_state();
-}
-inline const ::bgs::protocol::channel::v1::ChannelState& JoinNotification::channel_state() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.channel_state)
-  return channel_state_ != NULL ? *channel_state_ : *default_instance_->channel_state_;
-}
-inline ::bgs::protocol::channel::v1::ChannelState* JoinNotification::mutable_channel_state() {
-  set_has_channel_state();
-  if (channel_state_ == NULL) channel_state_ = new ::bgs::protocol::channel::v1::ChannelState;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.channel_state)
-  return channel_state_;
-}
-inline ::bgs::protocol::channel::v1::ChannelState* JoinNotification::release_channel_state() {
-  clear_has_channel_state();
-  ::bgs::protocol::channel::v1::ChannelState* temp = channel_state_;
-  channel_state_ = NULL;
-  return temp;
-}
-inline void JoinNotification::set_allocated_channel_state(::bgs::protocol::channel::v1::ChannelState* channel_state) {
-  delete channel_state_;
-  channel_state_ = channel_state;
-  if (channel_state) {
-    set_has_channel_state();
-  } else {
-    clear_has_channel_state();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.channel_state)
-}
-
-// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-inline bool JoinNotification::has_channel_id() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void JoinNotification::set_has_channel_id() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void JoinNotification::clear_has_channel_id() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void JoinNotification::clear_channel_id() {
-  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-  clear_has_channel_id();
-}
-inline const ::bgs::protocol::channel::v1::ChannelId& JoinNotification::channel_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.channel_id)
-  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* JoinNotification::mutable_channel_id() {
-  set_has_channel_id();
-  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.channel_id)
-  return channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* JoinNotification::release_channel_id() {
-  clear_has_channel_id();
-  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
-  channel_id_ = NULL;
-  return temp;
-}
-inline void JoinNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
-  delete channel_id_;
-  channel_id_ = channel_id;
-  if (channel_id) {
-    set_has_channel_id();
-  } else {
-    clear_has_channel_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.channel_id)
-}
-
-// optional .bgs.protocol.account.v1.Identity subscriber = 5;
-inline bool JoinNotification::has_subscriber() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void JoinNotification::set_has_subscriber() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void JoinNotification::clear_has_subscriber() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void JoinNotification::clear_subscriber() {
-  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-  clear_has_subscriber();
-}
-inline const ::bgs::protocol::account::v1::Identity& JoinNotification::subscriber() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.subscriber)
-  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* JoinNotification::mutable_subscriber() {
-  set_has_subscriber();
-  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.subscriber)
-  return subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* JoinNotification::release_subscriber() {
-  clear_has_subscriber();
-  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
-  subscriber_ = NULL;
-  return temp;
-}
-inline void JoinNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
-  delete subscriber_;
-  subscriber_ = subscriber;
-  if (subscriber) {
-    set_has_subscriber();
-  } else {
-    clear_has_subscriber();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.subscriber)
-}
-
-// -------------------------------------------------------------------
-
-// MemberAddedNotification
-
-// required .bgs.protocol.channel.v1.Member member = 1;
-inline bool MemberAddedNotification::has_member() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void MemberAddedNotification::set_has_member() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void MemberAddedNotification::clear_has_member() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void MemberAddedNotification::clear_member() {
-  if (member_ != NULL) member_->::bgs::protocol::channel::v1::Member::Clear();
-  clear_has_member();
-}
-inline const ::bgs::protocol::channel::v1::Member& MemberAddedNotification::member() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAddedNotification.member)
-  return member_ != NULL ? *member_ : *default_instance_->member_;
-}
-inline ::bgs::protocol::channel::v1::Member* MemberAddedNotification::mutable_member() {
-  set_has_member();
-  if (member_ == NULL) member_ = new ::bgs::protocol::channel::v1::Member;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberAddedNotification.member)
-  return member_;
-}
-inline ::bgs::protocol::channel::v1::Member* MemberAddedNotification::release_member() {
-  clear_has_member();
-  ::bgs::protocol::channel::v1::Member* temp = member_;
-  member_ = NULL;
-  return temp;
-}
-inline void MemberAddedNotification::set_allocated_member(::bgs::protocol::channel::v1::Member* member) {
-  delete member_;
-  member_ = member;
-  if (member) {
-    set_has_member();
-  } else {
-    clear_has_member();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberAddedNotification.member)
-}
-
-// optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
-inline bool MemberAddedNotification::has_channel_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void MemberAddedNotification::set_has_channel_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void MemberAddedNotification::clear_has_channel_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void MemberAddedNotification::clear_channel_id() {
-  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-  clear_has_channel_id();
-}
-inline const ::bgs::protocol::channel::v1::ChannelId& MemberAddedNotification::channel_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAddedNotification.channel_id)
-  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* MemberAddedNotification::mutable_channel_id() {
-  set_has_channel_id();
-  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberAddedNotification.channel_id)
-  return channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* MemberAddedNotification::release_channel_id() {
-  clear_has_channel_id();
-  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
-  channel_id_ = NULL;
-  return temp;
-}
-inline void MemberAddedNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
-  delete channel_id_;
-  channel_id_ = channel_id;
-  if (channel_id) {
-    set_has_channel_id();
-  } else {
-    clear_has_channel_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberAddedNotification.channel_id)
-}
-
-// optional .bgs.protocol.account.v1.Identity subscriber = 3;
-inline bool MemberAddedNotification::has_subscriber() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void MemberAddedNotification::set_has_subscriber() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void MemberAddedNotification::clear_has_subscriber() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void MemberAddedNotification::clear_subscriber() {
-  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-  clear_has_subscriber();
-}
-inline const ::bgs::protocol::account::v1::Identity& MemberAddedNotification::subscriber() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAddedNotification.subscriber)
-  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* MemberAddedNotification::mutable_subscriber() {
-  set_has_subscriber();
-  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberAddedNotification.subscriber)
-  return subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* MemberAddedNotification::release_subscriber() {
-  clear_has_subscriber();
-  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
-  subscriber_ = NULL;
-  return temp;
-}
-inline void MemberAddedNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
-  delete subscriber_;
-  subscriber_ = subscriber;
-  if (subscriber) {
-    set_has_subscriber();
-  } else {
-    clear_has_subscriber();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberAddedNotification.subscriber)
-}
-
-// -------------------------------------------------------------------
-
-// LeaveNotification
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool LeaveNotification::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void LeaveNotification::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void LeaveNotification::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void LeaveNotification::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& LeaveNotification::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* LeaveNotification::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* LeaveNotification::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void LeaveNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.agent_id)
-}
-
-// required .bgs.protocol.EntityId member_id = 2 [deprecated = true];
-inline bool LeaveNotification::has_member_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void LeaveNotification::set_has_member_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void LeaveNotification::clear_has_member_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void LeaveNotification::clear_member_id() {
-  if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_member_id();
-}
-inline const ::bgs::protocol::EntityId& LeaveNotification::member_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.member_id)
-  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
-}
-inline ::bgs::protocol::EntityId* LeaveNotification::mutable_member_id() {
-  set_has_member_id();
-  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.member_id)
-  return member_id_;
-}
-inline ::bgs::protocol::EntityId* LeaveNotification::release_member_id() {
-  clear_has_member_id();
-  ::bgs::protocol::EntityId* temp = member_id_;
-  member_id_ = NULL;
-  return temp;
-}
-inline void LeaveNotification::set_allocated_member_id(::bgs::protocol::EntityId* member_id) {
-  delete member_id_;
-  member_id_ = member_id;
-  if (member_id) {
-    set_has_member_id();
-  } else {
-    clear_has_member_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.member_id)
-}
-
-// optional uint32 reason = 3;
-inline bool LeaveNotification::has_reason() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void LeaveNotification::set_has_reason() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void LeaveNotification::clear_has_reason() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void LeaveNotification::clear_reason() {
-  reason_ = 0u;
-  clear_has_reason();
-}
-inline ::google::protobuf::uint32 LeaveNotification::reason() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.reason)
-  return reason_;
-}
-inline void LeaveNotification::set_reason(::google::protobuf::uint32 value) {
-  set_has_reason();
-  reason_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.LeaveNotification.reason)
-}
-
-// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-inline bool LeaveNotification::has_channel_id() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void LeaveNotification::set_has_channel_id() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void LeaveNotification::clear_has_channel_id() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void LeaveNotification::clear_channel_id() {
-  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-  clear_has_channel_id();
-}
-inline const ::bgs::protocol::channel::v1::ChannelId& LeaveNotification::channel_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.channel_id)
-  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* LeaveNotification::mutable_channel_id() {
-  set_has_channel_id();
-  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.channel_id)
-  return channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* LeaveNotification::release_channel_id() {
-  clear_has_channel_id();
-  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
-  channel_id_ = NULL;
-  return temp;
-}
-inline void LeaveNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
-  delete channel_id_;
-  channel_id_ = channel_id;
-  if (channel_id) {
-    set_has_channel_id();
-  } else {
-    clear_has_channel_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.channel_id)
-}
-
-// optional .bgs.protocol.account.v1.Identity subscriber = 5;
-inline bool LeaveNotification::has_subscriber() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void LeaveNotification::set_has_subscriber() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void LeaveNotification::clear_has_subscriber() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void LeaveNotification::clear_subscriber() {
-  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-  clear_has_subscriber();
-}
-inline const ::bgs::protocol::account::v1::Identity& LeaveNotification::subscriber() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.subscriber)
-  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* LeaveNotification::mutable_subscriber() {
-  set_has_subscriber();
-  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.subscriber)
-  return subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* LeaveNotification::release_subscriber() {
-  clear_has_subscriber();
-  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
-  subscriber_ = NULL;
-  return temp;
-}
-inline void LeaveNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
-  delete subscriber_;
-  subscriber_ = subscriber;
-  if (subscriber) {
-    set_has_subscriber();
-  } else {
-    clear_has_subscriber();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.subscriber)
-}
-
-// -------------------------------------------------------------------
-
-// MemberRemovedNotification
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool MemberRemovedNotification::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void MemberRemovedNotification::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void MemberRemovedNotification::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void MemberRemovedNotification::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& MemberRemovedNotification::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* MemberRemovedNotification::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* MemberRemovedNotification::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void MemberRemovedNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.agent_id)
-}
-
-// required .bgs.protocol.EntityId member_id = 2;
-inline bool MemberRemovedNotification::has_member_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void MemberRemovedNotification::set_has_member_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void MemberRemovedNotification::clear_has_member_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void MemberRemovedNotification::clear_member_id() {
-  if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_member_id();
-}
-inline const ::bgs::protocol::EntityId& MemberRemovedNotification::member_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.member_id)
-  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
-}
-inline ::bgs::protocol::EntityId* MemberRemovedNotification::mutable_member_id() {
-  set_has_member_id();
-  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.member_id)
-  return member_id_;
-}
-inline ::bgs::protocol::EntityId* MemberRemovedNotification::release_member_id() {
-  clear_has_member_id();
-  ::bgs::protocol::EntityId* temp = member_id_;
-  member_id_ = NULL;
-  return temp;
-}
-inline void MemberRemovedNotification::set_allocated_member_id(::bgs::protocol::EntityId* member_id) {
-  delete member_id_;
-  member_id_ = member_id;
-  if (member_id) {
-    set_has_member_id();
-  } else {
-    clear_has_member_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.member_id)
-}
-
-// optional uint32 reason = 3;
-inline bool MemberRemovedNotification::has_reason() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void MemberRemovedNotification::set_has_reason() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void MemberRemovedNotification::clear_has_reason() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void MemberRemovedNotification::clear_reason() {
-  reason_ = 0u;
-  clear_has_reason();
-}
-inline ::google::protobuf::uint32 MemberRemovedNotification::reason() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.reason)
-  return reason_;
-}
-inline void MemberRemovedNotification::set_reason(::google::protobuf::uint32 value) {
-  set_has_reason();
-  reason_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberRemovedNotification.reason)
-}
-
-// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-inline bool MemberRemovedNotification::has_channel_id() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void MemberRemovedNotification::set_has_channel_id() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void MemberRemovedNotification::clear_has_channel_id() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void MemberRemovedNotification::clear_channel_id() {
-  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-  clear_has_channel_id();
-}
-inline const ::bgs::protocol::channel::v1::ChannelId& MemberRemovedNotification::channel_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.channel_id)
-  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* MemberRemovedNotification::mutable_channel_id() {
-  set_has_channel_id();
-  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.channel_id)
-  return channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* MemberRemovedNotification::release_channel_id() {
-  clear_has_channel_id();
-  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
-  channel_id_ = NULL;
-  return temp;
-}
-inline void MemberRemovedNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
-  delete channel_id_;
-  channel_id_ = channel_id;
-  if (channel_id) {
-    set_has_channel_id();
-  } else {
-    clear_has_channel_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.channel_id)
-}
-
-// optional .bgs.protocol.account.v1.Identity subscriber = 5;
-inline bool MemberRemovedNotification::has_subscriber() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void MemberRemovedNotification::set_has_subscriber() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void MemberRemovedNotification::clear_has_subscriber() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void MemberRemovedNotification::clear_subscriber() {
-  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-  clear_has_subscriber();
-}
-inline const ::bgs::protocol::account::v1::Identity& MemberRemovedNotification::subscriber() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.subscriber)
-  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* MemberRemovedNotification::mutable_subscriber() {
-  set_has_subscriber();
-  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.subscriber)
-  return subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* MemberRemovedNotification::release_subscriber() {
-  clear_has_subscriber();
-  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
-  subscriber_ = NULL;
-  return temp;
-}
-inline void MemberRemovedNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
-  delete subscriber_;
-  subscriber_ = subscriber;
-  if (subscriber) {
-    set_has_subscriber();
-  } else {
-    clear_has_subscriber();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.subscriber)
-}
-
-// -------------------------------------------------------------------
-
-// SendMessageNotification
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool SendMessageNotification::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void SendMessageNotification::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void SendMessageNotification::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void SendMessageNotification::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& SendMessageNotification::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* SendMessageNotification::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* SendMessageNotification::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void SendMessageNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.agent_id)
-}
-
-// required .bgs.protocol.channel.v1.Message message = 2;
-inline bool SendMessageNotification::has_message() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void SendMessageNotification::set_has_message() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void SendMessageNotification::clear_has_message() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void SendMessageNotification::clear_message() {
-  if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear();
-  clear_has_message();
-}
-inline const ::bgs::protocol::channel::v1::Message& SendMessageNotification::message() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.message)
-  return message_ != NULL ? *message_ : *default_instance_->message_;
-}
-inline ::bgs::protocol::channel::v1::Message* SendMessageNotification::mutable_message() {
-  set_has_message();
-  if (message_ == NULL) message_ = new ::bgs::protocol::channel::v1::Message;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.message)
-  return message_;
-}
-inline ::bgs::protocol::channel::v1::Message* SendMessageNotification::release_message() {
-  clear_has_message();
-  ::bgs::protocol::channel::v1::Message* temp = message_;
-  message_ = NULL;
-  return temp;
-}
-inline void SendMessageNotification::set_allocated_message(::bgs::protocol::channel::v1::Message* message) {
-  delete message_;
-  message_ = message;
-  if (message) {
-    set_has_message();
-  } else {
-    clear_has_message();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.message)
-}
-
-// optional uint64 required_privileges = 3 [default = 0];
-inline bool SendMessageNotification::has_required_privileges() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void SendMessageNotification::set_has_required_privileges() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void SendMessageNotification::clear_has_required_privileges() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void SendMessageNotification::clear_required_privileges() {
-  required_privileges_ = GOOGLE_ULONGLONG(0);
-  clear_has_required_privileges();
-}
-inline ::google::protobuf::uint64 SendMessageNotification::required_privileges() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.required_privileges)
-  return required_privileges_;
-}
-inline void SendMessageNotification::set_required_privileges(::google::protobuf::uint64 value) {
-  set_has_required_privileges();
-  required_privileges_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SendMessageNotification.required_privileges)
-}
-
-// optional string battle_tag = 4;
-inline bool SendMessageNotification::has_battle_tag() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void SendMessageNotification::set_has_battle_tag() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void SendMessageNotification::clear_has_battle_tag() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void SendMessageNotification::clear_battle_tag() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_->clear();
-  }
-  clear_has_battle_tag();
-}
-inline const ::std::string& SendMessageNotification::battle_tag() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.battle_tag)
-  return *battle_tag_;
-}
-inline void SendMessageNotification::set_battle_tag(const ::std::string& value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SendMessageNotification.battle_tag)
-}
-inline void SendMessageNotification::set_battle_tag(const char* value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.SendMessageNotification.battle_tag)
-}
-inline void SendMessageNotification::set_battle_tag(const char* value, size_t size) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.SendMessageNotification.battle_tag)
-}
-inline ::std::string* SendMessageNotification::mutable_battle_tag() {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.battle_tag)
-  return battle_tag_;
-}
-inline ::std::string* SendMessageNotification::release_battle_tag() {
-  clear_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = battle_tag_;
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void SendMessageNotification::set_allocated_battle_tag(::std::string* battle_tag) {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (battle_tag) {
-    set_has_battle_tag();
-    battle_tag_ = battle_tag;
-  } else {
-    clear_has_battle_tag();
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.battle_tag)
-}
-
-// optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
-inline bool SendMessageNotification::has_channel_id() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void SendMessageNotification::set_has_channel_id() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void SendMessageNotification::clear_has_channel_id() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void SendMessageNotification::clear_channel_id() {
-  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-  clear_has_channel_id();
-}
-inline const ::bgs::protocol::channel::v1::ChannelId& SendMessageNotification::channel_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.channel_id)
-  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* SendMessageNotification::mutable_channel_id() {
-  set_has_channel_id();
-  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.channel_id)
-  return channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* SendMessageNotification::release_channel_id() {
-  clear_has_channel_id();
-  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
-  channel_id_ = NULL;
-  return temp;
-}
-inline void SendMessageNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
-  delete channel_id_;
-  channel_id_ = channel_id;
-  if (channel_id) {
-    set_has_channel_id();
-  } else {
-    clear_has_channel_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.channel_id)
-}
-
-// optional .bgs.protocol.account.v1.Identity subscriber = 6;
-inline bool SendMessageNotification::has_subscriber() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
-}
-inline void SendMessageNotification::set_has_subscriber() {
-  _has_bits_[0] |= 0x00000020u;
-}
-inline void SendMessageNotification::clear_has_subscriber() {
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline void SendMessageNotification::clear_subscriber() {
-  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-  clear_has_subscriber();
-}
-inline const ::bgs::protocol::account::v1::Identity& SendMessageNotification::subscriber() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.subscriber)
-  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* SendMessageNotification::mutable_subscriber() {
-  set_has_subscriber();
-  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.subscriber)
-  return subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* SendMessageNotification::release_subscriber() {
-  clear_has_subscriber();
-  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
-  subscriber_ = NULL;
-  return temp;
-}
-inline void SendMessageNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
-  delete subscriber_;
-  subscriber_ = subscriber;
-  if (subscriber) {
-    set_has_subscriber();
-  } else {
-    clear_has_subscriber();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.subscriber)
-}
-
-// -------------------------------------------------------------------
-
-// UpdateChannelStateNotification
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool UpdateChannelStateNotification::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void UpdateChannelStateNotification::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void UpdateChannelStateNotification::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void UpdateChannelStateNotification::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& UpdateChannelStateNotification::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateChannelStateNotification::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateChannelStateNotification::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void UpdateChannelStateNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.agent_id)
-}
-
-// required .bgs.protocol.channel.v1.ChannelState state_change = 2;
-inline bool UpdateChannelStateNotification::has_state_change() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void UpdateChannelStateNotification::set_has_state_change() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void UpdateChannelStateNotification::clear_has_state_change() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void UpdateChannelStateNotification::clear_state_change() {
-  if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear();
-  clear_has_state_change();
-}
-inline const ::bgs::protocol::channel::v1::ChannelState& UpdateChannelStateNotification::state_change() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.state_change)
-  return state_change_ != NULL ? *state_change_ : *default_instance_->state_change_;
-}
-inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateNotification::mutable_state_change() {
-  set_has_state_change();
-  if (state_change_ == NULL) state_change_ = new ::bgs::protocol::channel::v1::ChannelState;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.state_change)
-  return state_change_;
-}
-inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateNotification::release_state_change() {
-  clear_has_state_change();
-  ::bgs::protocol::channel::v1::ChannelState* temp = state_change_;
-  state_change_ = NULL;
-  return temp;
-}
-inline void UpdateChannelStateNotification::set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change) {
-  delete state_change_;
-  state_change_ = state_change;
-  if (state_change) {
-    set_has_state_change();
-  } else {
-    clear_has_state_change();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.state_change)
-}
-
-// optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
-inline bool UpdateChannelStateNotification::has_channel_id() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void UpdateChannelStateNotification::set_has_channel_id() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void UpdateChannelStateNotification::clear_has_channel_id() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void UpdateChannelStateNotification::clear_channel_id() {
-  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-  clear_has_channel_id();
-}
-inline const ::bgs::protocol::channel::v1::ChannelId& UpdateChannelStateNotification::channel_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.channel_id)
-  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* UpdateChannelStateNotification::mutable_channel_id() {
-  set_has_channel_id();
-  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.channel_id)
-  return channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* UpdateChannelStateNotification::release_channel_id() {
-  clear_has_channel_id();
-  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
-  channel_id_ = NULL;
-  return temp;
-}
-inline void UpdateChannelStateNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
-  delete channel_id_;
-  channel_id_ = channel_id;
-  if (channel_id) {
-    set_has_channel_id();
-  } else {
-    clear_has_channel_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.channel_id)
-}
-
-// optional .bgs.protocol.account.v1.Identity subscriber = 4;
-inline bool UpdateChannelStateNotification::has_subscriber() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void UpdateChannelStateNotification::set_has_subscriber() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void UpdateChannelStateNotification::clear_has_subscriber() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void UpdateChannelStateNotification::clear_subscriber() {
-  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-  clear_has_subscriber();
-}
-inline const ::bgs::protocol::account::v1::Identity& UpdateChannelStateNotification::subscriber() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.subscriber)
-  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* UpdateChannelStateNotification::mutable_subscriber() {
-  set_has_subscriber();
-  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.subscriber)
-  return subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* UpdateChannelStateNotification::release_subscriber() {
-  clear_has_subscriber();
-  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
-  subscriber_ = NULL;
-  return temp;
-}
-inline void UpdateChannelStateNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
-  delete subscriber_;
-  subscriber_ = subscriber;
-  if (subscriber) {
-    set_has_subscriber();
-  } else {
-    clear_has_subscriber();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.subscriber)
-}
-
-// -------------------------------------------------------------------
-
-// UpdateMemberStateNotification
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool UpdateMemberStateNotification::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void UpdateMemberStateNotification::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void UpdateMemberStateNotification::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void UpdateMemberStateNotification::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& UpdateMemberStateNotification::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateMemberStateNotification::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateMemberStateNotification::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void UpdateMemberStateNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateNotification.agent_id)
-}
-
-// repeated .bgs.protocol.channel.v1.Member state_change = 2;
-inline int UpdateMemberStateNotification::state_change_size() const {
-  return state_change_.size();
-}
-inline void UpdateMemberStateNotification::clear_state_change() {
-  state_change_.Clear();
-}
-inline const ::bgs::protocol::channel::v1::Member& UpdateMemberStateNotification::state_change(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
-  return state_change_.Get(index);
-}
-inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateNotification::mutable_state_change(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
-  return state_change_.Mutable(index);
-}
-inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateNotification::add_state_change() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
-  return state_change_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
-UpdateMemberStateNotification::state_change() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
-  return state_change_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
-UpdateMemberStateNotification::mutable_state_change() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
-  return &state_change_;
-}
-
-// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
-inline bool UpdateMemberStateNotification::has_channel_id() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void UpdateMemberStateNotification::set_has_channel_id() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void UpdateMemberStateNotification::clear_has_channel_id() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void UpdateMemberStateNotification::clear_channel_id() {
-  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
-  clear_has_channel_id();
-}
-inline const ::bgs::protocol::channel::v1::ChannelId& UpdateMemberStateNotification::channel_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.channel_id)
-  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* UpdateMemberStateNotification::mutable_channel_id() {
-  set_has_channel_id();
-  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.channel_id)
-  return channel_id_;
-}
-inline ::bgs::protocol::channel::v1::ChannelId* UpdateMemberStateNotification::release_channel_id() {
-  clear_has_channel_id();
-  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
-  channel_id_ = NULL;
-  return temp;
-}
-inline void UpdateMemberStateNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
-  delete channel_id_;
-  channel_id_ = channel_id;
-  if (channel_id) {
-    set_has_channel_id();
-  } else {
-    clear_has_channel_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateNotification.channel_id)
-}
-
-// optional .bgs.protocol.account.v1.Identity subscriber = 5;
-inline bool UpdateMemberStateNotification::has_subscriber() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void UpdateMemberStateNotification::set_has_subscriber() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void UpdateMemberStateNotification::clear_has_subscriber() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void UpdateMemberStateNotification::clear_subscriber() {
-  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
-  clear_has_subscriber();
-}
-inline const ::bgs::protocol::account::v1::Identity& UpdateMemberStateNotification::subscriber() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.subscriber)
-  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* UpdateMemberStateNotification::mutable_subscriber() {
-  set_has_subscriber();
-  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.subscriber)
-  return subscriber_;
-}
-inline ::bgs::protocol::account::v1::Identity* UpdateMemberStateNotification::release_subscriber() {
-  clear_has_subscriber();
-  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
-  subscriber_ = NULL;
-  return temp;
-}
-inline void UpdateMemberStateNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
-  delete subscriber_;
-  subscriber_ = subscriber;
-  if (subscriber) {
-    set_has_subscriber();
-  } else {
-    clear_has_subscriber();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateNotification.subscriber)
-}
-
-
-// @@protoc_insertion_point(namespace_scope)
-
-}  // namespace v1
-}  // namespace channel
-}  // namespace protocol
-}  // namespace bgs
-
-#ifndef SWIG
-namespace google {
-namespace protobuf {
-
-
-}  // namespace google
-}  // namespace protobuf
-#endif  // SWIG
-
-// @@protoc_insertion_point(global_scope)
-
-#endif  // PROTOBUF_channel_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/channel_types.pb.cc b/src/server/proto/Client/channel_types.pb.cc
index 7e6a71a5245..e27aaf9942f 100644
--- a/src/server/proto/Client/channel_types.pb.cc
+++ b/src/server/proto/Client/channel_types.pb.cc
@@ -262,51 +262,51 @@ void protobuf_AddDesc_channel_5ftypes_2eproto() {
   already_here = true;
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
-  ::bgs::protocol::channel::v1::protobuf_AddDesc_client_2fv1_2fchannel_5fid_2eproto();
+  ::bgs::protocol::channel::v1::protobuf_AddDesc_api_2fclient_2fv1_2fchannel_5fid_2eproto();
   ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
   ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
   ::bgs::protocol::protobuf_AddDesc_invitation_5ftypes_2eproto();
   ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\023channel_types.proto\022\027bgs.protocol.chan"
-    "nel.v1\032\032client/v1/channel_id.proto\032\025attr"
-    "ibute_types.proto\032\022entity_types.proto\032\026i"
-    "nvitation_types.proto\032\017rpc_types.proto\"<"
-    "\n\007Message\022*\n\tattribute\030\001 \003(\0132\027.bgs.proto"
-    "col.Attribute*\005\010d\020\220N\"\333\001\n\023ListChannelsOpt"
-    "ions\022\026\n\013start_index\030\001 \001(\r:\0010\022\027\n\013max_resu"
-    "lts\030\002 \001(\r:\00216\022\014\n\004name\030\003 \001(\t\022\017\n\007program\030\004"
-    " \001(\007\022\016\n\006locale\030\005 \001(\007\022\025\n\rcapacity_full\030\006 "
-    "\001(\r\0227\n\020attribute_filter\030\007 \002(\0132\035.bgs.prot"
-    "ocol.AttributeFilter\022\024\n\014channel_type\030\010 \001"
-    "(\t\"\217\001\n\022ChannelDescription\022*\n\nchannel_id\030"
-    "\001 \002(\0132\026.bgs.protocol.EntityId\022\027\n\017current"
-    "_members\030\002 \001(\r\0224\n\005state\030\003 \001(\0132%.bgs.prot"
-    "ocol.channel.v1.ChannelState\"\200\001\n\013Channel"
-    "Info\022@\n\013description\030\001 \002(\0132+.bgs.protocol"
-    ".channel.v1.ChannelDescription\022/\n\006member"
-    "\030\002 \003(\0132\037.bgs.protocol.channel.v1.Member\""
-    "\202\004\n\014ChannelState\022\023\n\013max_members\030\001 \001(\r\022\023\n"
-    "\013min_members\030\002 \001(\r\022*\n\tattribute\030\003 \003(\0132\027."
-    "bgs.protocol.Attribute\022,\n\ninvitation\030\004 \003"
-    "(\0132\030.bgs.protocol.Invitation\022\016\n\006reason\030\006"
-    " \001(\r\022]\n\rprivacy_level\030\007 \001(\01622.bgs.protoc"
-    "ol.channel.v1.ChannelState.PrivacyLevel:"
-    "\022PRIVACY_LEVEL_OPEN\022\014\n\004name\030\010 \001(\t\022\035\n\014cha"
-    "nnel_type\030\n \001(\t:\007default\022\022\n\007program\030\013 \001("
-    "\007:\0010\022#\n\025subscribe_to_presence\030\r \001(\010:\004tru"
-    "e\"\221\001\n\014PrivacyLevel\022\026\n\022PRIVACY_LEVEL_OPEN"
-    "\020\001\022,\n(PRIVACY_LEVEL_OPEN_INVITATION_AND_"
-    "FRIEND\020\002\022!\n\035PRIVACY_LEVEL_OPEN_INVITATIO"
-    "N\020\003\022\030\n\024PRIVACY_LEVEL_CLOSED\020\004*\005\010d\020\220N\"\'\n\021"
-    "MemberAccountInfo\022\022\n\nbattle_tag\030\003 \001(\t\"\234\001"
-    "\n\013MemberState\022*\n\tattribute\030\001 \003(\0132\027.bgs.p"
-    "rotocol.Attribute\022\020\n\004role\030\002 \003(\rB\002\020\001\022\025\n\np"
-    "rivileges\030\003 \001(\004:\0010\0228\n\004info\030\004 \001(\0132*.bgs.p"
-    "rotocol.channel.v1.MemberAccountInfo\"g\n\006"
-    "Member\022(\n\010identity\030\001 \002(\0132\026.bgs.protocol."
-    "Identity\0223\n\005state\030\002 \002(\0132$.bgs.protocol.c"
-    "hannel.v1.MemberStateB\002H\001P\000", 1547);
+    "nel.v1\032\036api/client/v1/channel_id.proto\032\025"
+    "attribute_types.proto\032\022entity_types.prot"
+    "o\032\026invitation_types.proto\032\017rpc_types.pro"
+    "to\"<\n\007Message\022*\n\tattribute\030\001 \003(\0132\027.bgs.p"
+    "rotocol.Attribute*\005\010d\020\220N\"\333\001\n\023ListChannel"
+    "sOptions\022\026\n\013start_index\030\001 \001(\r:\0010\022\027\n\013max_"
+    "results\030\002 \001(\r:\00216\022\014\n\004name\030\003 \001(\t\022\017\n\007progr"
+    "am\030\004 \001(\007\022\016\n\006locale\030\005 \001(\007\022\025\n\rcapacity_ful"
+    "l\030\006 \001(\r\0227\n\020attribute_filter\030\007 \002(\0132\035.bgs."
+    "protocol.AttributeFilter\022\024\n\014channel_type"
+    "\030\010 \001(\t\"\217\001\n\022ChannelDescription\022*\n\nchannel"
+    "_id\030\001 \002(\0132\026.bgs.protocol.EntityId\022\027\n\017cur"
+    "rent_members\030\002 \001(\r\0224\n\005state\030\003 \001(\0132%.bgs."
+    "protocol.channel.v1.ChannelState\"\200\001\n\013Cha"
+    "nnelInfo\022@\n\013description\030\001 \002(\0132+.bgs.prot"
+    "ocol.channel.v1.ChannelDescription\022/\n\006me"
+    "mber\030\002 \003(\0132\037.bgs.protocol.channel.v1.Mem"
+    "ber\"\377\003\n\014ChannelState\022\023\n\013max_members\030\001 \001("
+    "\r\022\023\n\013min_members\030\002 \001(\r\022*\n\tattribute\030\003 \003("
+    "\0132\027.bgs.protocol.Attribute\022,\n\ninvitation"
+    "\030\004 \003(\0132\030.bgs.protocol.Invitation\022\016\n\006reas"
+    "on\030\006 \001(\r\022]\n\rprivacy_level\030\007 \001(\01622.bgs.pr"
+    "otocol.channel.v1.ChannelState.PrivacyLe"
+    "vel:\022PRIVACY_LEVEL_OPEN\022\014\n\004name\030\010 \001(\t\022\035\n"
+    "\014channel_type\030\n \001(\t:\007default\022\017\n\007program\030"
+    "\013 \001(\007\022#\n\025subscribe_to_presence\030\r \001(\010:\004tr"
+    "ue\"\221\001\n\014PrivacyLevel\022\026\n\022PRIVACY_LEVEL_OPE"
+    "N\020\001\022,\n(PRIVACY_LEVEL_OPEN_INVITATION_AND"
+    "_FRIEND\020\002\022!\n\035PRIVACY_LEVEL_OPEN_INVITATI"
+    "ON\020\003\022\030\n\024PRIVACY_LEVEL_CLOSED\020\004*\005\010d\020\220N\"\'\n"
+    "\021MemberAccountInfo\022\022\n\nbattle_tag\030\003 \001(\t\"\234"
+    "\001\n\013MemberState\022*\n\tattribute\030\001 \003(\0132\027.bgs."
+    "protocol.Attribute\022\020\n\004role\030\002 \003(\rB\002\020\001\022\025\n\n"
+    "privileges\030\003 \001(\004:\0010\0228\n\004info\030\004 \001(\0132*.bgs."
+    "protocol.channel.v1.MemberAccountInfo\"g\n"
+    "\006Member\022(\n\010identity\030\001 \002(\0132\026.bgs.protocol"
+    ".Identity\0223\n\005state\030\002 \002(\0132$.bgs.protocol."
+    "channel.v1.MemberStateB\002H\001P\000", 1548);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "channel_types.proto", &protobuf_RegisterTypes);
   Message::default_instance_ = new Message();
@@ -2007,7 +2007,7 @@ bool ChannelState::MergePartialFromCodedStream(
         break;
       }
 
-      // optional fixed32 program = 11 [default = 0];
+      // optional fixed32 program = 11;
       case 11: {
         if (tag == 93) {
          parse_program:
@@ -2120,7 +2120,7 @@ void ChannelState::SerializeWithCachedSizes(
       10, this->channel_type(), output);
   }
 
-  // optional fixed32 program = 11 [default = 0];
+  // optional fixed32 program = 11;
   if (has_program()) {
     ::google::protobuf::internal::WireFormatLite::WriteFixed32(11, this->program(), output);
   }
@@ -2201,7 +2201,7 @@ void ChannelState::SerializeWithCachedSizes(
         10, this->channel_type(), target);
   }
 
-  // optional fixed32 program = 11 [default = 0];
+  // optional fixed32 program = 11;
   if (has_program()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(11, this->program(), target);
   }
@@ -2270,7 +2270,7 @@ int ChannelState::ByteSize() const {
 
   }
   if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
-    // optional fixed32 program = 11 [default = 0];
+    // optional fixed32 program = 11;
     if (has_program()) {
       total_size += 1 + 4;
     }
diff --git a/src/server/proto/Client/channel_types.pb.h b/src/server/proto/Client/channel_types.pb.h
index 407e68e73c6..c17da91a0b4 100644
--- a/src/server/proto/Client/channel_types.pb.h
+++ b/src/server/proto/Client/channel_types.pb.h
@@ -25,7 +25,7 @@
 #include <google/protobuf/extension_set.h>
 #include <google/protobuf/generated_enum_reflection.h>
 #include <google/protobuf/unknown_field_set.h>
-#include "client/v1/channel_id.pb.h"  // IWYU pragma: export
+#include "api/client/v1/channel_id.pb.h"  // IWYU pragma: export
 #include "attribute_types.pb.h"
 #include "entity_types.pb.h"
 #include "invitation_types.pb.h"
@@ -673,7 +673,7 @@ class TC_PROTO_API ChannelState : public ::google::protobuf::Message {
   inline ::std::string* release_channel_type();
   inline void set_allocated_channel_type(::std::string* channel_type);
 
-  // optional fixed32 program = 11 [default = 0];
+  // optional fixed32 program = 11;
   inline bool has_program() const;
   inline void clear_program();
   static const int kProgramFieldNumber = 11;
@@ -1881,7 +1881,7 @@ inline void ChannelState::set_allocated_channel_type(::std::string* channel_type
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelState.channel_type)
 }
 
-// optional fixed32 program = 11 [default = 0];
+// optional fixed32 program = 11;
 inline bool ChannelState::has_program() const {
   return (_has_bits_[0] & 0x00000100u) != 0;
 }
diff --git a/src/server/proto/Client/club_ban.pb.cc b/src/server/proto/Client/club_ban.pb.cc
new file mode 100644
index 00000000000..a9e9c2a3aeb
--- /dev/null
+++ b/src/server/proto/Client/club_ban.pb.cc
@@ -0,0 +1,959 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_ban.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_ban.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* AddBanOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AddBanOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubBan_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubBan_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5fban_2eproto() {
+  protobuf_AddDesc_club_5fban_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_ban.proto");
+  GOOGLE_CHECK(file != NULL);
+  AddBanOptions_descriptor_ = file->message_type(0);
+  static const int AddBanOptions_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanOptions, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanOptions, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanOptions, reason_),
+  };
+  AddBanOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AddBanOptions_descriptor_,
+      AddBanOptions::default_instance_,
+      AddBanOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AddBanOptions));
+  ClubBan_descriptor_ = file->message_type(1);
+  static const int ClubBan_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBan, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBan, battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBan, creator_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBan, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBan, reason_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBan, creation_time_),
+  };
+  ClubBan_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubBan_descriptor_,
+      ClubBan::default_instance_,
+      ClubBan_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBan, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBan, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubBan));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5fban_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AddBanOptions_descriptor_, &AddBanOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubBan_descriptor_, &ClubBan::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5fban_2eproto() {
+  delete AddBanOptions::default_instance_;
+  delete AddBanOptions_reflection_;
+  delete ClubBan::default_instance_;
+  delete ClubBan_reflection_;
+}
+
+void protobuf_AddDesc_club_5fban_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fmember_2eproto();
+  ::bgs::protocol::v2::protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\016club_ban.proto\022\024bgs.protocol.club.v1\032\021"
+    "club_member.proto\032#api/client/v2/attribu"
+    "te_types.proto\"\201\001\n\rAddBanOptions\0221\n\ttarg"
+    "et_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Membe"
+    "rId\022-\n\tattribute\030\002 \003(\0132\032.bgs.protocol.v2"
+    ".Attribute\022\016\n\006reason\030\003 \001(\t\"\331\001\n\007ClubBan\022*"
+    "\n\002id\030\001 \001(\0132\036.bgs.protocol.club.v1.Member"
+    "Id\022\022\n\nbattle_tag\030\002 \001(\t\0228\n\007creator\030\003 \001(\0132"
+    "\'.bgs.protocol.club.v1.MemberDescription"
+    "\022-\n\tattribute\030\004 \003(\0132\032.bgs.protocol.v2.At"
+    "tribute\022\016\n\006reason\030\005 \001(\t\022\025\n\rcreation_time"
+    "\030\006 \001(\004B\002H\001", 450);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_ban.proto", &protobuf_RegisterTypes);
+  AddBanOptions::default_instance_ = new AddBanOptions();
+  ClubBan::default_instance_ = new ClubBan();
+  AddBanOptions::default_instance_->InitAsDefaultInstance();
+  ClubBan::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5fban_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5fban_2eproto {
+  StaticDescriptorInitializer_club_5fban_2eproto() {
+    protobuf_AddDesc_club_5fban_2eproto();
+  }
+} static_descriptor_initializer_club_5fban_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AddBanOptions::kTargetIdFieldNumber;
+const int AddBanOptions::kAttributeFieldNumber;
+const int AddBanOptions::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+AddBanOptions::AddBanOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.AddBanOptions)
+}
+
+void AddBanOptions::InitAsDefaultInstance() {
+  target_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+AddBanOptions::AddBanOptions(const AddBanOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.AddBanOptions)
+}
+
+void AddBanOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  target_id_ = NULL;
+  reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AddBanOptions::~AddBanOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.AddBanOptions)
+  SharedDtor();
+}
+
+void AddBanOptions::SharedDtor() {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete reason_;
+  }
+  if (this != default_instance_) {
+    delete target_id_;
+  }
+}
+
+void AddBanOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AddBanOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AddBanOptions_descriptor_;
+}
+
+const AddBanOptions& AddBanOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fban_2eproto();
+  return *default_instance_;
+}
+
+AddBanOptions* AddBanOptions::default_instance_ = NULL;
+
+AddBanOptions* AddBanOptions::New() const {
+  return new AddBanOptions;
+}
+
+void AddBanOptions::Clear() {
+  if (_has_bits_[0 / 32] & 5) {
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_reason()) {
+      if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        reason_->clear();
+      }
+    }
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AddBanOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.AddBanOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectTag(26)) goto parse_reason;
+        break;
+      }
+
+      // optional string reason = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_reason:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_reason()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->reason().data(), this->reason().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "reason");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.AddBanOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.AddBanOptions)
+  return false;
+#undef DO_
+}
+
+void AddBanOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.AddBanOptions)
+  // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->target_id(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  // optional string reason = 3;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->reason().data(), this->reason().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "reason");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.AddBanOptions)
+}
+
+::google::protobuf::uint8* AddBanOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.AddBanOptions)
+  // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->target_id(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  // optional string reason = 3;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->reason().data(), this->reason().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "reason");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.AddBanOptions)
+  return target;
+}
+
+int AddBanOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // optional string reason = 3;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->reason());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AddBanOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AddBanOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AddBanOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AddBanOptions::MergeFrom(const AddBanOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.target_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AddBanOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AddBanOptions::CopyFrom(const AddBanOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AddBanOptions::IsInitialized() const {
+
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AddBanOptions::Swap(AddBanOptions* other) {
+  if (other != this) {
+    std::swap(target_id_, other->target_id_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AddBanOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AddBanOptions_descriptor_;
+  metadata.reflection = AddBanOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubBan::kIdFieldNumber;
+const int ClubBan::kBattleTagFieldNumber;
+const int ClubBan::kCreatorFieldNumber;
+const int ClubBan::kAttributeFieldNumber;
+const int ClubBan::kReasonFieldNumber;
+const int ClubBan::kCreationTimeFieldNumber;
+#endif  // !_MSC_VER
+
+ClubBan::ClubBan()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubBan)
+}
+
+void ClubBan::InitAsDefaultInstance() {
+  id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  creator_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+}
+
+ClubBan::ClubBan(const ClubBan& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubBan)
+}
+
+void ClubBan::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = NULL;
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  creator_ = NULL;
+  reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubBan::~ClubBan() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubBan)
+  SharedDtor();
+}
+
+void ClubBan::SharedDtor() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete reason_;
+  }
+  if (this != default_instance_) {
+    delete id_;
+    delete creator_;
+  }
+}
+
+void ClubBan::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubBan::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubBan_descriptor_;
+}
+
+const ClubBan& ClubBan::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fban_2eproto();
+  return *default_instance_;
+}
+
+ClubBan* ClubBan::default_instance_ = NULL;
+
+ClubBan* ClubBan::New() const {
+  return new ClubBan;
+}
+
+void ClubBan::Clear() {
+  if (_has_bits_[0 / 32] & 55) {
+    if (has_id()) {
+      if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+    if (has_creator()) {
+      if (creator_ != NULL) creator_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+    if (has_reason()) {
+      if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        reason_->clear();
+      }
+    }
+    creation_time_ = GOOGLE_ULONGLONG(0);
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubBan::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubBan)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_creator;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription creator = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_creator:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_creator()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attribute;
+        if (input->ExpectTag(42)) goto parse_reason;
+        break;
+      }
+
+      // optional string reason = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_reason:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_reason()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->reason().data(), this->reason().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "reason");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubBan)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubBan)
+  return false;
+#undef DO_
+}
+
+void ClubBan::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubBan)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->id(), output);
+  }
+
+  // optional string battle_tag = 2;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->battle_tag(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription creator = 3;
+  if (has_creator()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->creator(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 4;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->attribute(i), output);
+  }
+
+  // optional string reason = 5;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->reason().data(), this->reason().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "reason");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->reason(), output);
+  }
+
+  // optional uint64 creation_time = 6;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->creation_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubBan)
+}
+
+::google::protobuf::uint8* ClubBan::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubBan)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->id(), target);
+  }
+
+  // optional string battle_tag = 2;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->battle_tag(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription creator = 3;
+  if (has_creator()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->creator(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 4;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->attribute(i), target);
+  }
+
+  // optional string reason = 5;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->reason().data(), this->reason().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "reason");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->reason(), target);
+  }
+
+  // optional uint64 creation_time = 6;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->creation_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubBan)
+  return target;
+}
+
+int ClubBan::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->id());
+    }
+
+    // optional string battle_tag = 2;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription creator = 3;
+    if (has_creator()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->creator());
+    }
+
+    // optional string reason = 5;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->reason());
+    }
+
+    // optional uint64 creation_time = 6;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 4;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubBan::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubBan* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubBan*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubBan::MergeFrom(const ClubBan& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      mutable_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.id());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+    if (from.has_creator()) {
+      mutable_creator()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.creator());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubBan::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubBan::CopyFrom(const ClubBan& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubBan::IsInitialized() const {
+
+  if (has_id()) {
+    if (!this->id().IsInitialized()) return false;
+  }
+  if (has_creator()) {
+    if (!this->creator().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubBan::Swap(ClubBan* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(creator_, other->creator_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(reason_, other->reason_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubBan::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubBan_descriptor_;
+  metadata.reflection = ClubBan_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_ban.pb.h b/src/server/proto/Client/club_ban.pb.h
new file mode 100644
index 00000000000..b70366b8a78
--- /dev/null
+++ b/src/server/proto/Client/club_ban.pb.h
@@ -0,0 +1,768 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_ban.proto
+
+#ifndef PROTOBUF_club_5fban_2eproto__INCLUDED
+#define PROTOBUF_club_5fban_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "club_member.pb.h"
+#include "api/client/v2/attribute_types.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5fban_2eproto();
+void protobuf_AssignDesc_club_5fban_2eproto();
+void protobuf_ShutdownFile_club_5fban_2eproto();
+
+class AddBanOptions;
+class ClubBan;
+
+// ===================================================================
+
+class TC_PROTO_API AddBanOptions : public ::google::protobuf::Message {
+ public:
+  AddBanOptions();
+  virtual ~AddBanOptions();
+
+  AddBanOptions(const AddBanOptions& from);
+
+  inline AddBanOptions& operator=(const AddBanOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AddBanOptions& default_instance();
+
+  void Swap(AddBanOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  AddBanOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AddBanOptions& from);
+  void MergeFrom(const AddBanOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& target_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_target_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string reason = 3;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 3;
+  inline const ::std::string& reason() const;
+  inline void set_reason(const ::std::string& value);
+  inline void set_reason(const char* value);
+  inline void set_reason(const char* value, size_t size);
+  inline ::std::string* mutable_reason();
+  inline ::std::string* release_reason();
+  inline void set_allocated_reason(::std::string* reason);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.AddBanOptions)
+ private:
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* target_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* reason_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fban_2eproto();
+  friend void protobuf_AssignDesc_club_5fban_2eproto();
+  friend void protobuf_ShutdownFile_club_5fban_2eproto();
+
+  void InitAsDefaultInstance();
+  static AddBanOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubBan : public ::google::protobuf::Message {
+ public:
+  ClubBan();
+  virtual ~ClubBan();
+
+  ClubBan(const ClubBan& from);
+
+  inline ClubBan& operator=(const ClubBan& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubBan& default_instance();
+
+  void Swap(ClubBan* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubBan* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubBan& from);
+  void MergeFrom(const ClubBan& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_id();
+  inline void set_allocated_id(::bgs::protocol::club::v1::MemberId* id);
+
+  // optional string battle_tag = 2;
+  inline bool has_battle_tag() const;
+  inline void clear_battle_tag();
+  static const int kBattleTagFieldNumber = 2;
+  inline const ::std::string& battle_tag() const;
+  inline void set_battle_tag(const ::std::string& value);
+  inline void set_battle_tag(const char* value);
+  inline void set_battle_tag(const char* value, size_t size);
+  inline ::std::string* mutable_battle_tag();
+  inline ::std::string* release_battle_tag();
+  inline void set_allocated_battle_tag(::std::string* battle_tag);
+
+  // optional .bgs.protocol.club.v1.MemberDescription creator = 3;
+  inline bool has_creator() const;
+  inline void clear_creator();
+  static const int kCreatorFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberDescription& creator() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_creator();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_creator();
+  inline void set_allocated_creator(::bgs::protocol::club::v1::MemberDescription* creator);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 4;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 4;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string reason = 5;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 5;
+  inline const ::std::string& reason() const;
+  inline void set_reason(const ::std::string& value);
+  inline void set_reason(const char* value);
+  inline void set_reason(const char* value, size_t size);
+  inline ::std::string* mutable_reason();
+  inline ::std::string* release_reason();
+  inline void set_allocated_reason(::std::string* reason);
+
+  // optional uint64 creation_time = 6;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 6;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubBan)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+  inline void set_has_creator();
+  inline void clear_has_creator();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* id_;
+  ::std::string* battle_tag_;
+  ::bgs::protocol::club::v1::MemberDescription* creator_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* reason_;
+  ::google::protobuf::uint64 creation_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fban_2eproto();
+  friend void protobuf_AssignDesc_club_5fban_2eproto();
+  friend void protobuf_ShutdownFile_club_5fban_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubBan* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// AddBanOptions
+
+// optional .bgs.protocol.club.v1.MemberId target_id = 1;
+inline bool AddBanOptions::has_target_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AddBanOptions::set_has_target_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AddBanOptions::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AddBanOptions::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& AddBanOptions::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AddBanOptions.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AddBanOptions::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AddBanOptions.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AddBanOptions::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::club::v1::MemberId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void AddBanOptions::set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AddBanOptions.target_id)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 2;
+inline int AddBanOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void AddBanOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& AddBanOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AddBanOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* AddBanOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AddBanOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* AddBanOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.AddBanOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+AddBanOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.AddBanOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+AddBanOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.AddBanOptions.attribute)
+  return &attribute_;
+}
+
+// optional string reason = 3;
+inline bool AddBanOptions::has_reason() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AddBanOptions::set_has_reason() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AddBanOptions::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AddBanOptions::clear_reason() {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_->clear();
+  }
+  clear_has_reason();
+}
+inline const ::std::string& AddBanOptions::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AddBanOptions.reason)
+  return *reason_;
+}
+inline void AddBanOptions::set_reason(const ::std::string& value) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AddBanOptions.reason)
+}
+inline void AddBanOptions::set_reason(const char* value) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.AddBanOptions.reason)
+}
+inline void AddBanOptions::set_reason(const char* value, size_t size) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.AddBanOptions.reason)
+}
+inline ::std::string* AddBanOptions::mutable_reason() {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AddBanOptions.reason)
+  return reason_;
+}
+inline ::std::string* AddBanOptions::release_reason() {
+  clear_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = reason_;
+    reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void AddBanOptions::set_allocated_reason(::std::string* reason) {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete reason_;
+  }
+  if (reason) {
+    set_has_reason();
+    reason_ = reason;
+  } else {
+    clear_has_reason();
+    reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AddBanOptions.reason)
+}
+
+// -------------------------------------------------------------------
+
+// ClubBan
+
+// optional .bgs.protocol.club.v1.MemberId id = 1;
+inline bool ClubBan::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubBan::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubBan::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubBan::clear_id() {
+  if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& ClubBan::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubBan.id)
+  return id_ != NULL ? *id_ : *default_instance_->id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubBan::mutable_id() {
+  set_has_id();
+  if (id_ == NULL) id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubBan.id)
+  return id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubBan::release_id() {
+  clear_has_id();
+  ::bgs::protocol::club::v1::MemberId* temp = id_;
+  id_ = NULL;
+  return temp;
+}
+inline void ClubBan::set_allocated_id(::bgs::protocol::club::v1::MemberId* id) {
+  delete id_;
+  id_ = id;
+  if (id) {
+    set_has_id();
+  } else {
+    clear_has_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubBan.id)
+}
+
+// optional string battle_tag = 2;
+inline bool ClubBan::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubBan::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubBan::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubBan::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& ClubBan::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubBan.battle_tag)
+  return *battle_tag_;
+}
+inline void ClubBan::set_battle_tag(const ::std::string& value) {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubBan.battle_tag)
+}
+inline void ClubBan::set_battle_tag(const char* value) {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubBan.battle_tag)
+}
+inline void ClubBan::set_battle_tag(const char* value, size_t size) {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubBan.battle_tag)
+}
+inline ::std::string* ClubBan::mutable_battle_tag() {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubBan.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* ClubBan::release_battle_tag() {
+  clear_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = battle_tag_;
+    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubBan::set_allocated_battle_tag(::std::string* battle_tag) {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (battle_tag) {
+    set_has_battle_tag();
+    battle_tag_ = battle_tag;
+  } else {
+    clear_has_battle_tag();
+    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubBan.battle_tag)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription creator = 3;
+inline bool ClubBan::has_creator() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubBan::set_has_creator() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubBan::clear_has_creator() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubBan::clear_creator() {
+  if (creator_ != NULL) creator_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_creator();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& ClubBan::creator() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubBan.creator)
+  return creator_ != NULL ? *creator_ : *default_instance_->creator_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubBan::mutable_creator() {
+  set_has_creator();
+  if (creator_ == NULL) creator_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubBan.creator)
+  return creator_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubBan::release_creator() {
+  clear_has_creator();
+  ::bgs::protocol::club::v1::MemberDescription* temp = creator_;
+  creator_ = NULL;
+  return temp;
+}
+inline void ClubBan::set_allocated_creator(::bgs::protocol::club::v1::MemberDescription* creator) {
+  delete creator_;
+  creator_ = creator;
+  if (creator) {
+    set_has_creator();
+  } else {
+    clear_has_creator();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubBan.creator)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 4;
+inline int ClubBan::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClubBan::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& ClubBan::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubBan.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubBan::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubBan.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubBan::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubBan.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+ClubBan::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubBan.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+ClubBan::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubBan.attribute)
+  return &attribute_;
+}
+
+// optional string reason = 5;
+inline bool ClubBan::has_reason() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubBan::set_has_reason() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubBan::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubBan::clear_reason() {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_->clear();
+  }
+  clear_has_reason();
+}
+inline const ::std::string& ClubBan::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubBan.reason)
+  return *reason_;
+}
+inline void ClubBan::set_reason(const ::std::string& value) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubBan.reason)
+}
+inline void ClubBan::set_reason(const char* value) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubBan.reason)
+}
+inline void ClubBan::set_reason(const char* value, size_t size) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubBan.reason)
+}
+inline ::std::string* ClubBan::mutable_reason() {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubBan.reason)
+  return reason_;
+}
+inline ::std::string* ClubBan::release_reason() {
+  clear_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = reason_;
+    reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubBan::set_allocated_reason(::std::string* reason) {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete reason_;
+  }
+  if (reason) {
+    set_has_reason();
+    reason_ = reason;
+  } else {
+    clear_has_reason();
+    reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubBan.reason)
+}
+
+// optional uint64 creation_time = 6;
+inline bool ClubBan::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClubBan::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClubBan::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClubBan::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 ClubBan::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubBan.creation_time)
+  return creation_time_;
+}
+inline void ClubBan::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubBan.creation_time)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5fban_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_core.pb.cc b/src/server/proto/Client/club_core.pb.cc
new file mode 100644
index 00000000000..f2babe24a5e
--- /dev/null
+++ b/src/server/proto/Client/club_core.pb.cc
@@ -0,0 +1,6442 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_core.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_core.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* AvatarId_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AvatarId_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SetBroadcastOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SetBroadcastOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Broadcast_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Broadcast_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UniqueClubType_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UniqueClubType_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubCreateOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubCreateOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Club_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Club_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubDescription_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubDescription_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubView_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubView_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubStateOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubStateOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubStateAssignment_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubStateAssignment_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamSettings_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamSettings_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubSettings_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubSettings_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubSettingsOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubSettingsOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubSettingsAssignment_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubSettingsAssignment_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5fcore_2eproto() {
+  protobuf_AddDesc_club_5fcore_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_core.proto");
+  GOOGLE_CHECK(file != NULL);
+  AvatarId_descriptor_ = file->message_type(0);
+  static const int AvatarId_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AvatarId, id_),
+  };
+  AvatarId_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AvatarId_descriptor_,
+      AvatarId::default_instance_,
+      AvatarId_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AvatarId, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AvatarId, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AvatarId));
+  SetBroadcastOptions_descriptor_ = file->message_type(1);
+  static const int SetBroadcastOptions_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetBroadcastOptions, content_),
+  };
+  SetBroadcastOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SetBroadcastOptions_descriptor_,
+      SetBroadcastOptions::default_instance_,
+      SetBroadcastOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetBroadcastOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetBroadcastOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SetBroadcastOptions));
+  Broadcast_descriptor_ = file->message_type(2);
+  static const int Broadcast_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Broadcast, content_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Broadcast, creator_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Broadcast, creation_time_),
+  };
+  Broadcast_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Broadcast_descriptor_,
+      Broadcast::default_instance_,
+      Broadcast_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Broadcast, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Broadcast, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Broadcast));
+  UniqueClubType_descriptor_ = file->message_type(3);
+  static const int UniqueClubType_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UniqueClubType, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UniqueClubType, name_),
+  };
+  UniqueClubType_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UniqueClubType_descriptor_,
+      UniqueClubType::default_instance_,
+      UniqueClubType_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UniqueClubType, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UniqueClubType, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UniqueClubType));
+  ClubCreateOptions_descriptor_ = file->message_type(4);
+  static const int ClubCreateOptions_offsets_[9] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, avatar_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, privacy_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, short_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, member_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, stream_),
+  };
+  ClubCreateOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubCreateOptions_descriptor_,
+      ClubCreateOptions::default_instance_,
+      ClubCreateOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubCreateOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubCreateOptions));
+  Club_descriptor_ = file->message_type(5);
+  static const int Club_offsets_[15] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, broadcast_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, avatar_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, privacy_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, visibility_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, member_count_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, creation_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, stream_position_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, role_set_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, leader_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, short_name_),
+  };
+  Club_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Club_descriptor_,
+      Club::default_instance_,
+      Club_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Club, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Club));
+  ClubDescription_descriptor_ = file->message_type(6);
+  static const int ClubDescription_offsets_[10] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, avatar_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, privacy_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, visibility_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, member_count_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, leader_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, creation_time_),
+  };
+  ClubDescription_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubDescription_descriptor_,
+      ClubDescription::default_instance_,
+      ClubDescription_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubDescription, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubDescription));
+  ClubView_descriptor_ = file->message_type(7);
+  static const int ClubView_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubView, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubView, marker_),
+  };
+  ClubView_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubView_descriptor_,
+      ClubView::default_instance_,
+      ClubView_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubView, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubView, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubView));
+  ClubStateOptions_descriptor_ = file->message_type(8);
+  static const int ClubStateOptions_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, broadcast_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, avatar_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, privacy_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, stream_position_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, short_name_),
+  };
+  ClubStateOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubStateOptions_descriptor_,
+      ClubStateOptions::default_instance_,
+      ClubStateOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubStateOptions));
+  ClubStateAssignment_descriptor_ = file->message_type(9);
+  static const int ClubStateAssignment_offsets_[9] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, broadcast_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, avatar_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, privacy_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, stream_position_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, short_name_),
+  };
+  ClubStateAssignment_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubStateAssignment_descriptor_,
+      ClubStateAssignment::default_instance_,
+      ClubStateAssignment_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStateAssignment, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubStateAssignment));
+  StreamSettings_descriptor_ = file->message_type(10);
+  static const int StreamSettings_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamSettings, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamSettings, filter_),
+  };
+  StreamSettings_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamSettings_descriptor_,
+      StreamSettings::default_instance_,
+      StreamSettings_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamSettings, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamSettings, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamSettings));
+  ClubSettings_descriptor_ = file->message_type(11);
+  static const int ClubSettings_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettings, stream_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettings, stream_notification_filter_all_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettings, attribute_),
+  };
+  ClubSettings_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubSettings_descriptor_,
+      ClubSettings::default_instance_,
+      ClubSettings_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettings, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettings, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubSettings));
+  ClubSettingsOptions_descriptor_ = file->message_type(12);
+  static const int ClubSettingsOptions_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettingsOptions, stream_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettingsOptions, settings_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettingsOptions, version_),
+  };
+  ClubSettingsOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubSettingsOptions_descriptor_,
+      ClubSettingsOptions::default_instance_,
+      ClubSettingsOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettingsOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettingsOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubSettingsOptions));
+  ClubSettingsAssignment_descriptor_ = file->message_type(13);
+  static const int ClubSettingsAssignment_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettingsAssignment, stream_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettingsAssignment, settings_),
+  };
+  ClubSettingsAssignment_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubSettingsAssignment_descriptor_,
+      ClubSettingsAssignment::default_instance_,
+      ClubSettingsAssignment_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettingsAssignment, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSettingsAssignment, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubSettingsAssignment));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5fcore_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AvatarId_descriptor_, &AvatarId::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SetBroadcastOptions_descriptor_, &SetBroadcastOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Broadcast_descriptor_, &Broadcast::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UniqueClubType_descriptor_, &UniqueClubType::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubCreateOptions_descriptor_, &ClubCreateOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Club_descriptor_, &Club::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubDescription_descriptor_, &ClubDescription::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubView_descriptor_, &ClubView::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubStateOptions_descriptor_, &ClubStateOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubStateAssignment_descriptor_, &ClubStateAssignment::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamSettings_descriptor_, &StreamSettings::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubSettings_descriptor_, &ClubSettings::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubSettingsOptions_descriptor_, &ClubSettingsOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubSettingsAssignment_descriptor_, &ClubSettingsAssignment::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5fcore_2eproto() {
+  delete AvatarId::default_instance_;
+  delete AvatarId_reflection_;
+  delete SetBroadcastOptions::default_instance_;
+  delete SetBroadcastOptions_reflection_;
+  delete Broadcast::default_instance_;
+  delete Broadcast_reflection_;
+  delete UniqueClubType::default_instance_;
+  delete UniqueClubType_reflection_;
+  delete ClubCreateOptions::default_instance_;
+  delete ClubCreateOptions_reflection_;
+  delete Club::default_instance_;
+  delete Club_reflection_;
+  delete ClubDescription::default_instance_;
+  delete ClubDescription_reflection_;
+  delete ClubView::default_instance_;
+  delete ClubView_reflection_;
+  delete ClubStateOptions::default_instance_;
+  delete ClubStateOptions_reflection_;
+  delete ClubStateAssignment::default_instance_;
+  delete ClubStateAssignment_reflection_;
+  delete StreamSettings::default_instance_;
+  delete StreamSettings_reflection_;
+  delete ClubSettings::default_instance_;
+  delete ClubSettings_reflection_;
+  delete ClubSettingsOptions::default_instance_;
+  delete ClubSettingsOptions_reflection_;
+  delete ClubSettingsAssignment::default_instance_;
+  delete ClubSettingsAssignment_reflection_;
+}
+
+void protobuf_AddDesc_club_5fcore_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fenum_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5frole_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fmember_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fstream_2eproto();
+  ::bgs::protocol::v2::protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\017club_core.proto\022\024bgs.protocol.club.v1\032"
+    "\017club_enum.proto\032\017club_role.proto\032\021club_"
+    "member.proto\032\021club_stream.proto\032#api/cli"
+    "ent/v2/attribute_types.proto\032\026event_view"
+    "_types.proto\"\026\n\010AvatarId\022\n\n\002id\030\001 \001(\r\"&\n\023"
+    "SetBroadcastOptions\022\017\n\007content\030\001 \001(\t\"m\n\t"
+    "Broadcast\022\017\n\007content\030\001 \001(\t\0228\n\007creator\030\002 "
+    "\001(\0132\'.bgs.protocol.club.v1.MemberDescrip"
+    "tion\022\025\n\rcreation_time\030\003 \001(\004\"/\n\016UniqueClu"
+    "bType\022\017\n\007program\030\001 \001(\007\022\014\n\004name\030\002 \001(\t\"\216\003\n"
+    "\021ClubCreateOptions\0222\n\004type\030\001 \001(\0132$.bgs.p"
+    "rotocol.club.v1.UniqueClubType\022-\n\tattrib"
+    "ute\030\002 \003(\0132\032.bgs.protocol.v2.Attribute\022\014\n"
+    "\004name\030\003 \001(\t\022\023\n\013description\030\004 \001(\t\022.\n\006avat"
+    "ar\030\005 \001(\0132\036.bgs.protocol.club.v1.AvatarId"
+    "\0229\n\rprivacy_level\030\006 \001(\0162\".bgs.protocol.c"
+    "lub.v1.PrivacyLevel\022\022\n\nshort_name\030\007 \001(\t\022"
+    "9\n\006member\030\n \001(\0132).bgs.protocol.club.v1.C"
+    "reateMemberOptions\0229\n\006stream\030\013 \001(\0132).bgs"
+    ".protocol.club.v1.CreateStreamOptions\"\346\004"
+    "\n\004Club\022\n\n\002id\030\001 \001(\004\0222\n\004type\030\002 \001(\0132$.bgs.p"
+    "rotocol.club.v1.UniqueClubType\022-\n\tattrib"
+    "ute\030\003 \003(\0132\032.bgs.protocol.v2.Attribute\022\014\n"
+    "\004name\030\004 \001(\t\022\023\n\013description\030\005 \001(\t\0222\n\tbroa"
+    "dcast\030\006 \001(\0132\037.bgs.protocol.club.v1.Broad"
+    "cast\022.\n\006avatar\030\007 \001(\0132\036.bgs.protocol.club"
+    ".v1.AvatarId\0229\n\rprivacy_level\030\010 \001(\0162\".bg"
+    "s.protocol.club.v1.PrivacyLevel\022\?\n\020visib"
+    "ility_level\030\t \001(\0162%.bgs.protocol.club.v1"
+    ".VisibilityLevel\022\024\n\014member_count\030\n \001(\r\022\025"
+    "\n\rcreation_time\030\013 \001(\004\022=\n\017stream_position"
+    "\030\014 \001(\0132$.bgs.protocol.club.v1.StreamPosi"
+    "tion\0223\n\010role_set\030\r \001(\0132!.bgs.protocol.cl"
+    "ub.v1.ClubRoleSet\0227\n\006leader\030\016 \003(\0132\'.bgs."
+    "protocol.club.v1.MemberDescription\022\022\n\nsh"
+    "ort_name\030\017 \001(\t\"\206\003\n\017ClubDescription\022\n\n\002id"
+    "\030\001 \001(\004\0222\n\004type\030\002 \001(\0132$.bgs.protocol.club"
+    ".v1.UniqueClubType\022\014\n\004name\030\003 \001(\t\022\023\n\013desc"
+    "ription\030\004 \001(\t\022.\n\006avatar\030\005 \001(\0132\036.bgs.prot"
+    "ocol.club.v1.AvatarId\0229\n\rprivacy_level\030\006"
+    " \001(\0162\".bgs.protocol.club.v1.PrivacyLevel"
+    "\022\?\n\020visibility_level\030\007 \001(\0162%.bgs.protoco"
+    "l.club.v1.VisibilityLevel\022\024\n\014member_coun"
+    "t\030\010 \001(\r\0227\n\006leader\030\t \003(\0132\'.bgs.protocol.c"
+    "lub.v1.MemberDescription\022\025\n\rcreation_tim"
+    "e\030\n \001(\004\"E\n\010ClubView\022\017\n\007club_id\030\001 \001(\004\022(\n\006"
+    "marker\030\002 \001(\0132\030.bgs.protocol.ViewMarker\"\340"
+    "\002\n\020ClubStateOptions\022-\n\tattribute\030\001 \003(\0132\032"
+    ".bgs.protocol.v2.Attribute\022\014\n\004name\030\002 \001(\t"
+    "\022\023\n\013description\030\003 \001(\t\022<\n\tbroadcast\030\004 \001(\013"
+    "2).bgs.protocol.club.v1.SetBroadcastOpti"
+    "ons\022.\n\006avatar\030\005 \001(\0132\036.bgs.protocol.club."
+    "v1.AvatarId\0229\n\rprivacy_level\030\006 \001(\0162\".bgs"
+    ".protocol.club.v1.PrivacyLevel\022=\n\017stream"
+    "_position\030\007 \001(\0132$.bgs.protocol.club.v1.S"
+    "treamPosition\022\022\n\nshort_name\030\010 \001(\t\"\352\002\n\023Cl"
+    "ubStateAssignment\022\017\n\007club_id\030\001 \001(\004\022-\n\tat"
+    "tribute\030\002 \003(\0132\032.bgs.protocol.v2.Attribut"
+    "e\022\014\n\004name\030\003 \001(\t\022\023\n\013description\030\004 \001(\t\0222\n\t"
+    "broadcast\030\005 \001(\0132\037.bgs.protocol.club.v1.B"
+    "roadcast\022.\n\006avatar\030\006 \001(\0132\036.bgs.protocol."
+    "club.v1.AvatarId\0229\n\rprivacy_level\030\007 \001(\0162"
+    "\".bgs.protocol.club.v1.PrivacyLevel\022=\n\017s"
+    "tream_position\030\010 \001(\0132$.bgs.protocol.club"
+    ".v1.StreamPosition\022\022\n\nshort_name\030\t \001(\t\"c"
+    "\n\016StreamSettings\022\021\n\tstream_id\030\001 \001(\004\022>\n\006f"
+    "ilter\030\002 \001(\0162..bgs.protocol.club.v1.Strea"
+    "mNotificationFilter\"\233\001\n\014ClubSettings\0224\n\006"
+    "stream\030\001 \003(\0132$.bgs.protocol.club.v1.Stre"
+    "amSettings\022&\n\036stream_notification_filter"
+    "_all\030\002 \001(\010\022-\n\tattribute\030\003 \003(\0132\032.bgs.prot"
+    "ocol.v2.Attribute\"\226\001\n\023ClubSettingsOption"
+    "s\0228\n\006stream\030\001 \003(\0132$.bgs.protocol.club.v1"
+    ".StreamSettingsB\002\030\001\0224\n\010settings\030\002 \001(\0132\"."
+    "bgs.protocol.club.v1.ClubSettings\022\017\n\007ver"
+    "sion\030\003 \001(\r\"\210\001\n\026ClubSettingsAssignment\0228\n"
+    "\006stream\030\001 \003(\0132$.bgs.protocol.club.v1.Str"
+    "eamSettingsB\002\030\001\0224\n\010settings\030\002 \001(\0132\".bgs."
+    "protocol.club.v1.ClubSettingsB\002H\001", 3153);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_core.proto", &protobuf_RegisterTypes);
+  AvatarId::default_instance_ = new AvatarId();
+  SetBroadcastOptions::default_instance_ = new SetBroadcastOptions();
+  Broadcast::default_instance_ = new Broadcast();
+  UniqueClubType::default_instance_ = new UniqueClubType();
+  ClubCreateOptions::default_instance_ = new ClubCreateOptions();
+  Club::default_instance_ = new Club();
+  ClubDescription::default_instance_ = new ClubDescription();
+  ClubView::default_instance_ = new ClubView();
+  ClubStateOptions::default_instance_ = new ClubStateOptions();
+  ClubStateAssignment::default_instance_ = new ClubStateAssignment();
+  StreamSettings::default_instance_ = new StreamSettings();
+  ClubSettings::default_instance_ = new ClubSettings();
+  ClubSettingsOptions::default_instance_ = new ClubSettingsOptions();
+  ClubSettingsAssignment::default_instance_ = new ClubSettingsAssignment();
+  AvatarId::default_instance_->InitAsDefaultInstance();
+  SetBroadcastOptions::default_instance_->InitAsDefaultInstance();
+  Broadcast::default_instance_->InitAsDefaultInstance();
+  UniqueClubType::default_instance_->InitAsDefaultInstance();
+  ClubCreateOptions::default_instance_->InitAsDefaultInstance();
+  Club::default_instance_->InitAsDefaultInstance();
+  ClubDescription::default_instance_->InitAsDefaultInstance();
+  ClubView::default_instance_->InitAsDefaultInstance();
+  ClubStateOptions::default_instance_->InitAsDefaultInstance();
+  ClubStateAssignment::default_instance_->InitAsDefaultInstance();
+  StreamSettings::default_instance_->InitAsDefaultInstance();
+  ClubSettings::default_instance_->InitAsDefaultInstance();
+  ClubSettingsOptions::default_instance_->InitAsDefaultInstance();
+  ClubSettingsAssignment::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5fcore_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5fcore_2eproto {
+  StaticDescriptorInitializer_club_5fcore_2eproto() {
+    protobuf_AddDesc_club_5fcore_2eproto();
+  }
+} static_descriptor_initializer_club_5fcore_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AvatarId::kIdFieldNumber;
+#endif  // !_MSC_VER
+
+AvatarId::AvatarId()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.AvatarId)
+}
+
+void AvatarId::InitAsDefaultInstance() {
+}
+
+AvatarId::AvatarId(const AvatarId& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.AvatarId)
+}
+
+void AvatarId::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AvatarId::~AvatarId() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.AvatarId)
+  SharedDtor();
+}
+
+void AvatarId::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AvatarId::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AvatarId::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AvatarId_descriptor_;
+}
+
+const AvatarId& AvatarId::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+AvatarId* AvatarId::default_instance_ = NULL;
+
+AvatarId* AvatarId::New() const {
+  return new AvatarId;
+}
+
+void AvatarId::Clear() {
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AvatarId::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.AvatarId)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.AvatarId)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.AvatarId)
+  return false;
+#undef DO_
+}
+
+void AvatarId::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.AvatarId)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.AvatarId)
+}
+
+::google::protobuf::uint8* AvatarId::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.AvatarId)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.AvatarId)
+  return target;
+}
+
+int AvatarId::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AvatarId::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AvatarId* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AvatarId*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AvatarId::MergeFrom(const AvatarId& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AvatarId::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AvatarId::CopyFrom(const AvatarId& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AvatarId::IsInitialized() const {
+
+  return true;
+}
+
+void AvatarId::Swap(AvatarId* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AvatarId::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AvatarId_descriptor_;
+  metadata.reflection = AvatarId_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SetBroadcastOptions::kContentFieldNumber;
+#endif  // !_MSC_VER
+
+SetBroadcastOptions::SetBroadcastOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SetBroadcastOptions)
+}
+
+void SetBroadcastOptions::InitAsDefaultInstance() {
+}
+
+SetBroadcastOptions::SetBroadcastOptions(const SetBroadcastOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SetBroadcastOptions)
+}
+
+void SetBroadcastOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SetBroadcastOptions::~SetBroadcastOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SetBroadcastOptions)
+  SharedDtor();
+}
+
+void SetBroadcastOptions::SharedDtor() {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete content_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void SetBroadcastOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SetBroadcastOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SetBroadcastOptions_descriptor_;
+}
+
+const SetBroadcastOptions& SetBroadcastOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+SetBroadcastOptions* SetBroadcastOptions::default_instance_ = NULL;
+
+SetBroadcastOptions* SetBroadcastOptions::New() const {
+  return new SetBroadcastOptions;
+}
+
+void SetBroadcastOptions::Clear() {
+  if (has_content()) {
+    if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      content_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SetBroadcastOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SetBroadcastOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string content = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_content()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->content().data(), this->content().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "content");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SetBroadcastOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SetBroadcastOptions)
+  return false;
+#undef DO_
+}
+
+void SetBroadcastOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SetBroadcastOptions)
+  // optional string content = 1;
+  if (has_content()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->content().data(), this->content().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "content");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->content(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SetBroadcastOptions)
+}
+
+::google::protobuf::uint8* SetBroadcastOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SetBroadcastOptions)
+  // optional string content = 1;
+  if (has_content()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->content().data(), this->content().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "content");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->content(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SetBroadcastOptions)
+  return target;
+}
+
+int SetBroadcastOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string content = 1;
+    if (has_content()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->content());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SetBroadcastOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SetBroadcastOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SetBroadcastOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SetBroadcastOptions::MergeFrom(const SetBroadcastOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_content()) {
+      set_content(from.content());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SetBroadcastOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SetBroadcastOptions::CopyFrom(const SetBroadcastOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SetBroadcastOptions::IsInitialized() const {
+
+  return true;
+}
+
+void SetBroadcastOptions::Swap(SetBroadcastOptions* other) {
+  if (other != this) {
+    std::swap(content_, other->content_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SetBroadcastOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SetBroadcastOptions_descriptor_;
+  metadata.reflection = SetBroadcastOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Broadcast::kContentFieldNumber;
+const int Broadcast::kCreatorFieldNumber;
+const int Broadcast::kCreationTimeFieldNumber;
+#endif  // !_MSC_VER
+
+Broadcast::Broadcast()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.Broadcast)
+}
+
+void Broadcast::InitAsDefaultInstance() {
+  creator_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+}
+
+Broadcast::Broadcast(const Broadcast& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.Broadcast)
+}
+
+void Broadcast::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  creator_ = NULL;
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Broadcast::~Broadcast() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.Broadcast)
+  SharedDtor();
+}
+
+void Broadcast::SharedDtor() {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete content_;
+  }
+  if (this != default_instance_) {
+    delete creator_;
+  }
+}
+
+void Broadcast::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Broadcast::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Broadcast_descriptor_;
+}
+
+const Broadcast& Broadcast::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+Broadcast* Broadcast::default_instance_ = NULL;
+
+Broadcast* Broadcast::New() const {
+  return new Broadcast;
+}
+
+void Broadcast::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_content()) {
+      if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        content_->clear();
+      }
+    }
+    if (has_creator()) {
+      if (creator_ != NULL) creator_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+    creation_time_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Broadcast::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.Broadcast)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string content = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_content()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->content().data(), this->content().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "content");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_creator;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_creator:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_creator()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.Broadcast)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.Broadcast)
+  return false;
+#undef DO_
+}
+
+void Broadcast::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.Broadcast)
+  // optional string content = 1;
+  if (has_content()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->content().data(), this->content().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "content");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->content(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+  if (has_creator()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->creator(), output);
+  }
+
+  // optional uint64 creation_time = 3;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->creation_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.Broadcast)
+}
+
+::google::protobuf::uint8* Broadcast::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.Broadcast)
+  // optional string content = 1;
+  if (has_content()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->content().data(), this->content().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "content");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->content(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+  if (has_creator()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->creator(), target);
+  }
+
+  // optional uint64 creation_time = 3;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->creation_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.Broadcast)
+  return target;
+}
+
+int Broadcast::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string content = 1;
+    if (has_content()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->content());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+    if (has_creator()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->creator());
+    }
+
+    // optional uint64 creation_time = 3;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Broadcast::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Broadcast* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Broadcast*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Broadcast::MergeFrom(const Broadcast& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_content()) {
+      set_content(from.content());
+    }
+    if (from.has_creator()) {
+      mutable_creator()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.creator());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Broadcast::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Broadcast::CopyFrom(const Broadcast& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Broadcast::IsInitialized() const {
+
+  if (has_creator()) {
+    if (!this->creator().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Broadcast::Swap(Broadcast* other) {
+  if (other != this) {
+    std::swap(content_, other->content_);
+    std::swap(creator_, other->creator_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Broadcast::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Broadcast_descriptor_;
+  metadata.reflection = Broadcast_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UniqueClubType::kProgramFieldNumber;
+const int UniqueClubType::kNameFieldNumber;
+#endif  // !_MSC_VER
+
+UniqueClubType::UniqueClubType()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UniqueClubType)
+}
+
+void UniqueClubType::InitAsDefaultInstance() {
+}
+
+UniqueClubType::UniqueClubType(const UniqueClubType& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UniqueClubType)
+}
+
+void UniqueClubType::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  program_ = 0u;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UniqueClubType::~UniqueClubType() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UniqueClubType)
+  SharedDtor();
+}
+
+void UniqueClubType::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void UniqueClubType::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UniqueClubType::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UniqueClubType_descriptor_;
+}
+
+const UniqueClubType& UniqueClubType::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+UniqueClubType* UniqueClubType::default_instance_ = NULL;
+
+UniqueClubType* UniqueClubType::New() const {
+  return new UniqueClubType;
+}
+
+void UniqueClubType::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    program_ = 0u;
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UniqueClubType::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UniqueClubType)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed32 program = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UniqueClubType)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UniqueClubType)
+  return false;
+#undef DO_
+}
+
+void UniqueClubType::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UniqueClubType)
+  // optional fixed32 program = 1;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->name(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UniqueClubType)
+}
+
+::google::protobuf::uint8* UniqueClubType::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UniqueClubType)
+  // optional fixed32 program = 1;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UniqueClubType)
+  return target;
+}
+
+int UniqueClubType::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed32 program = 1;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional string name = 2;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UniqueClubType::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UniqueClubType* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UniqueClubType*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UniqueClubType::MergeFrom(const UniqueClubType& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UniqueClubType::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UniqueClubType::CopyFrom(const UniqueClubType& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UniqueClubType::IsInitialized() const {
+
+  return true;
+}
+
+void UniqueClubType::Swap(UniqueClubType* other) {
+  if (other != this) {
+    std::swap(program_, other->program_);
+    std::swap(name_, other->name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UniqueClubType::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UniqueClubType_descriptor_;
+  metadata.reflection = UniqueClubType_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubCreateOptions::kTypeFieldNumber;
+const int ClubCreateOptions::kAttributeFieldNumber;
+const int ClubCreateOptions::kNameFieldNumber;
+const int ClubCreateOptions::kDescriptionFieldNumber;
+const int ClubCreateOptions::kAvatarFieldNumber;
+const int ClubCreateOptions::kPrivacyLevelFieldNumber;
+const int ClubCreateOptions::kShortNameFieldNumber;
+const int ClubCreateOptions::kMemberFieldNumber;
+const int ClubCreateOptions::kStreamFieldNumber;
+#endif  // !_MSC_VER
+
+ClubCreateOptions::ClubCreateOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubCreateOptions)
+}
+
+void ClubCreateOptions::InitAsDefaultInstance() {
+  type_ = const_cast< ::bgs::protocol::club::v1::UniqueClubType*>(&::bgs::protocol::club::v1::UniqueClubType::default_instance());
+  avatar_ = const_cast< ::bgs::protocol::club::v1::AvatarId*>(&::bgs::protocol::club::v1::AvatarId::default_instance());
+  member_ = const_cast< ::bgs::protocol::club::v1::CreateMemberOptions*>(&::bgs::protocol::club::v1::CreateMemberOptions::default_instance());
+  stream_ = const_cast< ::bgs::protocol::club::v1::CreateStreamOptions*>(&::bgs::protocol::club::v1::CreateStreamOptions::default_instance());
+}
+
+ClubCreateOptions::ClubCreateOptions(const ClubCreateOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubCreateOptions)
+}
+
+void ClubCreateOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  type_ = NULL;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  avatar_ = NULL;
+  privacy_level_ = 0;
+  short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  member_ = NULL;
+  stream_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubCreateOptions::~ClubCreateOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubCreateOptions)
+  SharedDtor();
+}
+
+void ClubCreateOptions::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete short_name_;
+  }
+  if (this != default_instance_) {
+    delete type_;
+    delete avatar_;
+    delete member_;
+    delete stream_;
+  }
+}
+
+void ClubCreateOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubCreateOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubCreateOptions_descriptor_;
+}
+
+const ClubCreateOptions& ClubCreateOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+ClubCreateOptions* ClubCreateOptions::default_instance_ = NULL;
+
+ClubCreateOptions* ClubCreateOptions::New() const {
+  return new ClubCreateOptions;
+}
+
+void ClubCreateOptions::Clear() {
+  if (_has_bits_[0 / 32] & 253) {
+    if (has_type()) {
+      if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+    }
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_description()) {
+      if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        description_->clear();
+      }
+    }
+    if (has_avatar()) {
+      if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+    }
+    privacy_level_ = 0;
+    if (has_short_name()) {
+      if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        short_name_->clear();
+      }
+    }
+    if (has_member()) {
+      if (member_ != NULL) member_->::bgs::protocol::club::v1::CreateMemberOptions::Clear();
+    }
+  }
+  if (has_stream()) {
+    if (stream_ != NULL) stream_->::bgs::protocol::club::v1::CreateStreamOptions::Clear();
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubCreateOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubCreateOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_type()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectTag(26)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_description;
+        break;
+      }
+
+      // optional string description = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_description()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->description().data(), this->description().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "description");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_avatar;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_avatar:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_avatar()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_privacy_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_privacy_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::PrivacyLevel_IsValid(value)) {
+            set_privacy_level(static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(6, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_short_name;
+        break;
+      }
+
+      // optional string short_name = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_short_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_short_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->short_name().data(), this->short_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "short_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_member;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.CreateMemberOptions member = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_member:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(90)) goto parse_stream;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.CreateStreamOptions stream = 11;
+      case 11: {
+        if (tag == 90) {
+         parse_stream:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_stream()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubCreateOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubCreateOptions)
+  return false;
+#undef DO_
+}
+
+void ClubCreateOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubCreateOptions)
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->type(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->name(), output);
+  }
+
+  // optional string description = 4;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->description(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+  if (has_avatar()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->avatar(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+  if (has_privacy_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->privacy_level(), output);
+  }
+
+  // optional string short_name = 7;
+  if (has_short_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->short_name().data(), this->short_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "short_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      7, this->short_name(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateMemberOptions member = 10;
+  if (has_member()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->member(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateStreamOptions stream = 11;
+  if (has_stream()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      11, this->stream(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubCreateOptions)
+}
+
+::google::protobuf::uint8* ClubCreateOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubCreateOptions)
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->type(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->name(), target);
+  }
+
+  // optional string description = 4;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->description(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+  if (has_avatar()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->avatar(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+  if (has_privacy_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      6, this->privacy_level(), target);
+  }
+
+  // optional string short_name = 7;
+  if (has_short_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->short_name().data(), this->short_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "short_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        7, this->short_name(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateMemberOptions member = 10;
+  if (has_member()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->member(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateStreamOptions stream = 11;
+  if (has_stream()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        11, this->stream(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubCreateOptions)
+  return target;
+}
+
+int ClubCreateOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->type());
+    }
+
+    // optional string name = 3;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string description = 4;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->description());
+    }
+
+    // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+    if (has_avatar()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->avatar());
+    }
+
+    // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+    if (has_privacy_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->privacy_level());
+    }
+
+    // optional string short_name = 7;
+    if (has_short_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->short_name());
+    }
+
+    // optional .bgs.protocol.club.v1.CreateMemberOptions member = 10;
+    if (has_member()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional .bgs.protocol.club.v1.CreateStreamOptions stream = 11;
+    if (has_stream()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->stream());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubCreateOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubCreateOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubCreateOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubCreateOptions::MergeFrom(const ClubCreateOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_type()) {
+      mutable_type()->::bgs::protocol::club::v1::UniqueClubType::MergeFrom(from.type());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_description()) {
+      set_description(from.description());
+    }
+    if (from.has_avatar()) {
+      mutable_avatar()->::bgs::protocol::club::v1::AvatarId::MergeFrom(from.avatar());
+    }
+    if (from.has_privacy_level()) {
+      set_privacy_level(from.privacy_level());
+    }
+    if (from.has_short_name()) {
+      set_short_name(from.short_name());
+    }
+    if (from.has_member()) {
+      mutable_member()->::bgs::protocol::club::v1::CreateMemberOptions::MergeFrom(from.member());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_stream()) {
+      mutable_stream()->::bgs::protocol::club::v1::CreateStreamOptions::MergeFrom(from.stream());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubCreateOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubCreateOptions::CopyFrom(const ClubCreateOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubCreateOptions::IsInitialized() const {
+
+  if (has_member()) {
+    if (!this->member().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubCreateOptions::Swap(ClubCreateOptions* other) {
+  if (other != this) {
+    std::swap(type_, other->type_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(name_, other->name_);
+    std::swap(description_, other->description_);
+    std::swap(avatar_, other->avatar_);
+    std::swap(privacy_level_, other->privacy_level_);
+    std::swap(short_name_, other->short_name_);
+    std::swap(member_, other->member_);
+    std::swap(stream_, other->stream_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubCreateOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubCreateOptions_descriptor_;
+  metadata.reflection = ClubCreateOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Club::kIdFieldNumber;
+const int Club::kTypeFieldNumber;
+const int Club::kAttributeFieldNumber;
+const int Club::kNameFieldNumber;
+const int Club::kDescriptionFieldNumber;
+const int Club::kBroadcastFieldNumber;
+const int Club::kAvatarFieldNumber;
+const int Club::kPrivacyLevelFieldNumber;
+const int Club::kVisibilityLevelFieldNumber;
+const int Club::kMemberCountFieldNumber;
+const int Club::kCreationTimeFieldNumber;
+const int Club::kStreamPositionFieldNumber;
+const int Club::kRoleSetFieldNumber;
+const int Club::kLeaderFieldNumber;
+const int Club::kShortNameFieldNumber;
+#endif  // !_MSC_VER
+
+Club::Club()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.Club)
+}
+
+void Club::InitAsDefaultInstance() {
+  type_ = const_cast< ::bgs::protocol::club::v1::UniqueClubType*>(&::bgs::protocol::club::v1::UniqueClubType::default_instance());
+  broadcast_ = const_cast< ::bgs::protocol::club::v1::Broadcast*>(&::bgs::protocol::club::v1::Broadcast::default_instance());
+  avatar_ = const_cast< ::bgs::protocol::club::v1::AvatarId*>(&::bgs::protocol::club::v1::AvatarId::default_instance());
+  stream_position_ = const_cast< ::bgs::protocol::club::v1::StreamPosition*>(&::bgs::protocol::club::v1::StreamPosition::default_instance());
+  role_set_ = const_cast< ::bgs::protocol::club::v1::ClubRoleSet*>(&::bgs::protocol::club::v1::ClubRoleSet::default_instance());
+}
+
+Club::Club(const Club& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.Club)
+}
+
+void Club::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = GOOGLE_ULONGLONG(0);
+  type_ = NULL;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  broadcast_ = NULL;
+  avatar_ = NULL;
+  privacy_level_ = 0;
+  visibility_level_ = 0;
+  member_count_ = 0u;
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  stream_position_ = NULL;
+  role_set_ = NULL;
+  short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Club::~Club() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.Club)
+  SharedDtor();
+}
+
+void Club::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete short_name_;
+  }
+  if (this != default_instance_) {
+    delete type_;
+    delete broadcast_;
+    delete avatar_;
+    delete stream_position_;
+    delete role_set_;
+  }
+}
+
+void Club::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Club::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Club_descriptor_;
+}
+
+const Club& Club::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+Club* Club::default_instance_ = NULL;
+
+Club* Club::New() const {
+  return new Club;
+}
+
+void Club::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Club*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 251) {
+    id_ = GOOGLE_ULONGLONG(0);
+    if (has_type()) {
+      if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+    }
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_description()) {
+      if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        description_->clear();
+      }
+    }
+    if (has_broadcast()) {
+      if (broadcast_ != NULL) broadcast_->::bgs::protocol::club::v1::Broadcast::Clear();
+    }
+    if (has_avatar()) {
+      if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+    }
+    privacy_level_ = 0;
+  }
+  if (_has_bits_[8 / 32] & 24320) {
+    ZR_(visibility_level_, creation_time_);
+    member_count_ = 0u;
+    if (has_stream_position()) {
+      if (stream_position_ != NULL) stream_position_->::bgs::protocol::club::v1::StreamPosition::Clear();
+    }
+    if (has_role_set()) {
+      if (role_set_ != NULL) role_set_->::bgs::protocol::club::v1::ClubRoleSet::Clear();
+    }
+    if (has_short_name()) {
+      if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        short_name_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  leader_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Club::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.Club)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_type;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_type()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        if (input->ExpectTag(34)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_description;
+        break;
+      }
+
+      // optional string description = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_description()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->description().data(), this->description().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "description");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_broadcast;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.Broadcast broadcast = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_broadcast:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_broadcast()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_avatar;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.AvatarId avatar = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_avatar:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_avatar()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_privacy_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_privacy_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::PrivacyLevel_IsValid(value)) {
+            set_privacy_level(static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(8, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_visibility_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_visibility_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::VisibilityLevel_IsValid(value)) {
+            set_visibility_level(static_cast< ::bgs::protocol::club::v1::VisibilityLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(9, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_member_count;
+        break;
+      }
+
+      // optional uint32 member_count = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_member_count:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &member_count_)));
+          set_has_member_count();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(88)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 11;
+      case 11: {
+        if (tag == 88) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(98)) goto parse_stream_position;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamPosition stream_position = 12;
+      case 12: {
+        if (tag == 98) {
+         parse_stream_position:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_stream_position()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(106)) goto parse_role_set;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 13;
+      case 13: {
+        if (tag == 106) {
+         parse_role_set:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_role_set()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(114)) goto parse_leader;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.MemberDescription leader = 14;
+      case 14: {
+        if (tag == 114) {
+         parse_leader:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_leader()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(114)) goto parse_leader;
+        if (input->ExpectTag(122)) goto parse_short_name;
+        break;
+      }
+
+      // optional string short_name = 15;
+      case 15: {
+        if (tag == 122) {
+         parse_short_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_short_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->short_name().data(), this->short_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "short_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.Club)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.Club)
+  return false;
+#undef DO_
+}
+
+void Club::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.Club)
+  // optional uint64 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->type(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->attribute(i), output);
+  }
+
+  // optional string name = 4;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->name(), output);
+  }
+
+  // optional string description = 5;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->description(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.Broadcast broadcast = 6;
+  if (has_broadcast()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->broadcast(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 7;
+  if (has_avatar()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->avatar(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 8;
+  if (has_privacy_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      8, this->privacy_level(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 9;
+  if (has_visibility_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      9, this->visibility_level(), output);
+  }
+
+  // optional uint32 member_count = 10;
+  if (has_member_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->member_count(), output);
+  }
+
+  // optional uint64 creation_time = 11;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(11, this->creation_time(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamPosition stream_position = 12;
+  if (has_stream_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      12, this->stream_position(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 13;
+  if (has_role_set()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      13, this->role_set(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberDescription leader = 14;
+  for (int i = 0; i < this->leader_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      14, this->leader(i), output);
+  }
+
+  // optional string short_name = 15;
+  if (has_short_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->short_name().data(), this->short_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "short_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      15, this->short_name(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.Club)
+}
+
+::google::protobuf::uint8* Club::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.Club)
+  // optional uint64 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->type(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->attribute(i), target);
+  }
+
+  // optional string name = 4;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->name(), target);
+  }
+
+  // optional string description = 5;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->description(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.Broadcast broadcast = 6;
+  if (has_broadcast()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->broadcast(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 7;
+  if (has_avatar()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->avatar(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 8;
+  if (has_privacy_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      8, this->privacy_level(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 9;
+  if (has_visibility_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      9, this->visibility_level(), target);
+  }
+
+  // optional uint32 member_count = 10;
+  if (has_member_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->member_count(), target);
+  }
+
+  // optional uint64 creation_time = 11;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(11, this->creation_time(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamPosition stream_position = 12;
+  if (has_stream_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        12, this->stream_position(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 13;
+  if (has_role_set()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        13, this->role_set(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberDescription leader = 14;
+  for (int i = 0; i < this->leader_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        14, this->leader(i), target);
+  }
+
+  // optional string short_name = 15;
+  if (has_short_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->short_name().data(), this->short_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "short_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        15, this->short_name(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.Club)
+  return target;
+}
+
+int Club::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->id());
+    }
+
+    // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->type());
+    }
+
+    // optional string name = 4;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string description = 5;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->description());
+    }
+
+    // optional .bgs.protocol.club.v1.Broadcast broadcast = 6;
+    if (has_broadcast()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->broadcast());
+    }
+
+    // optional .bgs.protocol.club.v1.AvatarId avatar = 7;
+    if (has_avatar()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->avatar());
+    }
+
+    // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 8;
+    if (has_privacy_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->privacy_level());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 9;
+    if (has_visibility_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->visibility_level());
+    }
+
+    // optional uint32 member_count = 10;
+    if (has_member_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->member_count());
+    }
+
+    // optional uint64 creation_time = 11;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamPosition stream_position = 12;
+    if (has_stream_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->stream_position());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 13;
+    if (has_role_set()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->role_set());
+    }
+
+    // optional string short_name = 15;
+    if (has_short_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->short_name());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberDescription leader = 14;
+  total_size += 1 * this->leader_size();
+  for (int i = 0; i < this->leader_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->leader(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Club::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Club* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Club*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Club::MergeFrom(const Club& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  leader_.MergeFrom(from.leader_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_type()) {
+      mutable_type()->::bgs::protocol::club::v1::UniqueClubType::MergeFrom(from.type());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_description()) {
+      set_description(from.description());
+    }
+    if (from.has_broadcast()) {
+      mutable_broadcast()->::bgs::protocol::club::v1::Broadcast::MergeFrom(from.broadcast());
+    }
+    if (from.has_avatar()) {
+      mutable_avatar()->::bgs::protocol::club::v1::AvatarId::MergeFrom(from.avatar());
+    }
+    if (from.has_privacy_level()) {
+      set_privacy_level(from.privacy_level());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_visibility_level()) {
+      set_visibility_level(from.visibility_level());
+    }
+    if (from.has_member_count()) {
+      set_member_count(from.member_count());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+    if (from.has_stream_position()) {
+      mutable_stream_position()->::bgs::protocol::club::v1::StreamPosition::MergeFrom(from.stream_position());
+    }
+    if (from.has_role_set()) {
+      mutable_role_set()->::bgs::protocol::club::v1::ClubRoleSet::MergeFrom(from.role_set());
+    }
+    if (from.has_short_name()) {
+      set_short_name(from.short_name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Club::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Club::CopyFrom(const Club& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Club::IsInitialized() const {
+
+  if (has_broadcast()) {
+    if (!this->broadcast().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->leader())) return false;
+  return true;
+}
+
+void Club::Swap(Club* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(type_, other->type_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(name_, other->name_);
+    std::swap(description_, other->description_);
+    std::swap(broadcast_, other->broadcast_);
+    std::swap(avatar_, other->avatar_);
+    std::swap(privacy_level_, other->privacy_level_);
+    std::swap(visibility_level_, other->visibility_level_);
+    std::swap(member_count_, other->member_count_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(stream_position_, other->stream_position_);
+    std::swap(role_set_, other->role_set_);
+    leader_.Swap(&other->leader_);
+    std::swap(short_name_, other->short_name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Club::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Club_descriptor_;
+  metadata.reflection = Club_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubDescription::kIdFieldNumber;
+const int ClubDescription::kTypeFieldNumber;
+const int ClubDescription::kNameFieldNumber;
+const int ClubDescription::kDescriptionFieldNumber;
+const int ClubDescription::kAvatarFieldNumber;
+const int ClubDescription::kPrivacyLevelFieldNumber;
+const int ClubDescription::kVisibilityLevelFieldNumber;
+const int ClubDescription::kMemberCountFieldNumber;
+const int ClubDescription::kLeaderFieldNumber;
+const int ClubDescription::kCreationTimeFieldNumber;
+#endif  // !_MSC_VER
+
+ClubDescription::ClubDescription()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubDescription)
+}
+
+void ClubDescription::InitAsDefaultInstance() {
+  type_ = const_cast< ::bgs::protocol::club::v1::UniqueClubType*>(&::bgs::protocol::club::v1::UniqueClubType::default_instance());
+  avatar_ = const_cast< ::bgs::protocol::club::v1::AvatarId*>(&::bgs::protocol::club::v1::AvatarId::default_instance());
+}
+
+ClubDescription::ClubDescription(const ClubDescription& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubDescription)
+}
+
+void ClubDescription::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = GOOGLE_ULONGLONG(0);
+  type_ = NULL;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  avatar_ = NULL;
+  privacy_level_ = 0;
+  visibility_level_ = 0;
+  member_count_ = 0u;
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubDescription::~ClubDescription() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubDescription)
+  SharedDtor();
+}
+
+void ClubDescription::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (this != default_instance_) {
+    delete type_;
+    delete avatar_;
+  }
+}
+
+void ClubDescription::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubDescription::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubDescription_descriptor_;
+}
+
+const ClubDescription& ClubDescription::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+ClubDescription* ClubDescription::default_instance_ = NULL;
+
+ClubDescription* ClubDescription::New() const {
+  return new ClubDescription;
+}
+
+void ClubDescription::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClubDescription*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(privacy_level_, visibility_level_);
+    id_ = GOOGLE_ULONGLONG(0);
+    if (has_type()) {
+      if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+    }
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_description()) {
+      if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        description_->clear();
+      }
+    }
+    if (has_avatar()) {
+      if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+    }
+    member_count_ = 0u;
+  }
+  creation_time_ = GOOGLE_ULONGLONG(0);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  leader_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubDescription::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubDescription)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_type;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_type()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_description;
+        break;
+      }
+
+      // optional string description = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_description()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->description().data(), this->description().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "description");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_avatar;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_avatar:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_avatar()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_privacy_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_privacy_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::PrivacyLevel_IsValid(value)) {
+            set_privacy_level(static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(6, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_visibility_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_visibility_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::VisibilityLevel_IsValid(value)) {
+            set_visibility_level(static_cast< ::bgs::protocol::club::v1::VisibilityLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(7, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_member_count;
+        break;
+      }
+
+      // optional uint32 member_count = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_member_count:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &member_count_)));
+          set_has_member_count();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_leader;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.MemberDescription leader = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_leader:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_leader()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_leader;
+        if (input->ExpectTag(80)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubDescription)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubDescription)
+  return false;
+#undef DO_
+}
+
+void ClubDescription::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubDescription)
+  // optional uint64 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->type(), output);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->name(), output);
+  }
+
+  // optional string description = 4;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->description(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+  if (has_avatar()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->avatar(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+  if (has_privacy_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->privacy_level(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 7;
+  if (has_visibility_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      7, this->visibility_level(), output);
+  }
+
+  // optional uint32 member_count = 8;
+  if (has_member_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->member_count(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberDescription leader = 9;
+  for (int i = 0; i < this->leader_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      9, this->leader(i), output);
+  }
+
+  // optional uint64 creation_time = 10;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(10, this->creation_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubDescription)
+}
+
+::google::protobuf::uint8* ClubDescription::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubDescription)
+  // optional uint64 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->type(), target);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->name(), target);
+  }
+
+  // optional string description = 4;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->description(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+  if (has_avatar()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->avatar(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+  if (has_privacy_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      6, this->privacy_level(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 7;
+  if (has_visibility_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      7, this->visibility_level(), target);
+  }
+
+  // optional uint32 member_count = 8;
+  if (has_member_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->member_count(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberDescription leader = 9;
+  for (int i = 0; i < this->leader_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        9, this->leader(i), target);
+  }
+
+  // optional uint64 creation_time = 10;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(10, this->creation_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubDescription)
+  return target;
+}
+
+int ClubDescription::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->id());
+    }
+
+    // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->type());
+    }
+
+    // optional string name = 3;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string description = 4;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->description());
+    }
+
+    // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+    if (has_avatar()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->avatar());
+    }
+
+    // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+    if (has_privacy_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->privacy_level());
+    }
+
+    // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 7;
+    if (has_visibility_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->visibility_level());
+    }
+
+    // optional uint32 member_count = 8;
+    if (has_member_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->member_count());
+    }
+
+  }
+  if (_has_bits_[9 / 32] & (0xffu << (9 % 32))) {
+    // optional uint64 creation_time = 10;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.MemberDescription leader = 9;
+  total_size += 1 * this->leader_size();
+  for (int i = 0; i < this->leader_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->leader(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubDescription::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubDescription* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubDescription*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubDescription::MergeFrom(const ClubDescription& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  leader_.MergeFrom(from.leader_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_type()) {
+      mutable_type()->::bgs::protocol::club::v1::UniqueClubType::MergeFrom(from.type());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_description()) {
+      set_description(from.description());
+    }
+    if (from.has_avatar()) {
+      mutable_avatar()->::bgs::protocol::club::v1::AvatarId::MergeFrom(from.avatar());
+    }
+    if (from.has_privacy_level()) {
+      set_privacy_level(from.privacy_level());
+    }
+    if (from.has_visibility_level()) {
+      set_visibility_level(from.visibility_level());
+    }
+    if (from.has_member_count()) {
+      set_member_count(from.member_count());
+    }
+  }
+  if (from._has_bits_[9 / 32] & (0xffu << (9 % 32))) {
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubDescription::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubDescription::CopyFrom(const ClubDescription& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubDescription::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->leader())) return false;
+  return true;
+}
+
+void ClubDescription::Swap(ClubDescription* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(type_, other->type_);
+    std::swap(name_, other->name_);
+    std::swap(description_, other->description_);
+    std::swap(avatar_, other->avatar_);
+    std::swap(privacy_level_, other->privacy_level_);
+    std::swap(visibility_level_, other->visibility_level_);
+    std::swap(member_count_, other->member_count_);
+    leader_.Swap(&other->leader_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubDescription::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubDescription_descriptor_;
+  metadata.reflection = ClubDescription_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubView::kClubIdFieldNumber;
+const int ClubView::kMarkerFieldNumber;
+#endif  // !_MSC_VER
+
+ClubView::ClubView()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubView)
+}
+
+void ClubView::InitAsDefaultInstance() {
+  marker_ = const_cast< ::bgs::protocol::ViewMarker*>(&::bgs::protocol::ViewMarker::default_instance());
+}
+
+ClubView::ClubView(const ClubView& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubView)
+}
+
+void ClubView::SharedCtor() {
+  _cached_size_ = 0;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  marker_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubView::~ClubView() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubView)
+  SharedDtor();
+}
+
+void ClubView::SharedDtor() {
+  if (this != default_instance_) {
+    delete marker_;
+  }
+}
+
+void ClubView::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubView::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubView_descriptor_;
+}
+
+const ClubView& ClubView::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+ClubView* ClubView::default_instance_ = NULL;
+
+ClubView* ClubView::New() const {
+  return new ClubView;
+}
+
+void ClubView::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_marker()) {
+      if (marker_ != NULL) marker_->::bgs::protocol::ViewMarker::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubView::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubView)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 club_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_marker;
+        break;
+      }
+
+      // optional .bgs.protocol.ViewMarker marker = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_marker:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_marker()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubView)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubView)
+  return false;
+#undef DO_
+}
+
+void ClubView::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubView)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.ViewMarker marker = 2;
+  if (has_marker()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->marker(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubView)
+}
+
+::google::protobuf::uint8* ClubView::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubView)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.ViewMarker marker = 2;
+  if (has_marker()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->marker(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubView)
+  return target;
+}
+
+int ClubView::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 club_id = 1;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.ViewMarker marker = 2;
+    if (has_marker()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->marker());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubView::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubView* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubView*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubView::MergeFrom(const ClubView& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_marker()) {
+      mutable_marker()->::bgs::protocol::ViewMarker::MergeFrom(from.marker());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubView::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubView::CopyFrom(const ClubView& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubView::IsInitialized() const {
+
+  return true;
+}
+
+void ClubView::Swap(ClubView* other) {
+  if (other != this) {
+    std::swap(club_id_, other->club_id_);
+    std::swap(marker_, other->marker_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubView::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubView_descriptor_;
+  metadata.reflection = ClubView_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubStateOptions::kAttributeFieldNumber;
+const int ClubStateOptions::kNameFieldNumber;
+const int ClubStateOptions::kDescriptionFieldNumber;
+const int ClubStateOptions::kBroadcastFieldNumber;
+const int ClubStateOptions::kAvatarFieldNumber;
+const int ClubStateOptions::kPrivacyLevelFieldNumber;
+const int ClubStateOptions::kStreamPositionFieldNumber;
+const int ClubStateOptions::kShortNameFieldNumber;
+#endif  // !_MSC_VER
+
+ClubStateOptions::ClubStateOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubStateOptions)
+}
+
+void ClubStateOptions::InitAsDefaultInstance() {
+  broadcast_ = const_cast< ::bgs::protocol::club::v1::SetBroadcastOptions*>(&::bgs::protocol::club::v1::SetBroadcastOptions::default_instance());
+  avatar_ = const_cast< ::bgs::protocol::club::v1::AvatarId*>(&::bgs::protocol::club::v1::AvatarId::default_instance());
+  stream_position_ = const_cast< ::bgs::protocol::club::v1::StreamPosition*>(&::bgs::protocol::club::v1::StreamPosition::default_instance());
+}
+
+ClubStateOptions::ClubStateOptions(const ClubStateOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubStateOptions)
+}
+
+void ClubStateOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  broadcast_ = NULL;
+  avatar_ = NULL;
+  privacy_level_ = 0;
+  stream_position_ = NULL;
+  short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubStateOptions::~ClubStateOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubStateOptions)
+  SharedDtor();
+}
+
+void ClubStateOptions::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete short_name_;
+  }
+  if (this != default_instance_) {
+    delete broadcast_;
+    delete avatar_;
+    delete stream_position_;
+  }
+}
+
+void ClubStateOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubStateOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubStateOptions_descriptor_;
+}
+
+const ClubStateOptions& ClubStateOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+ClubStateOptions* ClubStateOptions::default_instance_ = NULL;
+
+ClubStateOptions* ClubStateOptions::New() const {
+  return new ClubStateOptions;
+}
+
+void ClubStateOptions::Clear() {
+  if (_has_bits_[0 / 32] & 254) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_description()) {
+      if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        description_->clear();
+      }
+    }
+    if (has_broadcast()) {
+      if (broadcast_ != NULL) broadcast_->::bgs::protocol::club::v1::SetBroadcastOptions::Clear();
+    }
+    if (has_avatar()) {
+      if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+    }
+    privacy_level_ = 0;
+    if (has_stream_position()) {
+      if (stream_position_ != NULL) stream_position_->::bgs::protocol::club::v1::StreamPosition::Clear();
+    }
+    if (has_short_name()) {
+      if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        short_name_->clear();
+      }
+    }
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubStateOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubStateOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.v2.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectTag(18)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_description;
+        break;
+      }
+
+      // optional string description = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_description()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->description().data(), this->description().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "description");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_broadcast;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.SetBroadcastOptions broadcast = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_broadcast:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_broadcast()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_avatar;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_avatar:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_avatar()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_privacy_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_privacy_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::PrivacyLevel_IsValid(value)) {
+            set_privacy_level(static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(6, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_stream_position;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamPosition stream_position = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_stream_position:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_stream_position()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_short_name;
+        break;
+      }
+
+      // optional string short_name = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_short_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_short_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->short_name().data(), this->short_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "short_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubStateOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubStateOptions)
+  return false;
+#undef DO_
+}
+
+void ClubStateOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubStateOptions)
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->name(), output);
+  }
+
+  // optional string description = 3;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->description(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.SetBroadcastOptions broadcast = 4;
+  if (has_broadcast()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->broadcast(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+  if (has_avatar()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->avatar(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+  if (has_privacy_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->privacy_level(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamPosition stream_position = 7;
+  if (has_stream_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->stream_position(), output);
+  }
+
+  // optional string short_name = 8;
+  if (has_short_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->short_name().data(), this->short_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "short_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      8, this->short_name(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubStateOptions)
+}
+
+::google::protobuf::uint8* ClubStateOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubStateOptions)
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+
+  // optional string description = 3;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->description(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.SetBroadcastOptions broadcast = 4;
+  if (has_broadcast()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->broadcast(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+  if (has_avatar()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->avatar(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+  if (has_privacy_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      6, this->privacy_level(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamPosition stream_position = 7;
+  if (has_stream_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->stream_position(), target);
+  }
+
+  // optional string short_name = 8;
+  if (has_short_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->short_name().data(), this->short_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "short_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->short_name(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubStateOptions)
+  return target;
+}
+
+int ClubStateOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional string name = 2;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string description = 3;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->description());
+    }
+
+    // optional .bgs.protocol.club.v1.SetBroadcastOptions broadcast = 4;
+    if (has_broadcast()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->broadcast());
+    }
+
+    // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+    if (has_avatar()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->avatar());
+    }
+
+    // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+    if (has_privacy_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->privacy_level());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamPosition stream_position = 7;
+    if (has_stream_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->stream_position());
+    }
+
+    // optional string short_name = 8;
+    if (has_short_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->short_name());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubStateOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubStateOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubStateOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubStateOptions::MergeFrom(const ClubStateOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_description()) {
+      set_description(from.description());
+    }
+    if (from.has_broadcast()) {
+      mutable_broadcast()->::bgs::protocol::club::v1::SetBroadcastOptions::MergeFrom(from.broadcast());
+    }
+    if (from.has_avatar()) {
+      mutable_avatar()->::bgs::protocol::club::v1::AvatarId::MergeFrom(from.avatar());
+    }
+    if (from.has_privacy_level()) {
+      set_privacy_level(from.privacy_level());
+    }
+    if (from.has_stream_position()) {
+      mutable_stream_position()->::bgs::protocol::club::v1::StreamPosition::MergeFrom(from.stream_position());
+    }
+    if (from.has_short_name()) {
+      set_short_name(from.short_name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubStateOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubStateOptions::CopyFrom(const ClubStateOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubStateOptions::IsInitialized() const {
+
+  return true;
+}
+
+void ClubStateOptions::Swap(ClubStateOptions* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    std::swap(name_, other->name_);
+    std::swap(description_, other->description_);
+    std::swap(broadcast_, other->broadcast_);
+    std::swap(avatar_, other->avatar_);
+    std::swap(privacy_level_, other->privacy_level_);
+    std::swap(stream_position_, other->stream_position_);
+    std::swap(short_name_, other->short_name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubStateOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubStateOptions_descriptor_;
+  metadata.reflection = ClubStateOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubStateAssignment::kClubIdFieldNumber;
+const int ClubStateAssignment::kAttributeFieldNumber;
+const int ClubStateAssignment::kNameFieldNumber;
+const int ClubStateAssignment::kDescriptionFieldNumber;
+const int ClubStateAssignment::kBroadcastFieldNumber;
+const int ClubStateAssignment::kAvatarFieldNumber;
+const int ClubStateAssignment::kPrivacyLevelFieldNumber;
+const int ClubStateAssignment::kStreamPositionFieldNumber;
+const int ClubStateAssignment::kShortNameFieldNumber;
+#endif  // !_MSC_VER
+
+ClubStateAssignment::ClubStateAssignment()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubStateAssignment)
+}
+
+void ClubStateAssignment::InitAsDefaultInstance() {
+  broadcast_ = const_cast< ::bgs::protocol::club::v1::Broadcast*>(&::bgs::protocol::club::v1::Broadcast::default_instance());
+  avatar_ = const_cast< ::bgs::protocol::club::v1::AvatarId*>(&::bgs::protocol::club::v1::AvatarId::default_instance());
+  stream_position_ = const_cast< ::bgs::protocol::club::v1::StreamPosition*>(&::bgs::protocol::club::v1::StreamPosition::default_instance());
+}
+
+ClubStateAssignment::ClubStateAssignment(const ClubStateAssignment& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubStateAssignment)
+}
+
+void ClubStateAssignment::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  broadcast_ = NULL;
+  avatar_ = NULL;
+  privacy_level_ = 0;
+  stream_position_ = NULL;
+  short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubStateAssignment::~ClubStateAssignment() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubStateAssignment)
+  SharedDtor();
+}
+
+void ClubStateAssignment::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete short_name_;
+  }
+  if (this != default_instance_) {
+    delete broadcast_;
+    delete avatar_;
+    delete stream_position_;
+  }
+}
+
+void ClubStateAssignment::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubStateAssignment::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubStateAssignment_descriptor_;
+}
+
+const ClubStateAssignment& ClubStateAssignment::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+ClubStateAssignment* ClubStateAssignment::default_instance_ = NULL;
+
+ClubStateAssignment* ClubStateAssignment::New() const {
+  return new ClubStateAssignment;
+}
+
+void ClubStateAssignment::Clear() {
+  if (_has_bits_[0 / 32] & 253) {
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_description()) {
+      if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        description_->clear();
+      }
+    }
+    if (has_broadcast()) {
+      if (broadcast_ != NULL) broadcast_->::bgs::protocol::club::v1::Broadcast::Clear();
+    }
+    if (has_avatar()) {
+      if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+    }
+    privacy_level_ = 0;
+    if (has_stream_position()) {
+      if (stream_position_ != NULL) stream_position_->::bgs::protocol::club::v1::StreamPosition::Clear();
+    }
+  }
+  if (has_short_name()) {
+    if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      short_name_->clear();
+    }
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubStateAssignment::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubStateAssignment)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 club_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectTag(26)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_description;
+        break;
+      }
+
+      // optional string description = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_description()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->description().data(), this->description().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "description");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_broadcast;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.Broadcast broadcast = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_broadcast:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_broadcast()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_avatar;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.AvatarId avatar = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_avatar:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_avatar()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_privacy_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_privacy_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::PrivacyLevel_IsValid(value)) {
+            set_privacy_level(static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(7, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_stream_position;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamPosition stream_position = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_stream_position:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_stream_position()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_short_name;
+        break;
+      }
+
+      // optional string short_name = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_short_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_short_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->short_name().data(), this->short_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "short_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubStateAssignment)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubStateAssignment)
+  return false;
+#undef DO_
+}
+
+void ClubStateAssignment::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubStateAssignment)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->club_id(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->name(), output);
+  }
+
+  // optional string description = 4;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->description(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.Broadcast broadcast = 5;
+  if (has_broadcast()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->broadcast(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 6;
+  if (has_avatar()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->avatar(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 7;
+  if (has_privacy_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      7, this->privacy_level(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamPosition stream_position = 8;
+  if (has_stream_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      8, this->stream_position(), output);
+  }
+
+  // optional string short_name = 9;
+  if (has_short_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->short_name().data(), this->short_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "short_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      9, this->short_name(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubStateAssignment)
+}
+
+::google::protobuf::uint8* ClubStateAssignment::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubStateAssignment)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->club_id(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->name(), target);
+  }
+
+  // optional string description = 4;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->description(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.Broadcast broadcast = 5;
+  if (has_broadcast()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->broadcast(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 6;
+  if (has_avatar()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->avatar(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 7;
+  if (has_privacy_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      7, this->privacy_level(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamPosition stream_position = 8;
+  if (has_stream_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        8, this->stream_position(), target);
+  }
+
+  // optional string short_name = 9;
+  if (has_short_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->short_name().data(), this->short_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "short_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        9, this->short_name(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubStateAssignment)
+  return target;
+}
+
+int ClubStateAssignment::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 club_id = 1;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional string name = 3;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string description = 4;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->description());
+    }
+
+    // optional .bgs.protocol.club.v1.Broadcast broadcast = 5;
+    if (has_broadcast()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->broadcast());
+    }
+
+    // optional .bgs.protocol.club.v1.AvatarId avatar = 6;
+    if (has_avatar()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->avatar());
+    }
+
+    // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 7;
+    if (has_privacy_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->privacy_level());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamPosition stream_position = 8;
+    if (has_stream_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->stream_position());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional string short_name = 9;
+    if (has_short_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->short_name());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubStateAssignment::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubStateAssignment* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubStateAssignment*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubStateAssignment::MergeFrom(const ClubStateAssignment& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_description()) {
+      set_description(from.description());
+    }
+    if (from.has_broadcast()) {
+      mutable_broadcast()->::bgs::protocol::club::v1::Broadcast::MergeFrom(from.broadcast());
+    }
+    if (from.has_avatar()) {
+      mutable_avatar()->::bgs::protocol::club::v1::AvatarId::MergeFrom(from.avatar());
+    }
+    if (from.has_privacy_level()) {
+      set_privacy_level(from.privacy_level());
+    }
+    if (from.has_stream_position()) {
+      mutable_stream_position()->::bgs::protocol::club::v1::StreamPosition::MergeFrom(from.stream_position());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_short_name()) {
+      set_short_name(from.short_name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubStateAssignment::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubStateAssignment::CopyFrom(const ClubStateAssignment& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubStateAssignment::IsInitialized() const {
+
+  if (has_broadcast()) {
+    if (!this->broadcast().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubStateAssignment::Swap(ClubStateAssignment* other) {
+  if (other != this) {
+    std::swap(club_id_, other->club_id_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(name_, other->name_);
+    std::swap(description_, other->description_);
+    std::swap(broadcast_, other->broadcast_);
+    std::swap(avatar_, other->avatar_);
+    std::swap(privacy_level_, other->privacy_level_);
+    std::swap(stream_position_, other->stream_position_);
+    std::swap(short_name_, other->short_name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubStateAssignment::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubStateAssignment_descriptor_;
+  metadata.reflection = ClubStateAssignment_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamSettings::kStreamIdFieldNumber;
+const int StreamSettings::kFilterFieldNumber;
+#endif  // !_MSC_VER
+
+StreamSettings::StreamSettings()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamSettings)
+}
+
+void StreamSettings::InitAsDefaultInstance() {
+}
+
+StreamSettings::StreamSettings(const StreamSettings& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamSettings)
+}
+
+void StreamSettings::SharedCtor() {
+  _cached_size_ = 0;
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  filter_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamSettings::~StreamSettings() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamSettings)
+  SharedDtor();
+}
+
+void StreamSettings::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void StreamSettings::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamSettings::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamSettings_descriptor_;
+}
+
+const StreamSettings& StreamSettings::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+StreamSettings* StreamSettings::default_instance_ = NULL;
+
+StreamSettings* StreamSettings::New() const {
+  return new StreamSettings;
+}
+
+void StreamSettings::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamSettings*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(stream_id_, filter_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamSettings::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamSettings)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 stream_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_filter;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamNotificationFilter filter = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_filter:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::StreamNotificationFilter_IsValid(value)) {
+            set_filter(static_cast< ::bgs::protocol::club::v1::StreamNotificationFilter >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(2, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamSettings)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamSettings)
+  return false;
+#undef DO_
+}
+
+void StreamSettings::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamSettings)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamNotificationFilter filter = 2;
+  if (has_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->filter(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamSettings)
+}
+
+::google::protobuf::uint8* StreamSettings::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamSettings)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamNotificationFilter filter = 2;
+  if (has_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->filter(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamSettings)
+  return target;
+}
+
+int StreamSettings::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 stream_id = 1;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamNotificationFilter filter = 2;
+    if (has_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->filter());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamSettings::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamSettings* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamSettings*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamSettings::MergeFrom(const StreamSettings& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_filter()) {
+      set_filter(from.filter());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamSettings::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamSettings::CopyFrom(const StreamSettings& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamSettings::IsInitialized() const {
+
+  return true;
+}
+
+void StreamSettings::Swap(StreamSettings* other) {
+  if (other != this) {
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(filter_, other->filter_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamSettings::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamSettings_descriptor_;
+  metadata.reflection = StreamSettings_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubSettings::kStreamFieldNumber;
+const int ClubSettings::kStreamNotificationFilterAllFieldNumber;
+const int ClubSettings::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+ClubSettings::ClubSettings()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubSettings)
+}
+
+void ClubSettings::InitAsDefaultInstance() {
+}
+
+ClubSettings::ClubSettings(const ClubSettings& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubSettings)
+}
+
+void ClubSettings::SharedCtor() {
+  _cached_size_ = 0;
+  stream_notification_filter_all_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubSettings::~ClubSettings() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubSettings)
+  SharedDtor();
+}
+
+void ClubSettings::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ClubSettings::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubSettings::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSettings_descriptor_;
+}
+
+const ClubSettings& ClubSettings::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+ClubSettings* ClubSettings::default_instance_ = NULL;
+
+ClubSettings* ClubSettings::New() const {
+  return new ClubSettings;
+}
+
+void ClubSettings::Clear() {
+  stream_notification_filter_all_ = false;
+  stream_.Clear();
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubSettings::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubSettings)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.StreamSettings stream = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_stream:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_stream()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_stream;
+        if (input->ExpectTag(16)) goto parse_stream_notification_filter_all;
+        break;
+      }
+
+      // optional bool stream_notification_filter_all = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_stream_notification_filter_all:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &stream_notification_filter_all_)));
+          set_has_stream_notification_filter_all();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubSettings)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubSettings)
+  return false;
+#undef DO_
+}
+
+void ClubSettings::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubSettings)
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1;
+  for (int i = 0; i < this->stream_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->stream(i), output);
+  }
+
+  // optional bool stream_notification_filter_all = 2;
+  if (has_stream_notification_filter_all()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->stream_notification_filter_all(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubSettings)
+}
+
+::google::protobuf::uint8* ClubSettings::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubSettings)
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1;
+  for (int i = 0; i < this->stream_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->stream(i), target);
+  }
+
+  // optional bool stream_notification_filter_all = 2;
+  if (has_stream_notification_filter_all()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->stream_notification_filter_all(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubSettings)
+  return target;
+}
+
+int ClubSettings::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional bool stream_notification_filter_all = 2;
+    if (has_stream_notification_filter_all()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1;
+  total_size += 1 * this->stream_size();
+  for (int i = 0; i < this->stream_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->stream(i));
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubSettings::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubSettings* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubSettings*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubSettings::MergeFrom(const ClubSettings& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  stream_.MergeFrom(from.stream_);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_stream_notification_filter_all()) {
+      set_stream_notification_filter_all(from.stream_notification_filter_all());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubSettings::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubSettings::CopyFrom(const ClubSettings& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubSettings::IsInitialized() const {
+
+  return true;
+}
+
+void ClubSettings::Swap(ClubSettings* other) {
+  if (other != this) {
+    stream_.Swap(&other->stream_);
+    std::swap(stream_notification_filter_all_, other->stream_notification_filter_all_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubSettings::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubSettings_descriptor_;
+  metadata.reflection = ClubSettings_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubSettingsOptions::kStreamFieldNumber;
+const int ClubSettingsOptions::kSettingsFieldNumber;
+const int ClubSettingsOptions::kVersionFieldNumber;
+#endif  // !_MSC_VER
+
+ClubSettingsOptions::ClubSettingsOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubSettingsOptions)
+}
+
+void ClubSettingsOptions::InitAsDefaultInstance() {
+  settings_ = const_cast< ::bgs::protocol::club::v1::ClubSettings*>(&::bgs::protocol::club::v1::ClubSettings::default_instance());
+}
+
+ClubSettingsOptions::ClubSettingsOptions(const ClubSettingsOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubSettingsOptions)
+}
+
+void ClubSettingsOptions::SharedCtor() {
+  _cached_size_ = 0;
+  settings_ = NULL;
+  version_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubSettingsOptions::~ClubSettingsOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubSettingsOptions)
+  SharedDtor();
+}
+
+void ClubSettingsOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete settings_;
+  }
+}
+
+void ClubSettingsOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubSettingsOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSettingsOptions_descriptor_;
+}
+
+const ClubSettingsOptions& ClubSettingsOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+ClubSettingsOptions* ClubSettingsOptions::default_instance_ = NULL;
+
+ClubSettingsOptions* ClubSettingsOptions::New() const {
+  return new ClubSettingsOptions;
+}
+
+void ClubSettingsOptions::Clear() {
+  if (_has_bits_[0 / 32] & 6) {
+    if (has_settings()) {
+      if (settings_ != NULL) settings_->::bgs::protocol::club::v1::ClubSettings::Clear();
+    }
+    version_ = 0u;
+  }
+  stream_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubSettingsOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubSettingsOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+      case 1: {
+        if (tag == 10) {
+         parse_stream:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_stream()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_stream;
+        if (input->ExpectTag(18)) goto parse_settings;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_settings:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_settings()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_version;
+        break;
+      }
+
+      // optional uint32 version = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_version:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &version_)));
+          set_has_version();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubSettingsOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubSettingsOptions)
+  return false;
+#undef DO_
+}
+
+void ClubSettingsOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubSettingsOptions)
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+  for (int i = 0; i < this->stream_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->stream(i), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+  if (has_settings()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->settings(), output);
+  }
+
+  // optional uint32 version = 3;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->version(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubSettingsOptions)
+}
+
+::google::protobuf::uint8* ClubSettingsOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubSettingsOptions)
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+  for (int i = 0; i < this->stream_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->stream(i), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+  if (has_settings()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->settings(), target);
+  }
+
+  // optional uint32 version = 3;
+  if (has_version()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->version(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubSettingsOptions)
+  return target;
+}
+
+int ClubSettingsOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+    if (has_settings()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->settings());
+    }
+
+    // optional uint32 version = 3;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->version());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+  total_size += 1 * this->stream_size();
+  for (int i = 0; i < this->stream_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->stream(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubSettingsOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubSettingsOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubSettingsOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubSettingsOptions::MergeFrom(const ClubSettingsOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  stream_.MergeFrom(from.stream_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_settings()) {
+      mutable_settings()->::bgs::protocol::club::v1::ClubSettings::MergeFrom(from.settings());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubSettingsOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubSettingsOptions::CopyFrom(const ClubSettingsOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubSettingsOptions::IsInitialized() const {
+
+  return true;
+}
+
+void ClubSettingsOptions::Swap(ClubSettingsOptions* other) {
+  if (other != this) {
+    stream_.Swap(&other->stream_);
+    std::swap(settings_, other->settings_);
+    std::swap(version_, other->version_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubSettingsOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubSettingsOptions_descriptor_;
+  metadata.reflection = ClubSettingsOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubSettingsAssignment::kStreamFieldNumber;
+const int ClubSettingsAssignment::kSettingsFieldNumber;
+#endif  // !_MSC_VER
+
+ClubSettingsAssignment::ClubSettingsAssignment()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubSettingsAssignment)
+}
+
+void ClubSettingsAssignment::InitAsDefaultInstance() {
+  settings_ = const_cast< ::bgs::protocol::club::v1::ClubSettings*>(&::bgs::protocol::club::v1::ClubSettings::default_instance());
+}
+
+ClubSettingsAssignment::ClubSettingsAssignment(const ClubSettingsAssignment& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubSettingsAssignment)
+}
+
+void ClubSettingsAssignment::SharedCtor() {
+  _cached_size_ = 0;
+  settings_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubSettingsAssignment::~ClubSettingsAssignment() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubSettingsAssignment)
+  SharedDtor();
+}
+
+void ClubSettingsAssignment::SharedDtor() {
+  if (this != default_instance_) {
+    delete settings_;
+  }
+}
+
+void ClubSettingsAssignment::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubSettingsAssignment::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSettingsAssignment_descriptor_;
+}
+
+const ClubSettingsAssignment& ClubSettingsAssignment::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fcore_2eproto();
+  return *default_instance_;
+}
+
+ClubSettingsAssignment* ClubSettingsAssignment::default_instance_ = NULL;
+
+ClubSettingsAssignment* ClubSettingsAssignment::New() const {
+  return new ClubSettingsAssignment;
+}
+
+void ClubSettingsAssignment::Clear() {
+  if (has_settings()) {
+    if (settings_ != NULL) settings_->::bgs::protocol::club::v1::ClubSettings::Clear();
+  }
+  stream_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubSettingsAssignment::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubSettingsAssignment)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+      case 1: {
+        if (tag == 10) {
+         parse_stream:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_stream()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_stream;
+        if (input->ExpectTag(18)) goto parse_settings;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_settings:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_settings()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubSettingsAssignment)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubSettingsAssignment)
+  return false;
+#undef DO_
+}
+
+void ClubSettingsAssignment::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubSettingsAssignment)
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+  for (int i = 0; i < this->stream_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->stream(i), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+  if (has_settings()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->settings(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubSettingsAssignment)
+}
+
+::google::protobuf::uint8* ClubSettingsAssignment::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubSettingsAssignment)
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+  for (int i = 0; i < this->stream_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->stream(i), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+  if (has_settings()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->settings(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubSettingsAssignment)
+  return target;
+}
+
+int ClubSettingsAssignment::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+    if (has_settings()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->settings());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+  total_size += 1 * this->stream_size();
+  for (int i = 0; i < this->stream_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->stream(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubSettingsAssignment::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubSettingsAssignment* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubSettingsAssignment*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubSettingsAssignment::MergeFrom(const ClubSettingsAssignment& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  stream_.MergeFrom(from.stream_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_settings()) {
+      mutable_settings()->::bgs::protocol::club::v1::ClubSettings::MergeFrom(from.settings());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubSettingsAssignment::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubSettingsAssignment::CopyFrom(const ClubSettingsAssignment& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubSettingsAssignment::IsInitialized() const {
+
+  return true;
+}
+
+void ClubSettingsAssignment::Swap(ClubSettingsAssignment* other) {
+  if (other != this) {
+    stream_.Swap(&other->stream_);
+    std::swap(settings_, other->settings_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubSettingsAssignment::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubSettingsAssignment_descriptor_;
+  metadata.reflection = ClubSettingsAssignment_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_core.pb.h b/src/server/proto/Client/club_core.pb.h
new file mode 100644
index 00000000000..b9a3880bc38
--- /dev/null
+++ b/src/server/proto/Client/club_core.pb.h
@@ -0,0 +1,4954 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_core.proto
+
+#ifndef PROTOBUF_club_5fcore_2eproto__INCLUDED
+#define PROTOBUF_club_5fcore_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "club_enum.pb.h"
+#include "club_role.pb.h"
+#include "club_member.pb.h"
+#include "club_stream.pb.h"
+#include "api/client/v2/attribute_types.pb.h"
+#include "event_view_types.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+void protobuf_AssignDesc_club_5fcore_2eproto();
+void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+class AvatarId;
+class SetBroadcastOptions;
+class Broadcast;
+class UniqueClubType;
+class ClubCreateOptions;
+class Club;
+class ClubDescription;
+class ClubView;
+class ClubStateOptions;
+class ClubStateAssignment;
+class StreamSettings;
+class ClubSettings;
+class ClubSettingsOptions;
+class ClubSettingsAssignment;
+
+// ===================================================================
+
+class TC_PROTO_API AvatarId : public ::google::protobuf::Message {
+ public:
+  AvatarId();
+  virtual ~AvatarId();
+
+  AvatarId(const AvatarId& from);
+
+  inline AvatarId& operator=(const AvatarId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AvatarId& default_instance();
+
+  void Swap(AvatarId* other);
+
+  // implements Message ----------------------------------------------
+
+  AvatarId* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AvatarId& from);
+  void MergeFrom(const AvatarId& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint32 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.AvatarId)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static AvatarId* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SetBroadcastOptions : public ::google::protobuf::Message {
+ public:
+  SetBroadcastOptions();
+  virtual ~SetBroadcastOptions();
+
+  SetBroadcastOptions(const SetBroadcastOptions& from);
+
+  inline SetBroadcastOptions& operator=(const SetBroadcastOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SetBroadcastOptions& default_instance();
+
+  void Swap(SetBroadcastOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  SetBroadcastOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SetBroadcastOptions& from);
+  void MergeFrom(const SetBroadcastOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string content = 1;
+  inline bool has_content() const;
+  inline void clear_content();
+  static const int kContentFieldNumber = 1;
+  inline const ::std::string& content() const;
+  inline void set_content(const ::std::string& value);
+  inline void set_content(const char* value);
+  inline void set_content(const char* value, size_t size);
+  inline ::std::string* mutable_content();
+  inline ::std::string* release_content();
+  inline void set_allocated_content(::std::string* content);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SetBroadcastOptions)
+ private:
+  inline void set_has_content();
+  inline void clear_has_content();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* content_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static SetBroadcastOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API Broadcast : public ::google::protobuf::Message {
+ public:
+  Broadcast();
+  virtual ~Broadcast();
+
+  Broadcast(const Broadcast& from);
+
+  inline Broadcast& operator=(const Broadcast& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Broadcast& default_instance();
+
+  void Swap(Broadcast* other);
+
+  // implements Message ----------------------------------------------
+
+  Broadcast* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Broadcast& from);
+  void MergeFrom(const Broadcast& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string content = 1;
+  inline bool has_content() const;
+  inline void clear_content();
+  static const int kContentFieldNumber = 1;
+  inline const ::std::string& content() const;
+  inline void set_content(const ::std::string& value);
+  inline void set_content(const char* value);
+  inline void set_content(const char* value, size_t size);
+  inline ::std::string* mutable_content();
+  inline ::std::string* release_content();
+  inline void set_allocated_content(::std::string* content);
+
+  // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+  inline bool has_creator() const;
+  inline void clear_creator();
+  static const int kCreatorFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberDescription& creator() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_creator();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_creator();
+  inline void set_allocated_creator(::bgs::protocol::club::v1::MemberDescription* creator);
+
+  // optional uint64 creation_time = 3;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 3;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.Broadcast)
+ private:
+  inline void set_has_content();
+  inline void clear_has_content();
+  inline void set_has_creator();
+  inline void clear_has_creator();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* content_;
+  ::bgs::protocol::club::v1::MemberDescription* creator_;
+  ::google::protobuf::uint64 creation_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static Broadcast* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UniqueClubType : public ::google::protobuf::Message {
+ public:
+  UniqueClubType();
+  virtual ~UniqueClubType();
+
+  UniqueClubType(const UniqueClubType& from);
+
+  inline UniqueClubType& operator=(const UniqueClubType& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UniqueClubType& default_instance();
+
+  void Swap(UniqueClubType* other);
+
+  // implements Message ----------------------------------------------
+
+  UniqueClubType* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UniqueClubType& from);
+  void MergeFrom(const UniqueClubType& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional fixed32 program = 1;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 1;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional string name = 2;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UniqueClubType)
+ private:
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_name();
+  inline void clear_has_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static UniqueClubType* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubCreateOptions : public ::google::protobuf::Message {
+ public:
+  ClubCreateOptions();
+  virtual ~ClubCreateOptions();
+
+  ClubCreateOptions(const ClubCreateOptions& from);
+
+  inline ClubCreateOptions& operator=(const ClubCreateOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubCreateOptions& default_instance();
+
+  void Swap(ClubCreateOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubCreateOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubCreateOptions& from);
+  void MergeFrom(const ClubCreateOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::UniqueClubType& type() const;
+  inline ::bgs::protocol::club::v1::UniqueClubType* mutable_type();
+  inline ::bgs::protocol::club::v1::UniqueClubType* release_type();
+  inline void set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string name = 3;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 3;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string description = 4;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 4;
+  inline const ::std::string& description() const;
+  inline void set_description(const ::std::string& value);
+  inline void set_description(const char* value);
+  inline void set_description(const char* value, size_t size);
+  inline ::std::string* mutable_description();
+  inline ::std::string* release_description();
+  inline void set_allocated_description(::std::string* description);
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+  inline bool has_avatar() const;
+  inline void clear_avatar();
+  static const int kAvatarFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::AvatarId& avatar() const;
+  inline ::bgs::protocol::club::v1::AvatarId* mutable_avatar();
+  inline ::bgs::protocol::club::v1::AvatarId* release_avatar();
+  inline void set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar);
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+  inline bool has_privacy_level() const;
+  inline void clear_privacy_level();
+  static const int kPrivacyLevelFieldNumber = 6;
+  inline ::bgs::protocol::club::v1::PrivacyLevel privacy_level() const;
+  inline void set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value);
+
+  // optional string short_name = 7;
+  inline bool has_short_name() const;
+  inline void clear_short_name();
+  static const int kShortNameFieldNumber = 7;
+  inline const ::std::string& short_name() const;
+  inline void set_short_name(const ::std::string& value);
+  inline void set_short_name(const char* value);
+  inline void set_short_name(const char* value, size_t size);
+  inline ::std::string* mutable_short_name();
+  inline ::std::string* release_short_name();
+  inline void set_allocated_short_name(::std::string* short_name);
+
+  // optional .bgs.protocol.club.v1.CreateMemberOptions member = 10;
+  inline bool has_member() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 10;
+  inline const ::bgs::protocol::club::v1::CreateMemberOptions& member() const;
+  inline ::bgs::protocol::club::v1::CreateMemberOptions* mutable_member();
+  inline ::bgs::protocol::club::v1::CreateMemberOptions* release_member();
+  inline void set_allocated_member(::bgs::protocol::club::v1::CreateMemberOptions* member);
+
+  // optional .bgs.protocol.club.v1.CreateStreamOptions stream = 11;
+  inline bool has_stream() const;
+  inline void clear_stream();
+  static const int kStreamFieldNumber = 11;
+  inline const ::bgs::protocol::club::v1::CreateStreamOptions& stream() const;
+  inline ::bgs::protocol::club::v1::CreateStreamOptions* mutable_stream();
+  inline ::bgs::protocol::club::v1::CreateStreamOptions* release_stream();
+  inline void set_allocated_stream(::bgs::protocol::club::v1::CreateStreamOptions* stream);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubCreateOptions)
+ private:
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_description();
+  inline void clear_has_description();
+  inline void set_has_avatar();
+  inline void clear_has_avatar();
+  inline void set_has_privacy_level();
+  inline void clear_has_privacy_level();
+  inline void set_has_short_name();
+  inline void clear_has_short_name();
+  inline void set_has_member();
+  inline void clear_has_member();
+  inline void set_has_stream();
+  inline void clear_has_stream();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::UniqueClubType* type_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* name_;
+  ::std::string* description_;
+  ::bgs::protocol::club::v1::AvatarId* avatar_;
+  ::std::string* short_name_;
+  ::bgs::protocol::club::v1::CreateMemberOptions* member_;
+  ::bgs::protocol::club::v1::CreateStreamOptions* stream_;
+  int privacy_level_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubCreateOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API Club : public ::google::protobuf::Message {
+ public:
+  Club();
+  virtual ~Club();
+
+  Club(const Club& from);
+
+  inline Club& operator=(const Club& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Club& default_instance();
+
+  void Swap(Club* other);
+
+  // implements Message ----------------------------------------------
+
+  Club* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Club& from);
+  void MergeFrom(const Club& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 id() const;
+  inline void set_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::UniqueClubType& type() const;
+  inline ::bgs::protocol::club::v1::UniqueClubType* mutable_type();
+  inline ::bgs::protocol::club::v1::UniqueClubType* release_type();
+  inline void set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 3;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string name = 4;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 4;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string description = 5;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 5;
+  inline const ::std::string& description() const;
+  inline void set_description(const ::std::string& value);
+  inline void set_description(const char* value);
+  inline void set_description(const char* value, size_t size);
+  inline ::std::string* mutable_description();
+  inline ::std::string* release_description();
+  inline void set_allocated_description(::std::string* description);
+
+  // optional .bgs.protocol.club.v1.Broadcast broadcast = 6;
+  inline bool has_broadcast() const;
+  inline void clear_broadcast();
+  static const int kBroadcastFieldNumber = 6;
+  inline const ::bgs::protocol::club::v1::Broadcast& broadcast() const;
+  inline ::bgs::protocol::club::v1::Broadcast* mutable_broadcast();
+  inline ::bgs::protocol::club::v1::Broadcast* release_broadcast();
+  inline void set_allocated_broadcast(::bgs::protocol::club::v1::Broadcast* broadcast);
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 7;
+  inline bool has_avatar() const;
+  inline void clear_avatar();
+  static const int kAvatarFieldNumber = 7;
+  inline const ::bgs::protocol::club::v1::AvatarId& avatar() const;
+  inline ::bgs::protocol::club::v1::AvatarId* mutable_avatar();
+  inline ::bgs::protocol::club::v1::AvatarId* release_avatar();
+  inline void set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar);
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 8;
+  inline bool has_privacy_level() const;
+  inline void clear_privacy_level();
+  static const int kPrivacyLevelFieldNumber = 8;
+  inline ::bgs::protocol::club::v1::PrivacyLevel privacy_level() const;
+  inline void set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value);
+
+  // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 9;
+  inline bool has_visibility_level() const;
+  inline void clear_visibility_level();
+  static const int kVisibilityLevelFieldNumber = 9;
+  inline ::bgs::protocol::club::v1::VisibilityLevel visibility_level() const;
+  inline void set_visibility_level(::bgs::protocol::club::v1::VisibilityLevel value);
+
+  // optional uint32 member_count = 10;
+  inline bool has_member_count() const;
+  inline void clear_member_count();
+  static const int kMemberCountFieldNumber = 10;
+  inline ::google::protobuf::uint32 member_count() const;
+  inline void set_member_count(::google::protobuf::uint32 value);
+
+  // optional uint64 creation_time = 11;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 11;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.StreamPosition stream_position = 12;
+  inline bool has_stream_position() const;
+  inline void clear_stream_position();
+  static const int kStreamPositionFieldNumber = 12;
+  inline const ::bgs::protocol::club::v1::StreamPosition& stream_position() const;
+  inline ::bgs::protocol::club::v1::StreamPosition* mutable_stream_position();
+  inline ::bgs::protocol::club::v1::StreamPosition* release_stream_position();
+  inline void set_allocated_stream_position(::bgs::protocol::club::v1::StreamPosition* stream_position);
+
+  // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 13;
+  inline bool has_role_set() const;
+  inline void clear_role_set();
+  static const int kRoleSetFieldNumber = 13;
+  inline const ::bgs::protocol::club::v1::ClubRoleSet& role_set() const;
+  inline ::bgs::protocol::club::v1::ClubRoleSet* mutable_role_set();
+  inline ::bgs::protocol::club::v1::ClubRoleSet* release_role_set();
+  inline void set_allocated_role_set(::bgs::protocol::club::v1::ClubRoleSet* role_set);
+
+  // repeated .bgs.protocol.club.v1.MemberDescription leader = 14;
+  inline int leader_size() const;
+  inline void clear_leader();
+  static const int kLeaderFieldNumber = 14;
+  inline const ::bgs::protocol::club::v1::MemberDescription& leader(int index) const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_leader(int index);
+  inline ::bgs::protocol::club::v1::MemberDescription* add_leader();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription >&
+      leader() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription >*
+      mutable_leader();
+
+  // optional string short_name = 15;
+  inline bool has_short_name() const;
+  inline void clear_short_name();
+  static const int kShortNameFieldNumber = 15;
+  inline const ::std::string& short_name() const;
+  inline void set_short_name(const ::std::string& value);
+  inline void set_short_name(const char* value);
+  inline void set_short_name(const char* value, size_t size);
+  inline ::std::string* mutable_short_name();
+  inline ::std::string* release_short_name();
+  inline void set_allocated_short_name(::std::string* short_name);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.Club)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_description();
+  inline void clear_has_description();
+  inline void set_has_broadcast();
+  inline void clear_has_broadcast();
+  inline void set_has_avatar();
+  inline void clear_has_avatar();
+  inline void set_has_privacy_level();
+  inline void clear_has_privacy_level();
+  inline void set_has_visibility_level();
+  inline void clear_has_visibility_level();
+  inline void set_has_member_count();
+  inline void clear_has_member_count();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+  inline void set_has_stream_position();
+  inline void clear_has_stream_position();
+  inline void set_has_role_set();
+  inline void clear_has_role_set();
+  inline void set_has_short_name();
+  inline void clear_has_short_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 id_;
+  ::bgs::protocol::club::v1::UniqueClubType* type_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* name_;
+  ::std::string* description_;
+  ::bgs::protocol::club::v1::Broadcast* broadcast_;
+  ::bgs::protocol::club::v1::AvatarId* avatar_;
+  int privacy_level_;
+  int visibility_level_;
+  ::google::protobuf::uint64 creation_time_;
+  ::bgs::protocol::club::v1::StreamPosition* stream_position_;
+  ::bgs::protocol::club::v1::ClubRoleSet* role_set_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription > leader_;
+  ::std::string* short_name_;
+  ::google::protobuf::uint32 member_count_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static Club* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubDescription : public ::google::protobuf::Message {
+ public:
+  ClubDescription();
+  virtual ~ClubDescription();
+
+  ClubDescription(const ClubDescription& from);
+
+  inline ClubDescription& operator=(const ClubDescription& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubDescription& default_instance();
+
+  void Swap(ClubDescription* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubDescription* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubDescription& from);
+  void MergeFrom(const ClubDescription& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 id() const;
+  inline void set_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::UniqueClubType& type() const;
+  inline ::bgs::protocol::club::v1::UniqueClubType* mutable_type();
+  inline ::bgs::protocol::club::v1::UniqueClubType* release_type();
+  inline void set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type);
+
+  // optional string name = 3;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 3;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string description = 4;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 4;
+  inline const ::std::string& description() const;
+  inline void set_description(const ::std::string& value);
+  inline void set_description(const char* value);
+  inline void set_description(const char* value, size_t size);
+  inline ::std::string* mutable_description();
+  inline ::std::string* release_description();
+  inline void set_allocated_description(::std::string* description);
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+  inline bool has_avatar() const;
+  inline void clear_avatar();
+  static const int kAvatarFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::AvatarId& avatar() const;
+  inline ::bgs::protocol::club::v1::AvatarId* mutable_avatar();
+  inline ::bgs::protocol::club::v1::AvatarId* release_avatar();
+  inline void set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar);
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+  inline bool has_privacy_level() const;
+  inline void clear_privacy_level();
+  static const int kPrivacyLevelFieldNumber = 6;
+  inline ::bgs::protocol::club::v1::PrivacyLevel privacy_level() const;
+  inline void set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value);
+
+  // optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 7;
+  inline bool has_visibility_level() const;
+  inline void clear_visibility_level();
+  static const int kVisibilityLevelFieldNumber = 7;
+  inline ::bgs::protocol::club::v1::VisibilityLevel visibility_level() const;
+  inline void set_visibility_level(::bgs::protocol::club::v1::VisibilityLevel value);
+
+  // optional uint32 member_count = 8;
+  inline bool has_member_count() const;
+  inline void clear_member_count();
+  static const int kMemberCountFieldNumber = 8;
+  inline ::google::protobuf::uint32 member_count() const;
+  inline void set_member_count(::google::protobuf::uint32 value);
+
+  // repeated .bgs.protocol.club.v1.MemberDescription leader = 9;
+  inline int leader_size() const;
+  inline void clear_leader();
+  static const int kLeaderFieldNumber = 9;
+  inline const ::bgs::protocol::club::v1::MemberDescription& leader(int index) const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_leader(int index);
+  inline ::bgs::protocol::club::v1::MemberDescription* add_leader();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription >&
+      leader() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription >*
+      mutable_leader();
+
+  // optional uint64 creation_time = 10;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 10;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubDescription)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_description();
+  inline void clear_has_description();
+  inline void set_has_avatar();
+  inline void clear_has_avatar();
+  inline void set_has_privacy_level();
+  inline void clear_has_privacy_level();
+  inline void set_has_visibility_level();
+  inline void clear_has_visibility_level();
+  inline void set_has_member_count();
+  inline void clear_has_member_count();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 id_;
+  ::bgs::protocol::club::v1::UniqueClubType* type_;
+  ::std::string* name_;
+  ::std::string* description_;
+  ::bgs::protocol::club::v1::AvatarId* avatar_;
+  int privacy_level_;
+  int visibility_level_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription > leader_;
+  ::google::protobuf::uint64 creation_time_;
+  ::google::protobuf::uint32 member_count_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubDescription* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubView : public ::google::protobuf::Message {
+ public:
+  ClubView();
+  virtual ~ClubView();
+
+  ClubView(const ClubView& from);
+
+  inline ClubView& operator=(const ClubView& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubView& default_instance();
+
+  void Swap(ClubView* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubView* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubView& from);
+  void MergeFrom(const ClubView& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 club_id = 1;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.ViewMarker marker = 2;
+  inline bool has_marker() const;
+  inline void clear_marker();
+  static const int kMarkerFieldNumber = 2;
+  inline const ::bgs::protocol::ViewMarker& marker() const;
+  inline ::bgs::protocol::ViewMarker* mutable_marker();
+  inline ::bgs::protocol::ViewMarker* release_marker();
+  inline void set_allocated_marker(::bgs::protocol::ViewMarker* marker);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubView)
+ private:
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_marker();
+  inline void clear_has_marker();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::ViewMarker* marker_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubView* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubStateOptions : public ::google::protobuf::Message {
+ public:
+  ClubStateOptions();
+  virtual ~ClubStateOptions();
+
+  ClubStateOptions(const ClubStateOptions& from);
+
+  inline ClubStateOptions& operator=(const ClubStateOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubStateOptions& default_instance();
+
+  void Swap(ClubStateOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubStateOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubStateOptions& from);
+  void MergeFrom(const ClubStateOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string name = 2;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string description = 3;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 3;
+  inline const ::std::string& description() const;
+  inline void set_description(const ::std::string& value);
+  inline void set_description(const char* value);
+  inline void set_description(const char* value, size_t size);
+  inline ::std::string* mutable_description();
+  inline ::std::string* release_description();
+  inline void set_allocated_description(::std::string* description);
+
+  // optional .bgs.protocol.club.v1.SetBroadcastOptions broadcast = 4;
+  inline bool has_broadcast() const;
+  inline void clear_broadcast();
+  static const int kBroadcastFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::SetBroadcastOptions& broadcast() const;
+  inline ::bgs::protocol::club::v1::SetBroadcastOptions* mutable_broadcast();
+  inline ::bgs::protocol::club::v1::SetBroadcastOptions* release_broadcast();
+  inline void set_allocated_broadcast(::bgs::protocol::club::v1::SetBroadcastOptions* broadcast);
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+  inline bool has_avatar() const;
+  inline void clear_avatar();
+  static const int kAvatarFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::AvatarId& avatar() const;
+  inline ::bgs::protocol::club::v1::AvatarId* mutable_avatar();
+  inline ::bgs::protocol::club::v1::AvatarId* release_avatar();
+  inline void set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar);
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+  inline bool has_privacy_level() const;
+  inline void clear_privacy_level();
+  static const int kPrivacyLevelFieldNumber = 6;
+  inline ::bgs::protocol::club::v1::PrivacyLevel privacy_level() const;
+  inline void set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value);
+
+  // optional .bgs.protocol.club.v1.StreamPosition stream_position = 7;
+  inline bool has_stream_position() const;
+  inline void clear_stream_position();
+  static const int kStreamPositionFieldNumber = 7;
+  inline const ::bgs::protocol::club::v1::StreamPosition& stream_position() const;
+  inline ::bgs::protocol::club::v1::StreamPosition* mutable_stream_position();
+  inline ::bgs::protocol::club::v1::StreamPosition* release_stream_position();
+  inline void set_allocated_stream_position(::bgs::protocol::club::v1::StreamPosition* stream_position);
+
+  // optional string short_name = 8;
+  inline bool has_short_name() const;
+  inline void clear_short_name();
+  static const int kShortNameFieldNumber = 8;
+  inline const ::std::string& short_name() const;
+  inline void set_short_name(const ::std::string& value);
+  inline void set_short_name(const char* value);
+  inline void set_short_name(const char* value, size_t size);
+  inline ::std::string* mutable_short_name();
+  inline ::std::string* release_short_name();
+  inline void set_allocated_short_name(::std::string* short_name);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubStateOptions)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_description();
+  inline void clear_has_description();
+  inline void set_has_broadcast();
+  inline void clear_has_broadcast();
+  inline void set_has_avatar();
+  inline void clear_has_avatar();
+  inline void set_has_privacy_level();
+  inline void clear_has_privacy_level();
+  inline void set_has_stream_position();
+  inline void clear_has_stream_position();
+  inline void set_has_short_name();
+  inline void clear_has_short_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* name_;
+  ::std::string* description_;
+  ::bgs::protocol::club::v1::SetBroadcastOptions* broadcast_;
+  ::bgs::protocol::club::v1::AvatarId* avatar_;
+  ::bgs::protocol::club::v1::StreamPosition* stream_position_;
+  ::std::string* short_name_;
+  int privacy_level_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubStateOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubStateAssignment : public ::google::protobuf::Message {
+ public:
+  ClubStateAssignment();
+  virtual ~ClubStateAssignment();
+
+  ClubStateAssignment(const ClubStateAssignment& from);
+
+  inline ClubStateAssignment& operator=(const ClubStateAssignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubStateAssignment& default_instance();
+
+  void Swap(ClubStateAssignment* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubStateAssignment* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubStateAssignment& from);
+  void MergeFrom(const ClubStateAssignment& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 club_id = 1;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string name = 3;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 3;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string description = 4;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 4;
+  inline const ::std::string& description() const;
+  inline void set_description(const ::std::string& value);
+  inline void set_description(const char* value);
+  inline void set_description(const char* value, size_t size);
+  inline ::std::string* mutable_description();
+  inline ::std::string* release_description();
+  inline void set_allocated_description(::std::string* description);
+
+  // optional .bgs.protocol.club.v1.Broadcast broadcast = 5;
+  inline bool has_broadcast() const;
+  inline void clear_broadcast();
+  static const int kBroadcastFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::Broadcast& broadcast() const;
+  inline ::bgs::protocol::club::v1::Broadcast* mutable_broadcast();
+  inline ::bgs::protocol::club::v1::Broadcast* release_broadcast();
+  inline void set_allocated_broadcast(::bgs::protocol::club::v1::Broadcast* broadcast);
+
+  // optional .bgs.protocol.club.v1.AvatarId avatar = 6;
+  inline bool has_avatar() const;
+  inline void clear_avatar();
+  static const int kAvatarFieldNumber = 6;
+  inline const ::bgs::protocol::club::v1::AvatarId& avatar() const;
+  inline ::bgs::protocol::club::v1::AvatarId* mutable_avatar();
+  inline ::bgs::protocol::club::v1::AvatarId* release_avatar();
+  inline void set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar);
+
+  // optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 7;
+  inline bool has_privacy_level() const;
+  inline void clear_privacy_level();
+  static const int kPrivacyLevelFieldNumber = 7;
+  inline ::bgs::protocol::club::v1::PrivacyLevel privacy_level() const;
+  inline void set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value);
+
+  // optional .bgs.protocol.club.v1.StreamPosition stream_position = 8;
+  inline bool has_stream_position() const;
+  inline void clear_stream_position();
+  static const int kStreamPositionFieldNumber = 8;
+  inline const ::bgs::protocol::club::v1::StreamPosition& stream_position() const;
+  inline ::bgs::protocol::club::v1::StreamPosition* mutable_stream_position();
+  inline ::bgs::protocol::club::v1::StreamPosition* release_stream_position();
+  inline void set_allocated_stream_position(::bgs::protocol::club::v1::StreamPosition* stream_position);
+
+  // optional string short_name = 9;
+  inline bool has_short_name() const;
+  inline void clear_short_name();
+  static const int kShortNameFieldNumber = 9;
+  inline const ::std::string& short_name() const;
+  inline void set_short_name(const ::std::string& value);
+  inline void set_short_name(const char* value);
+  inline void set_short_name(const char* value, size_t size);
+  inline ::std::string* mutable_short_name();
+  inline ::std::string* release_short_name();
+  inline void set_allocated_short_name(::std::string* short_name);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubStateAssignment)
+ private:
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_description();
+  inline void clear_has_description();
+  inline void set_has_broadcast();
+  inline void clear_has_broadcast();
+  inline void set_has_avatar();
+  inline void clear_has_avatar();
+  inline void set_has_privacy_level();
+  inline void clear_has_privacy_level();
+  inline void set_has_stream_position();
+  inline void clear_has_stream_position();
+  inline void set_has_short_name();
+  inline void clear_has_short_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* name_;
+  ::std::string* description_;
+  ::bgs::protocol::club::v1::Broadcast* broadcast_;
+  ::bgs::protocol::club::v1::AvatarId* avatar_;
+  ::bgs::protocol::club::v1::StreamPosition* stream_position_;
+  ::std::string* short_name_;
+  int privacy_level_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubStateAssignment* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamSettings : public ::google::protobuf::Message {
+ public:
+  StreamSettings();
+  virtual ~StreamSettings();
+
+  StreamSettings(const StreamSettings& from);
+
+  inline StreamSettings& operator=(const StreamSettings& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamSettings& default_instance();
+
+  void Swap(StreamSettings* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamSettings* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamSettings& from);
+  void MergeFrom(const StreamSettings& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 stream_id = 1;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.StreamNotificationFilter filter = 2;
+  inline bool has_filter() const;
+  inline void clear_filter();
+  static const int kFilterFieldNumber = 2;
+  inline ::bgs::protocol::club::v1::StreamNotificationFilter filter() const;
+  inline void set_filter(::bgs::protocol::club::v1::StreamNotificationFilter value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamSettings)
+ private:
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_filter();
+  inline void clear_has_filter();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 stream_id_;
+  int filter_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamSettings* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubSettings : public ::google::protobuf::Message {
+ public:
+  ClubSettings();
+  virtual ~ClubSettings();
+
+  ClubSettings(const ClubSettings& from);
+
+  inline ClubSettings& operator=(const ClubSettings& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubSettings& default_instance();
+
+  void Swap(ClubSettings* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubSettings* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubSettings& from);
+  void MergeFrom(const ClubSettings& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1;
+  inline int stream_size() const;
+  inline void clear_stream();
+  static const int kStreamFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::StreamSettings& stream(int index) const;
+  inline ::bgs::protocol::club::v1::StreamSettings* mutable_stream(int index);
+  inline ::bgs::protocol::club::v1::StreamSettings* add_stream();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >&
+      stream() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >*
+      mutable_stream();
+
+  // optional bool stream_notification_filter_all = 2;
+  inline bool has_stream_notification_filter_all() const;
+  inline void clear_stream_notification_filter_all();
+  static const int kStreamNotificationFilterAllFieldNumber = 2;
+  inline bool stream_notification_filter_all() const;
+  inline void set_stream_notification_filter_all(bool value);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 3;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubSettings)
+ private:
+  inline void set_has_stream_notification_filter_all();
+  inline void clear_has_stream_notification_filter_all();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings > stream_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  bool stream_notification_filter_all_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubSettings* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubSettingsOptions : public ::google::protobuf::Message {
+ public:
+  ClubSettingsOptions();
+  virtual ~ClubSettingsOptions();
+
+  ClubSettingsOptions(const ClubSettingsOptions& from);
+
+  inline ClubSettingsOptions& operator=(const ClubSettingsOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubSettingsOptions& default_instance();
+
+  void Swap(ClubSettingsOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubSettingsOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubSettingsOptions& from);
+  void MergeFrom(const ClubSettingsOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+  inline int stream_size() const PROTOBUF_DEPRECATED;
+  inline void clear_stream() PROTOBUF_DEPRECATED;
+  static const int kStreamFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::StreamSettings& stream(int index) const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::club::v1::StreamSettings* mutable_stream(int index) PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::club::v1::StreamSettings* add_stream() PROTOBUF_DEPRECATED;
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >&
+      stream() const PROTOBUF_DEPRECATED;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >*
+      mutable_stream() PROTOBUF_DEPRECATED;
+
+  // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+  inline bool has_settings() const;
+  inline void clear_settings();
+  static const int kSettingsFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::ClubSettings& settings() const;
+  inline ::bgs::protocol::club::v1::ClubSettings* mutable_settings();
+  inline ::bgs::protocol::club::v1::ClubSettings* release_settings();
+  inline void set_allocated_settings(::bgs::protocol::club::v1::ClubSettings* settings);
+
+  // optional uint32 version = 3;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 3;
+  inline ::google::protobuf::uint32 version() const;
+  inline void set_version(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubSettingsOptions)
+ private:
+  inline void set_has_settings();
+  inline void clear_has_settings();
+  inline void set_has_version();
+  inline void clear_has_version();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings > stream_;
+  ::bgs::protocol::club::v1::ClubSettings* settings_;
+  ::google::protobuf::uint32 version_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubSettingsOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubSettingsAssignment : public ::google::protobuf::Message {
+ public:
+  ClubSettingsAssignment();
+  virtual ~ClubSettingsAssignment();
+
+  ClubSettingsAssignment(const ClubSettingsAssignment& from);
+
+  inline ClubSettingsAssignment& operator=(const ClubSettingsAssignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubSettingsAssignment& default_instance();
+
+  void Swap(ClubSettingsAssignment* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubSettingsAssignment* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubSettingsAssignment& from);
+  void MergeFrom(const ClubSettingsAssignment& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+  inline int stream_size() const PROTOBUF_DEPRECATED;
+  inline void clear_stream() PROTOBUF_DEPRECATED;
+  static const int kStreamFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::StreamSettings& stream(int index) const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::club::v1::StreamSettings* mutable_stream(int index) PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::club::v1::StreamSettings* add_stream() PROTOBUF_DEPRECATED;
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >&
+      stream() const PROTOBUF_DEPRECATED;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >*
+      mutable_stream() PROTOBUF_DEPRECATED;
+
+  // optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+  inline bool has_settings() const;
+  inline void clear_settings();
+  static const int kSettingsFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::ClubSettings& settings() const;
+  inline ::bgs::protocol::club::v1::ClubSettings* mutable_settings();
+  inline ::bgs::protocol::club::v1::ClubSettings* release_settings();
+  inline void set_allocated_settings(::bgs::protocol::club::v1::ClubSettings* settings);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubSettingsAssignment)
+ private:
+  inline void set_has_settings();
+  inline void clear_has_settings();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings > stream_;
+  ::bgs::protocol::club::v1::ClubSettings* settings_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fcore_2eproto();
+  friend void protobuf_AssignDesc_club_5fcore_2eproto();
+  friend void protobuf_ShutdownFile_club_5fcore_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubSettingsAssignment* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// AvatarId
+
+// optional uint32 id = 1;
+inline bool AvatarId::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AvatarId::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AvatarId::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AvatarId::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 AvatarId::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AvatarId.id)
+  return id_;
+}
+inline void AvatarId::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AvatarId.id)
+}
+
+// -------------------------------------------------------------------
+
+// SetBroadcastOptions
+
+// optional string content = 1;
+inline bool SetBroadcastOptions::has_content() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SetBroadcastOptions::set_has_content() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SetBroadcastOptions::clear_has_content() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SetBroadcastOptions::clear_content() {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_->clear();
+  }
+  clear_has_content();
+}
+inline const ::std::string& SetBroadcastOptions::content() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetBroadcastOptions.content)
+  return *content_;
+}
+inline void SetBroadcastOptions::set_content(const ::std::string& value) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SetBroadcastOptions.content)
+}
+inline void SetBroadcastOptions::set_content(const char* value) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.SetBroadcastOptions.content)
+}
+inline void SetBroadcastOptions::set_content(const char* value, size_t size) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.SetBroadcastOptions.content)
+}
+inline ::std::string* SetBroadcastOptions::mutable_content() {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SetBroadcastOptions.content)
+  return content_;
+}
+inline ::std::string* SetBroadcastOptions::release_content() {
+  clear_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = content_;
+    content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void SetBroadcastOptions::set_allocated_content(::std::string* content) {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete content_;
+  }
+  if (content) {
+    set_has_content();
+    content_ = content;
+  } else {
+    clear_has_content();
+    content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SetBroadcastOptions.content)
+}
+
+// -------------------------------------------------------------------
+
+// Broadcast
+
+// optional string content = 1;
+inline bool Broadcast::has_content() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Broadcast::set_has_content() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Broadcast::clear_has_content() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Broadcast::clear_content() {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_->clear();
+  }
+  clear_has_content();
+}
+inline const ::std::string& Broadcast::content() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Broadcast.content)
+  return *content_;
+}
+inline void Broadcast::set_content(const ::std::string& value) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Broadcast.content)
+}
+inline void Broadcast::set_content(const char* value) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.Broadcast.content)
+}
+inline void Broadcast::set_content(const char* value, size_t size) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.Broadcast.content)
+}
+inline ::std::string* Broadcast::mutable_content() {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Broadcast.content)
+  return content_;
+}
+inline ::std::string* Broadcast::release_content() {
+  clear_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = content_;
+    content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Broadcast::set_allocated_content(::std::string* content) {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete content_;
+  }
+  if (content) {
+    set_has_content();
+    content_ = content;
+  } else {
+    clear_has_content();
+    content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Broadcast.content)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+inline bool Broadcast::has_creator() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Broadcast::set_has_creator() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Broadcast::clear_has_creator() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Broadcast::clear_creator() {
+  if (creator_ != NULL) creator_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_creator();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& Broadcast::creator() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Broadcast.creator)
+  return creator_ != NULL ? *creator_ : *default_instance_->creator_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* Broadcast::mutable_creator() {
+  set_has_creator();
+  if (creator_ == NULL) creator_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Broadcast.creator)
+  return creator_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* Broadcast::release_creator() {
+  clear_has_creator();
+  ::bgs::protocol::club::v1::MemberDescription* temp = creator_;
+  creator_ = NULL;
+  return temp;
+}
+inline void Broadcast::set_allocated_creator(::bgs::protocol::club::v1::MemberDescription* creator) {
+  delete creator_;
+  creator_ = creator;
+  if (creator) {
+    set_has_creator();
+  } else {
+    clear_has_creator();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Broadcast.creator)
+}
+
+// optional uint64 creation_time = 3;
+inline bool Broadcast::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Broadcast::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Broadcast::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Broadcast::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 Broadcast::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Broadcast.creation_time)
+  return creation_time_;
+}
+inline void Broadcast::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Broadcast.creation_time)
+}
+
+// -------------------------------------------------------------------
+
+// UniqueClubType
+
+// optional fixed32 program = 1;
+inline bool UniqueClubType::has_program() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UniqueClubType::set_has_program() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UniqueClubType::clear_has_program() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UniqueClubType::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 UniqueClubType::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UniqueClubType.program)
+  return program_;
+}
+inline void UniqueClubType::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UniqueClubType.program)
+}
+
+// optional string name = 2;
+inline bool UniqueClubType::has_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UniqueClubType::set_has_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UniqueClubType::clear_has_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UniqueClubType::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& UniqueClubType::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UniqueClubType.name)
+  return *name_;
+}
+inline void UniqueClubType::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UniqueClubType.name)
+}
+inline void UniqueClubType::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.UniqueClubType.name)
+}
+inline void UniqueClubType::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.UniqueClubType.name)
+}
+inline ::std::string* UniqueClubType::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UniqueClubType.name)
+  return name_;
+}
+inline ::std::string* UniqueClubType::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void UniqueClubType::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UniqueClubType.name)
+}
+
+// -------------------------------------------------------------------
+
+// ClubCreateOptions
+
+// optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+inline bool ClubCreateOptions::has_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubCreateOptions::set_has_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubCreateOptions::clear_has_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubCreateOptions::clear_type() {
+  if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+  clear_has_type();
+}
+inline const ::bgs::protocol::club::v1::UniqueClubType& ClubCreateOptions::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubCreateOptions.type)
+  return type_ != NULL ? *type_ : *default_instance_->type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* ClubCreateOptions::mutable_type() {
+  set_has_type();
+  if (type_ == NULL) type_ = new ::bgs::protocol::club::v1::UniqueClubType;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubCreateOptions.type)
+  return type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* ClubCreateOptions::release_type() {
+  clear_has_type();
+  ::bgs::protocol::club::v1::UniqueClubType* temp = type_;
+  type_ = NULL;
+  return temp;
+}
+inline void ClubCreateOptions::set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type) {
+  delete type_;
+  type_ = type;
+  if (type) {
+    set_has_type();
+  } else {
+    clear_has_type();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubCreateOptions.type)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 2;
+inline int ClubCreateOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClubCreateOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& ClubCreateOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubCreateOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubCreateOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubCreateOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubCreateOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubCreateOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+ClubCreateOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubCreateOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+ClubCreateOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubCreateOptions.attribute)
+  return &attribute_;
+}
+
+// optional string name = 3;
+inline bool ClubCreateOptions::has_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubCreateOptions::set_has_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubCreateOptions::clear_has_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubCreateOptions::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClubCreateOptions::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubCreateOptions.name)
+  return *name_;
+}
+inline void ClubCreateOptions::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubCreateOptions.name)
+}
+inline void ClubCreateOptions::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubCreateOptions.name)
+}
+inline void ClubCreateOptions::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubCreateOptions.name)
+}
+inline ::std::string* ClubCreateOptions::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubCreateOptions.name)
+  return name_;
+}
+inline ::std::string* ClubCreateOptions::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubCreateOptions::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubCreateOptions.name)
+}
+
+// optional string description = 4;
+inline bool ClubCreateOptions::has_description() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubCreateOptions::set_has_description() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubCreateOptions::clear_has_description() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubCreateOptions::clear_description() {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_->clear();
+  }
+  clear_has_description();
+}
+inline const ::std::string& ClubCreateOptions::description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubCreateOptions.description)
+  return *description_;
+}
+inline void ClubCreateOptions::set_description(const ::std::string& value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubCreateOptions.description)
+}
+inline void ClubCreateOptions::set_description(const char* value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubCreateOptions.description)
+}
+inline void ClubCreateOptions::set_description(const char* value, size_t size) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubCreateOptions.description)
+}
+inline ::std::string* ClubCreateOptions::mutable_description() {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubCreateOptions.description)
+  return description_;
+}
+inline ::std::string* ClubCreateOptions::release_description() {
+  clear_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = description_;
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubCreateOptions::set_allocated_description(::std::string* description) {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (description) {
+    set_has_description();
+    description_ = description;
+  } else {
+    clear_has_description();
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubCreateOptions.description)
+}
+
+// optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+inline bool ClubCreateOptions::has_avatar() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubCreateOptions::set_has_avatar() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubCreateOptions::clear_has_avatar() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubCreateOptions::clear_avatar() {
+  if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+  clear_has_avatar();
+}
+inline const ::bgs::protocol::club::v1::AvatarId& ClubCreateOptions::avatar() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubCreateOptions.avatar)
+  return avatar_ != NULL ? *avatar_ : *default_instance_->avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* ClubCreateOptions::mutable_avatar() {
+  set_has_avatar();
+  if (avatar_ == NULL) avatar_ = new ::bgs::protocol::club::v1::AvatarId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubCreateOptions.avatar)
+  return avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* ClubCreateOptions::release_avatar() {
+  clear_has_avatar();
+  ::bgs::protocol::club::v1::AvatarId* temp = avatar_;
+  avatar_ = NULL;
+  return temp;
+}
+inline void ClubCreateOptions::set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar) {
+  delete avatar_;
+  avatar_ = avatar;
+  if (avatar) {
+    set_has_avatar();
+  } else {
+    clear_has_avatar();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubCreateOptions.avatar)
+}
+
+// optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+inline bool ClubCreateOptions::has_privacy_level() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClubCreateOptions::set_has_privacy_level() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClubCreateOptions::clear_has_privacy_level() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClubCreateOptions::clear_privacy_level() {
+  privacy_level_ = 0;
+  clear_has_privacy_level();
+}
+inline ::bgs::protocol::club::v1::PrivacyLevel ClubCreateOptions::privacy_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubCreateOptions.privacy_level)
+  return static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(privacy_level_);
+}
+inline void ClubCreateOptions::set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value) {
+  assert(::bgs::protocol::club::v1::PrivacyLevel_IsValid(value));
+  set_has_privacy_level();
+  privacy_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubCreateOptions.privacy_level)
+}
+
+// optional string short_name = 7;
+inline bool ClubCreateOptions::has_short_name() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClubCreateOptions::set_has_short_name() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClubCreateOptions::clear_has_short_name() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClubCreateOptions::clear_short_name() {
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_->clear();
+  }
+  clear_has_short_name();
+}
+inline const ::std::string& ClubCreateOptions::short_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubCreateOptions.short_name)
+  return *short_name_;
+}
+inline void ClubCreateOptions::set_short_name(const ::std::string& value) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubCreateOptions.short_name)
+}
+inline void ClubCreateOptions::set_short_name(const char* value) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubCreateOptions.short_name)
+}
+inline void ClubCreateOptions::set_short_name(const char* value, size_t size) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubCreateOptions.short_name)
+}
+inline ::std::string* ClubCreateOptions::mutable_short_name() {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubCreateOptions.short_name)
+  return short_name_;
+}
+inline ::std::string* ClubCreateOptions::release_short_name() {
+  clear_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = short_name_;
+    short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubCreateOptions::set_allocated_short_name(::std::string* short_name) {
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete short_name_;
+  }
+  if (short_name) {
+    set_has_short_name();
+    short_name_ = short_name;
+  } else {
+    clear_has_short_name();
+    short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubCreateOptions.short_name)
+}
+
+// optional .bgs.protocol.club.v1.CreateMemberOptions member = 10;
+inline bool ClubCreateOptions::has_member() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClubCreateOptions::set_has_member() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClubCreateOptions::clear_has_member() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClubCreateOptions::clear_member() {
+  if (member_ != NULL) member_->::bgs::protocol::club::v1::CreateMemberOptions::Clear();
+  clear_has_member();
+}
+inline const ::bgs::protocol::club::v1::CreateMemberOptions& ClubCreateOptions::member() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubCreateOptions.member)
+  return member_ != NULL ? *member_ : *default_instance_->member_;
+}
+inline ::bgs::protocol::club::v1::CreateMemberOptions* ClubCreateOptions::mutable_member() {
+  set_has_member();
+  if (member_ == NULL) member_ = new ::bgs::protocol::club::v1::CreateMemberOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubCreateOptions.member)
+  return member_;
+}
+inline ::bgs::protocol::club::v1::CreateMemberOptions* ClubCreateOptions::release_member() {
+  clear_has_member();
+  ::bgs::protocol::club::v1::CreateMemberOptions* temp = member_;
+  member_ = NULL;
+  return temp;
+}
+inline void ClubCreateOptions::set_allocated_member(::bgs::protocol::club::v1::CreateMemberOptions* member) {
+  delete member_;
+  member_ = member;
+  if (member) {
+    set_has_member();
+  } else {
+    clear_has_member();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubCreateOptions.member)
+}
+
+// optional .bgs.protocol.club.v1.CreateStreamOptions stream = 11;
+inline bool ClubCreateOptions::has_stream() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ClubCreateOptions::set_has_stream() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ClubCreateOptions::clear_has_stream() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ClubCreateOptions::clear_stream() {
+  if (stream_ != NULL) stream_->::bgs::protocol::club::v1::CreateStreamOptions::Clear();
+  clear_has_stream();
+}
+inline const ::bgs::protocol::club::v1::CreateStreamOptions& ClubCreateOptions::stream() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubCreateOptions.stream)
+  return stream_ != NULL ? *stream_ : *default_instance_->stream_;
+}
+inline ::bgs::protocol::club::v1::CreateStreamOptions* ClubCreateOptions::mutable_stream() {
+  set_has_stream();
+  if (stream_ == NULL) stream_ = new ::bgs::protocol::club::v1::CreateStreamOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubCreateOptions.stream)
+  return stream_;
+}
+inline ::bgs::protocol::club::v1::CreateStreamOptions* ClubCreateOptions::release_stream() {
+  clear_has_stream();
+  ::bgs::protocol::club::v1::CreateStreamOptions* temp = stream_;
+  stream_ = NULL;
+  return temp;
+}
+inline void ClubCreateOptions::set_allocated_stream(::bgs::protocol::club::v1::CreateStreamOptions* stream) {
+  delete stream_;
+  stream_ = stream;
+  if (stream) {
+    set_has_stream();
+  } else {
+    clear_has_stream();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubCreateOptions.stream)
+}
+
+// -------------------------------------------------------------------
+
+// Club
+
+// optional uint64 id = 1;
+inline bool Club::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Club::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Club::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Club::clear_id() {
+  id_ = GOOGLE_ULONGLONG(0);
+  clear_has_id();
+}
+inline ::google::protobuf::uint64 Club::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.id)
+  return id_;
+}
+inline void Club::set_id(::google::protobuf::uint64 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Club.id)
+}
+
+// optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+inline bool Club::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Club::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Club::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Club::clear_type() {
+  if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+  clear_has_type();
+}
+inline const ::bgs::protocol::club::v1::UniqueClubType& Club::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.type)
+  return type_ != NULL ? *type_ : *default_instance_->type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* Club::mutable_type() {
+  set_has_type();
+  if (type_ == NULL) type_ = new ::bgs::protocol::club::v1::UniqueClubType;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.type)
+  return type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* Club::release_type() {
+  clear_has_type();
+  ::bgs::protocol::club::v1::UniqueClubType* temp = type_;
+  type_ = NULL;
+  return temp;
+}
+inline void Club::set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type) {
+  delete type_;
+  type_ = type;
+  if (type) {
+    set_has_type();
+  } else {
+    clear_has_type();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Club.type)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 3;
+inline int Club::attribute_size() const {
+  return attribute_.size();
+}
+inline void Club::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& Club::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* Club::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* Club::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.Club.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+Club::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.Club.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+Club::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.Club.attribute)
+  return &attribute_;
+}
+
+// optional string name = 4;
+inline bool Club::has_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Club::set_has_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Club::clear_has_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Club::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& Club::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.name)
+  return *name_;
+}
+inline void Club::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Club.name)
+}
+inline void Club::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.Club.name)
+}
+inline void Club::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.Club.name)
+}
+inline ::std::string* Club::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.name)
+  return name_;
+}
+inline ::std::string* Club::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Club::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Club.name)
+}
+
+// optional string description = 5;
+inline bool Club::has_description() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Club::set_has_description() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Club::clear_has_description() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Club::clear_description() {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_->clear();
+  }
+  clear_has_description();
+}
+inline const ::std::string& Club::description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.description)
+  return *description_;
+}
+inline void Club::set_description(const ::std::string& value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Club.description)
+}
+inline void Club::set_description(const char* value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.Club.description)
+}
+inline void Club::set_description(const char* value, size_t size) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.Club.description)
+}
+inline ::std::string* Club::mutable_description() {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.description)
+  return description_;
+}
+inline ::std::string* Club::release_description() {
+  clear_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = description_;
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Club::set_allocated_description(::std::string* description) {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (description) {
+    set_has_description();
+    description_ = description;
+  } else {
+    clear_has_description();
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Club.description)
+}
+
+// optional .bgs.protocol.club.v1.Broadcast broadcast = 6;
+inline bool Club::has_broadcast() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Club::set_has_broadcast() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Club::clear_has_broadcast() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Club::clear_broadcast() {
+  if (broadcast_ != NULL) broadcast_->::bgs::protocol::club::v1::Broadcast::Clear();
+  clear_has_broadcast();
+}
+inline const ::bgs::protocol::club::v1::Broadcast& Club::broadcast() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.broadcast)
+  return broadcast_ != NULL ? *broadcast_ : *default_instance_->broadcast_;
+}
+inline ::bgs::protocol::club::v1::Broadcast* Club::mutable_broadcast() {
+  set_has_broadcast();
+  if (broadcast_ == NULL) broadcast_ = new ::bgs::protocol::club::v1::Broadcast;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.broadcast)
+  return broadcast_;
+}
+inline ::bgs::protocol::club::v1::Broadcast* Club::release_broadcast() {
+  clear_has_broadcast();
+  ::bgs::protocol::club::v1::Broadcast* temp = broadcast_;
+  broadcast_ = NULL;
+  return temp;
+}
+inline void Club::set_allocated_broadcast(::bgs::protocol::club::v1::Broadcast* broadcast) {
+  delete broadcast_;
+  broadcast_ = broadcast;
+  if (broadcast) {
+    set_has_broadcast();
+  } else {
+    clear_has_broadcast();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Club.broadcast)
+}
+
+// optional .bgs.protocol.club.v1.AvatarId avatar = 7;
+inline bool Club::has_avatar() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void Club::set_has_avatar() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void Club::clear_has_avatar() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void Club::clear_avatar() {
+  if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+  clear_has_avatar();
+}
+inline const ::bgs::protocol::club::v1::AvatarId& Club::avatar() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.avatar)
+  return avatar_ != NULL ? *avatar_ : *default_instance_->avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* Club::mutable_avatar() {
+  set_has_avatar();
+  if (avatar_ == NULL) avatar_ = new ::bgs::protocol::club::v1::AvatarId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.avatar)
+  return avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* Club::release_avatar() {
+  clear_has_avatar();
+  ::bgs::protocol::club::v1::AvatarId* temp = avatar_;
+  avatar_ = NULL;
+  return temp;
+}
+inline void Club::set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar) {
+  delete avatar_;
+  avatar_ = avatar;
+  if (avatar) {
+    set_has_avatar();
+  } else {
+    clear_has_avatar();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Club.avatar)
+}
+
+// optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 8;
+inline bool Club::has_privacy_level() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void Club::set_has_privacy_level() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void Club::clear_has_privacy_level() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void Club::clear_privacy_level() {
+  privacy_level_ = 0;
+  clear_has_privacy_level();
+}
+inline ::bgs::protocol::club::v1::PrivacyLevel Club::privacy_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.privacy_level)
+  return static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(privacy_level_);
+}
+inline void Club::set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value) {
+  assert(::bgs::protocol::club::v1::PrivacyLevel_IsValid(value));
+  set_has_privacy_level();
+  privacy_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Club.privacy_level)
+}
+
+// optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 9;
+inline bool Club::has_visibility_level() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void Club::set_has_visibility_level() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void Club::clear_has_visibility_level() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void Club::clear_visibility_level() {
+  visibility_level_ = 0;
+  clear_has_visibility_level();
+}
+inline ::bgs::protocol::club::v1::VisibilityLevel Club::visibility_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.visibility_level)
+  return static_cast< ::bgs::protocol::club::v1::VisibilityLevel >(visibility_level_);
+}
+inline void Club::set_visibility_level(::bgs::protocol::club::v1::VisibilityLevel value) {
+  assert(::bgs::protocol::club::v1::VisibilityLevel_IsValid(value));
+  set_has_visibility_level();
+  visibility_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Club.visibility_level)
+}
+
+// optional uint32 member_count = 10;
+inline bool Club::has_member_count() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void Club::set_has_member_count() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void Club::clear_has_member_count() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void Club::clear_member_count() {
+  member_count_ = 0u;
+  clear_has_member_count();
+}
+inline ::google::protobuf::uint32 Club::member_count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.member_count)
+  return member_count_;
+}
+inline void Club::set_member_count(::google::protobuf::uint32 value) {
+  set_has_member_count();
+  member_count_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Club.member_count)
+}
+
+// optional uint64 creation_time = 11;
+inline bool Club::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void Club::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void Club::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void Club::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 Club::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.creation_time)
+  return creation_time_;
+}
+inline void Club::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Club.creation_time)
+}
+
+// optional .bgs.protocol.club.v1.StreamPosition stream_position = 12;
+inline bool Club::has_stream_position() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void Club::set_has_stream_position() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void Club::clear_has_stream_position() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void Club::clear_stream_position() {
+  if (stream_position_ != NULL) stream_position_->::bgs::protocol::club::v1::StreamPosition::Clear();
+  clear_has_stream_position();
+}
+inline const ::bgs::protocol::club::v1::StreamPosition& Club::stream_position() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.stream_position)
+  return stream_position_ != NULL ? *stream_position_ : *default_instance_->stream_position_;
+}
+inline ::bgs::protocol::club::v1::StreamPosition* Club::mutable_stream_position() {
+  set_has_stream_position();
+  if (stream_position_ == NULL) stream_position_ = new ::bgs::protocol::club::v1::StreamPosition;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.stream_position)
+  return stream_position_;
+}
+inline ::bgs::protocol::club::v1::StreamPosition* Club::release_stream_position() {
+  clear_has_stream_position();
+  ::bgs::protocol::club::v1::StreamPosition* temp = stream_position_;
+  stream_position_ = NULL;
+  return temp;
+}
+inline void Club::set_allocated_stream_position(::bgs::protocol::club::v1::StreamPosition* stream_position) {
+  delete stream_position_;
+  stream_position_ = stream_position;
+  if (stream_position) {
+    set_has_stream_position();
+  } else {
+    clear_has_stream_position();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Club.stream_position)
+}
+
+// optional .bgs.protocol.club.v1.ClubRoleSet role_set = 13;
+inline bool Club::has_role_set() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void Club::set_has_role_set() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void Club::clear_has_role_set() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void Club::clear_role_set() {
+  if (role_set_ != NULL) role_set_->::bgs::protocol::club::v1::ClubRoleSet::Clear();
+  clear_has_role_set();
+}
+inline const ::bgs::protocol::club::v1::ClubRoleSet& Club::role_set() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.role_set)
+  return role_set_ != NULL ? *role_set_ : *default_instance_->role_set_;
+}
+inline ::bgs::protocol::club::v1::ClubRoleSet* Club::mutable_role_set() {
+  set_has_role_set();
+  if (role_set_ == NULL) role_set_ = new ::bgs::protocol::club::v1::ClubRoleSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.role_set)
+  return role_set_;
+}
+inline ::bgs::protocol::club::v1::ClubRoleSet* Club::release_role_set() {
+  clear_has_role_set();
+  ::bgs::protocol::club::v1::ClubRoleSet* temp = role_set_;
+  role_set_ = NULL;
+  return temp;
+}
+inline void Club::set_allocated_role_set(::bgs::protocol::club::v1::ClubRoleSet* role_set) {
+  delete role_set_;
+  role_set_ = role_set;
+  if (role_set) {
+    set_has_role_set();
+  } else {
+    clear_has_role_set();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Club.role_set)
+}
+
+// repeated .bgs.protocol.club.v1.MemberDescription leader = 14;
+inline int Club::leader_size() const {
+  return leader_.size();
+}
+inline void Club::clear_leader() {
+  leader_.Clear();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& Club::leader(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.leader)
+  return leader_.Get(index);
+}
+inline ::bgs::protocol::club::v1::MemberDescription* Club::mutable_leader(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.leader)
+  return leader_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::MemberDescription* Club::add_leader() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.Club.leader)
+  return leader_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription >&
+Club::leader() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.Club.leader)
+  return leader_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription >*
+Club::mutable_leader() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.Club.leader)
+  return &leader_;
+}
+
+// optional string short_name = 15;
+inline bool Club::has_short_name() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void Club::set_has_short_name() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void Club::clear_has_short_name() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void Club::clear_short_name() {
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_->clear();
+  }
+  clear_has_short_name();
+}
+inline const ::std::string& Club::short_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Club.short_name)
+  return *short_name_;
+}
+inline void Club::set_short_name(const ::std::string& value) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Club.short_name)
+}
+inline void Club::set_short_name(const char* value) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.Club.short_name)
+}
+inline void Club::set_short_name(const char* value, size_t size) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.Club.short_name)
+}
+inline ::std::string* Club::mutable_short_name() {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Club.short_name)
+  return short_name_;
+}
+inline ::std::string* Club::release_short_name() {
+  clear_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = short_name_;
+    short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Club::set_allocated_short_name(::std::string* short_name) {
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete short_name_;
+  }
+  if (short_name) {
+    set_has_short_name();
+    short_name_ = short_name;
+  } else {
+    clear_has_short_name();
+    short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Club.short_name)
+}
+
+// -------------------------------------------------------------------
+
+// ClubDescription
+
+// optional uint64 id = 1;
+inline bool ClubDescription::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubDescription::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubDescription::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubDescription::clear_id() {
+  id_ = GOOGLE_ULONGLONG(0);
+  clear_has_id();
+}
+inline ::google::protobuf::uint64 ClubDescription::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.id)
+  return id_;
+}
+inline void ClubDescription::set_id(::google::protobuf::uint64 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubDescription.id)
+}
+
+// optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+inline bool ClubDescription::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubDescription::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubDescription::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubDescription::clear_type() {
+  if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+  clear_has_type();
+}
+inline const ::bgs::protocol::club::v1::UniqueClubType& ClubDescription::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.type)
+  return type_ != NULL ? *type_ : *default_instance_->type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* ClubDescription::mutable_type() {
+  set_has_type();
+  if (type_ == NULL) type_ = new ::bgs::protocol::club::v1::UniqueClubType;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubDescription.type)
+  return type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* ClubDescription::release_type() {
+  clear_has_type();
+  ::bgs::protocol::club::v1::UniqueClubType* temp = type_;
+  type_ = NULL;
+  return temp;
+}
+inline void ClubDescription::set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type) {
+  delete type_;
+  type_ = type;
+  if (type) {
+    set_has_type();
+  } else {
+    clear_has_type();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubDescription.type)
+}
+
+// optional string name = 3;
+inline bool ClubDescription::has_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubDescription::set_has_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubDescription::clear_has_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubDescription::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClubDescription::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.name)
+  return *name_;
+}
+inline void ClubDescription::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubDescription.name)
+}
+inline void ClubDescription::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubDescription.name)
+}
+inline void ClubDescription::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubDescription.name)
+}
+inline ::std::string* ClubDescription::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubDescription.name)
+  return name_;
+}
+inline ::std::string* ClubDescription::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubDescription::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubDescription.name)
+}
+
+// optional string description = 4;
+inline bool ClubDescription::has_description() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubDescription::set_has_description() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubDescription::clear_has_description() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubDescription::clear_description() {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_->clear();
+  }
+  clear_has_description();
+}
+inline const ::std::string& ClubDescription::description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.description)
+  return *description_;
+}
+inline void ClubDescription::set_description(const ::std::string& value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubDescription.description)
+}
+inline void ClubDescription::set_description(const char* value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubDescription.description)
+}
+inline void ClubDescription::set_description(const char* value, size_t size) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubDescription.description)
+}
+inline ::std::string* ClubDescription::mutable_description() {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubDescription.description)
+  return description_;
+}
+inline ::std::string* ClubDescription::release_description() {
+  clear_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = description_;
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubDescription::set_allocated_description(::std::string* description) {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (description) {
+    set_has_description();
+    description_ = description;
+  } else {
+    clear_has_description();
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubDescription.description)
+}
+
+// optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+inline bool ClubDescription::has_avatar() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubDescription::set_has_avatar() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubDescription::clear_has_avatar() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubDescription::clear_avatar() {
+  if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+  clear_has_avatar();
+}
+inline const ::bgs::protocol::club::v1::AvatarId& ClubDescription::avatar() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.avatar)
+  return avatar_ != NULL ? *avatar_ : *default_instance_->avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* ClubDescription::mutable_avatar() {
+  set_has_avatar();
+  if (avatar_ == NULL) avatar_ = new ::bgs::protocol::club::v1::AvatarId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubDescription.avatar)
+  return avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* ClubDescription::release_avatar() {
+  clear_has_avatar();
+  ::bgs::protocol::club::v1::AvatarId* temp = avatar_;
+  avatar_ = NULL;
+  return temp;
+}
+inline void ClubDescription::set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar) {
+  delete avatar_;
+  avatar_ = avatar;
+  if (avatar) {
+    set_has_avatar();
+  } else {
+    clear_has_avatar();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubDescription.avatar)
+}
+
+// optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+inline bool ClubDescription::has_privacy_level() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClubDescription::set_has_privacy_level() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClubDescription::clear_has_privacy_level() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClubDescription::clear_privacy_level() {
+  privacy_level_ = 0;
+  clear_has_privacy_level();
+}
+inline ::bgs::protocol::club::v1::PrivacyLevel ClubDescription::privacy_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.privacy_level)
+  return static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(privacy_level_);
+}
+inline void ClubDescription::set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value) {
+  assert(::bgs::protocol::club::v1::PrivacyLevel_IsValid(value));
+  set_has_privacy_level();
+  privacy_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubDescription.privacy_level)
+}
+
+// optional .bgs.protocol.club.v1.VisibilityLevel visibility_level = 7;
+inline bool ClubDescription::has_visibility_level() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClubDescription::set_has_visibility_level() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClubDescription::clear_has_visibility_level() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClubDescription::clear_visibility_level() {
+  visibility_level_ = 0;
+  clear_has_visibility_level();
+}
+inline ::bgs::protocol::club::v1::VisibilityLevel ClubDescription::visibility_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.visibility_level)
+  return static_cast< ::bgs::protocol::club::v1::VisibilityLevel >(visibility_level_);
+}
+inline void ClubDescription::set_visibility_level(::bgs::protocol::club::v1::VisibilityLevel value) {
+  assert(::bgs::protocol::club::v1::VisibilityLevel_IsValid(value));
+  set_has_visibility_level();
+  visibility_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubDescription.visibility_level)
+}
+
+// optional uint32 member_count = 8;
+inline bool ClubDescription::has_member_count() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClubDescription::set_has_member_count() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClubDescription::clear_has_member_count() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClubDescription::clear_member_count() {
+  member_count_ = 0u;
+  clear_has_member_count();
+}
+inline ::google::protobuf::uint32 ClubDescription::member_count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.member_count)
+  return member_count_;
+}
+inline void ClubDescription::set_member_count(::google::protobuf::uint32 value) {
+  set_has_member_count();
+  member_count_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubDescription.member_count)
+}
+
+// repeated .bgs.protocol.club.v1.MemberDescription leader = 9;
+inline int ClubDescription::leader_size() const {
+  return leader_.size();
+}
+inline void ClubDescription::clear_leader() {
+  leader_.Clear();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& ClubDescription::leader(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.leader)
+  return leader_.Get(index);
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubDescription::mutable_leader(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubDescription.leader)
+  return leader_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubDescription::add_leader() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubDescription.leader)
+  return leader_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription >&
+ClubDescription::leader() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubDescription.leader)
+  return leader_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberDescription >*
+ClubDescription::mutable_leader() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubDescription.leader)
+  return &leader_;
+}
+
+// optional uint64 creation_time = 10;
+inline bool ClubDescription::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ClubDescription::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ClubDescription::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ClubDescription::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 ClubDescription::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubDescription.creation_time)
+  return creation_time_;
+}
+inline void ClubDescription::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubDescription.creation_time)
+}
+
+// -------------------------------------------------------------------
+
+// ClubView
+
+// optional uint64 club_id = 1;
+inline bool ClubView::has_club_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubView::set_has_club_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubView::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubView::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 ClubView::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubView.club_id)
+  return club_id_;
+}
+inline void ClubView::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubView.club_id)
+}
+
+// optional .bgs.protocol.ViewMarker marker = 2;
+inline bool ClubView::has_marker() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubView::set_has_marker() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubView::clear_has_marker() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubView::clear_marker() {
+  if (marker_ != NULL) marker_->::bgs::protocol::ViewMarker::Clear();
+  clear_has_marker();
+}
+inline const ::bgs::protocol::ViewMarker& ClubView::marker() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubView.marker)
+  return marker_ != NULL ? *marker_ : *default_instance_->marker_;
+}
+inline ::bgs::protocol::ViewMarker* ClubView::mutable_marker() {
+  set_has_marker();
+  if (marker_ == NULL) marker_ = new ::bgs::protocol::ViewMarker;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubView.marker)
+  return marker_;
+}
+inline ::bgs::protocol::ViewMarker* ClubView::release_marker() {
+  clear_has_marker();
+  ::bgs::protocol::ViewMarker* temp = marker_;
+  marker_ = NULL;
+  return temp;
+}
+inline void ClubView::set_allocated_marker(::bgs::protocol::ViewMarker* marker) {
+  delete marker_;
+  marker_ = marker;
+  if (marker) {
+    set_has_marker();
+  } else {
+    clear_has_marker();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubView.marker)
+}
+
+// -------------------------------------------------------------------
+
+// ClubStateOptions
+
+// repeated .bgs.protocol.v2.Attribute attribute = 1;
+inline int ClubStateOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClubStateOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& ClubStateOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubStateOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubStateOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubStateOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+ClubStateOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubStateOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+ClubStateOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubStateOptions.attribute)
+  return &attribute_;
+}
+
+// optional string name = 2;
+inline bool ClubStateOptions::has_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubStateOptions::set_has_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubStateOptions::clear_has_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubStateOptions::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClubStateOptions::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateOptions.name)
+  return *name_;
+}
+inline void ClubStateOptions::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubStateOptions.name)
+}
+inline void ClubStateOptions::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubStateOptions.name)
+}
+inline void ClubStateOptions::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubStateOptions.name)
+}
+inline ::std::string* ClubStateOptions::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateOptions.name)
+  return name_;
+}
+inline ::std::string* ClubStateOptions::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubStateOptions::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateOptions.name)
+}
+
+// optional string description = 3;
+inline bool ClubStateOptions::has_description() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubStateOptions::set_has_description() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubStateOptions::clear_has_description() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubStateOptions::clear_description() {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_->clear();
+  }
+  clear_has_description();
+}
+inline const ::std::string& ClubStateOptions::description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateOptions.description)
+  return *description_;
+}
+inline void ClubStateOptions::set_description(const ::std::string& value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubStateOptions.description)
+}
+inline void ClubStateOptions::set_description(const char* value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubStateOptions.description)
+}
+inline void ClubStateOptions::set_description(const char* value, size_t size) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubStateOptions.description)
+}
+inline ::std::string* ClubStateOptions::mutable_description() {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateOptions.description)
+  return description_;
+}
+inline ::std::string* ClubStateOptions::release_description() {
+  clear_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = description_;
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubStateOptions::set_allocated_description(::std::string* description) {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (description) {
+    set_has_description();
+    description_ = description;
+  } else {
+    clear_has_description();
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateOptions.description)
+}
+
+// optional .bgs.protocol.club.v1.SetBroadcastOptions broadcast = 4;
+inline bool ClubStateOptions::has_broadcast() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubStateOptions::set_has_broadcast() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubStateOptions::clear_has_broadcast() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubStateOptions::clear_broadcast() {
+  if (broadcast_ != NULL) broadcast_->::bgs::protocol::club::v1::SetBroadcastOptions::Clear();
+  clear_has_broadcast();
+}
+inline const ::bgs::protocol::club::v1::SetBroadcastOptions& ClubStateOptions::broadcast() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateOptions.broadcast)
+  return broadcast_ != NULL ? *broadcast_ : *default_instance_->broadcast_;
+}
+inline ::bgs::protocol::club::v1::SetBroadcastOptions* ClubStateOptions::mutable_broadcast() {
+  set_has_broadcast();
+  if (broadcast_ == NULL) broadcast_ = new ::bgs::protocol::club::v1::SetBroadcastOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateOptions.broadcast)
+  return broadcast_;
+}
+inline ::bgs::protocol::club::v1::SetBroadcastOptions* ClubStateOptions::release_broadcast() {
+  clear_has_broadcast();
+  ::bgs::protocol::club::v1::SetBroadcastOptions* temp = broadcast_;
+  broadcast_ = NULL;
+  return temp;
+}
+inline void ClubStateOptions::set_allocated_broadcast(::bgs::protocol::club::v1::SetBroadcastOptions* broadcast) {
+  delete broadcast_;
+  broadcast_ = broadcast;
+  if (broadcast) {
+    set_has_broadcast();
+  } else {
+    clear_has_broadcast();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateOptions.broadcast)
+}
+
+// optional .bgs.protocol.club.v1.AvatarId avatar = 5;
+inline bool ClubStateOptions::has_avatar() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubStateOptions::set_has_avatar() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubStateOptions::clear_has_avatar() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubStateOptions::clear_avatar() {
+  if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+  clear_has_avatar();
+}
+inline const ::bgs::protocol::club::v1::AvatarId& ClubStateOptions::avatar() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateOptions.avatar)
+  return avatar_ != NULL ? *avatar_ : *default_instance_->avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* ClubStateOptions::mutable_avatar() {
+  set_has_avatar();
+  if (avatar_ == NULL) avatar_ = new ::bgs::protocol::club::v1::AvatarId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateOptions.avatar)
+  return avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* ClubStateOptions::release_avatar() {
+  clear_has_avatar();
+  ::bgs::protocol::club::v1::AvatarId* temp = avatar_;
+  avatar_ = NULL;
+  return temp;
+}
+inline void ClubStateOptions::set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar) {
+  delete avatar_;
+  avatar_ = avatar;
+  if (avatar) {
+    set_has_avatar();
+  } else {
+    clear_has_avatar();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateOptions.avatar)
+}
+
+// optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 6;
+inline bool ClubStateOptions::has_privacy_level() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClubStateOptions::set_has_privacy_level() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClubStateOptions::clear_has_privacy_level() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClubStateOptions::clear_privacy_level() {
+  privacy_level_ = 0;
+  clear_has_privacy_level();
+}
+inline ::bgs::protocol::club::v1::PrivacyLevel ClubStateOptions::privacy_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateOptions.privacy_level)
+  return static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(privacy_level_);
+}
+inline void ClubStateOptions::set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value) {
+  assert(::bgs::protocol::club::v1::PrivacyLevel_IsValid(value));
+  set_has_privacy_level();
+  privacy_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubStateOptions.privacy_level)
+}
+
+// optional .bgs.protocol.club.v1.StreamPosition stream_position = 7;
+inline bool ClubStateOptions::has_stream_position() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClubStateOptions::set_has_stream_position() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClubStateOptions::clear_has_stream_position() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClubStateOptions::clear_stream_position() {
+  if (stream_position_ != NULL) stream_position_->::bgs::protocol::club::v1::StreamPosition::Clear();
+  clear_has_stream_position();
+}
+inline const ::bgs::protocol::club::v1::StreamPosition& ClubStateOptions::stream_position() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateOptions.stream_position)
+  return stream_position_ != NULL ? *stream_position_ : *default_instance_->stream_position_;
+}
+inline ::bgs::protocol::club::v1::StreamPosition* ClubStateOptions::mutable_stream_position() {
+  set_has_stream_position();
+  if (stream_position_ == NULL) stream_position_ = new ::bgs::protocol::club::v1::StreamPosition;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateOptions.stream_position)
+  return stream_position_;
+}
+inline ::bgs::protocol::club::v1::StreamPosition* ClubStateOptions::release_stream_position() {
+  clear_has_stream_position();
+  ::bgs::protocol::club::v1::StreamPosition* temp = stream_position_;
+  stream_position_ = NULL;
+  return temp;
+}
+inline void ClubStateOptions::set_allocated_stream_position(::bgs::protocol::club::v1::StreamPosition* stream_position) {
+  delete stream_position_;
+  stream_position_ = stream_position;
+  if (stream_position) {
+    set_has_stream_position();
+  } else {
+    clear_has_stream_position();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateOptions.stream_position)
+}
+
+// optional string short_name = 8;
+inline bool ClubStateOptions::has_short_name() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClubStateOptions::set_has_short_name() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClubStateOptions::clear_has_short_name() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClubStateOptions::clear_short_name() {
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_->clear();
+  }
+  clear_has_short_name();
+}
+inline const ::std::string& ClubStateOptions::short_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateOptions.short_name)
+  return *short_name_;
+}
+inline void ClubStateOptions::set_short_name(const ::std::string& value) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubStateOptions.short_name)
+}
+inline void ClubStateOptions::set_short_name(const char* value) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubStateOptions.short_name)
+}
+inline void ClubStateOptions::set_short_name(const char* value, size_t size) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubStateOptions.short_name)
+}
+inline ::std::string* ClubStateOptions::mutable_short_name() {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateOptions.short_name)
+  return short_name_;
+}
+inline ::std::string* ClubStateOptions::release_short_name() {
+  clear_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = short_name_;
+    short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubStateOptions::set_allocated_short_name(::std::string* short_name) {
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete short_name_;
+  }
+  if (short_name) {
+    set_has_short_name();
+    short_name_ = short_name;
+  } else {
+    clear_has_short_name();
+    short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateOptions.short_name)
+}
+
+// -------------------------------------------------------------------
+
+// ClubStateAssignment
+
+// optional uint64 club_id = 1;
+inline bool ClubStateAssignment::has_club_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubStateAssignment::set_has_club_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubStateAssignment::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubStateAssignment::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 ClubStateAssignment::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateAssignment.club_id)
+  return club_id_;
+}
+inline void ClubStateAssignment::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubStateAssignment.club_id)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 2;
+inline int ClubStateAssignment::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClubStateAssignment::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& ClubStateAssignment::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateAssignment.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubStateAssignment::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateAssignment.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubStateAssignment::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubStateAssignment.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+ClubStateAssignment::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubStateAssignment.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+ClubStateAssignment::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubStateAssignment.attribute)
+  return &attribute_;
+}
+
+// optional string name = 3;
+inline bool ClubStateAssignment::has_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubStateAssignment::set_has_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubStateAssignment::clear_has_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubStateAssignment::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ClubStateAssignment::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateAssignment.name)
+  return *name_;
+}
+inline void ClubStateAssignment::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubStateAssignment.name)
+}
+inline void ClubStateAssignment::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubStateAssignment.name)
+}
+inline void ClubStateAssignment::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubStateAssignment.name)
+}
+inline ::std::string* ClubStateAssignment::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateAssignment.name)
+  return name_;
+}
+inline ::std::string* ClubStateAssignment::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubStateAssignment::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateAssignment.name)
+}
+
+// optional string description = 4;
+inline bool ClubStateAssignment::has_description() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubStateAssignment::set_has_description() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubStateAssignment::clear_has_description() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubStateAssignment::clear_description() {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_->clear();
+  }
+  clear_has_description();
+}
+inline const ::std::string& ClubStateAssignment::description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateAssignment.description)
+  return *description_;
+}
+inline void ClubStateAssignment::set_description(const ::std::string& value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubStateAssignment.description)
+}
+inline void ClubStateAssignment::set_description(const char* value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubStateAssignment.description)
+}
+inline void ClubStateAssignment::set_description(const char* value, size_t size) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubStateAssignment.description)
+}
+inline ::std::string* ClubStateAssignment::mutable_description() {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateAssignment.description)
+  return description_;
+}
+inline ::std::string* ClubStateAssignment::release_description() {
+  clear_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = description_;
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubStateAssignment::set_allocated_description(::std::string* description) {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (description) {
+    set_has_description();
+    description_ = description;
+  } else {
+    clear_has_description();
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateAssignment.description)
+}
+
+// optional .bgs.protocol.club.v1.Broadcast broadcast = 5;
+inline bool ClubStateAssignment::has_broadcast() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubStateAssignment::set_has_broadcast() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubStateAssignment::clear_has_broadcast() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubStateAssignment::clear_broadcast() {
+  if (broadcast_ != NULL) broadcast_->::bgs::protocol::club::v1::Broadcast::Clear();
+  clear_has_broadcast();
+}
+inline const ::bgs::protocol::club::v1::Broadcast& ClubStateAssignment::broadcast() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateAssignment.broadcast)
+  return broadcast_ != NULL ? *broadcast_ : *default_instance_->broadcast_;
+}
+inline ::bgs::protocol::club::v1::Broadcast* ClubStateAssignment::mutable_broadcast() {
+  set_has_broadcast();
+  if (broadcast_ == NULL) broadcast_ = new ::bgs::protocol::club::v1::Broadcast;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateAssignment.broadcast)
+  return broadcast_;
+}
+inline ::bgs::protocol::club::v1::Broadcast* ClubStateAssignment::release_broadcast() {
+  clear_has_broadcast();
+  ::bgs::protocol::club::v1::Broadcast* temp = broadcast_;
+  broadcast_ = NULL;
+  return temp;
+}
+inline void ClubStateAssignment::set_allocated_broadcast(::bgs::protocol::club::v1::Broadcast* broadcast) {
+  delete broadcast_;
+  broadcast_ = broadcast;
+  if (broadcast) {
+    set_has_broadcast();
+  } else {
+    clear_has_broadcast();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateAssignment.broadcast)
+}
+
+// optional .bgs.protocol.club.v1.AvatarId avatar = 6;
+inline bool ClubStateAssignment::has_avatar() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClubStateAssignment::set_has_avatar() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClubStateAssignment::clear_has_avatar() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClubStateAssignment::clear_avatar() {
+  if (avatar_ != NULL) avatar_->::bgs::protocol::club::v1::AvatarId::Clear();
+  clear_has_avatar();
+}
+inline const ::bgs::protocol::club::v1::AvatarId& ClubStateAssignment::avatar() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateAssignment.avatar)
+  return avatar_ != NULL ? *avatar_ : *default_instance_->avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* ClubStateAssignment::mutable_avatar() {
+  set_has_avatar();
+  if (avatar_ == NULL) avatar_ = new ::bgs::protocol::club::v1::AvatarId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateAssignment.avatar)
+  return avatar_;
+}
+inline ::bgs::protocol::club::v1::AvatarId* ClubStateAssignment::release_avatar() {
+  clear_has_avatar();
+  ::bgs::protocol::club::v1::AvatarId* temp = avatar_;
+  avatar_ = NULL;
+  return temp;
+}
+inline void ClubStateAssignment::set_allocated_avatar(::bgs::protocol::club::v1::AvatarId* avatar) {
+  delete avatar_;
+  avatar_ = avatar;
+  if (avatar) {
+    set_has_avatar();
+  } else {
+    clear_has_avatar();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateAssignment.avatar)
+}
+
+// optional .bgs.protocol.club.v1.PrivacyLevel privacy_level = 7;
+inline bool ClubStateAssignment::has_privacy_level() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClubStateAssignment::set_has_privacy_level() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClubStateAssignment::clear_has_privacy_level() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClubStateAssignment::clear_privacy_level() {
+  privacy_level_ = 0;
+  clear_has_privacy_level();
+}
+inline ::bgs::protocol::club::v1::PrivacyLevel ClubStateAssignment::privacy_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateAssignment.privacy_level)
+  return static_cast< ::bgs::protocol::club::v1::PrivacyLevel >(privacy_level_);
+}
+inline void ClubStateAssignment::set_privacy_level(::bgs::protocol::club::v1::PrivacyLevel value) {
+  assert(::bgs::protocol::club::v1::PrivacyLevel_IsValid(value));
+  set_has_privacy_level();
+  privacy_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubStateAssignment.privacy_level)
+}
+
+// optional .bgs.protocol.club.v1.StreamPosition stream_position = 8;
+inline bool ClubStateAssignment::has_stream_position() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClubStateAssignment::set_has_stream_position() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClubStateAssignment::clear_has_stream_position() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClubStateAssignment::clear_stream_position() {
+  if (stream_position_ != NULL) stream_position_->::bgs::protocol::club::v1::StreamPosition::Clear();
+  clear_has_stream_position();
+}
+inline const ::bgs::protocol::club::v1::StreamPosition& ClubStateAssignment::stream_position() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateAssignment.stream_position)
+  return stream_position_ != NULL ? *stream_position_ : *default_instance_->stream_position_;
+}
+inline ::bgs::protocol::club::v1::StreamPosition* ClubStateAssignment::mutable_stream_position() {
+  set_has_stream_position();
+  if (stream_position_ == NULL) stream_position_ = new ::bgs::protocol::club::v1::StreamPosition;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateAssignment.stream_position)
+  return stream_position_;
+}
+inline ::bgs::protocol::club::v1::StreamPosition* ClubStateAssignment::release_stream_position() {
+  clear_has_stream_position();
+  ::bgs::protocol::club::v1::StreamPosition* temp = stream_position_;
+  stream_position_ = NULL;
+  return temp;
+}
+inline void ClubStateAssignment::set_allocated_stream_position(::bgs::protocol::club::v1::StreamPosition* stream_position) {
+  delete stream_position_;
+  stream_position_ = stream_position;
+  if (stream_position) {
+    set_has_stream_position();
+  } else {
+    clear_has_stream_position();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateAssignment.stream_position)
+}
+
+// optional string short_name = 9;
+inline bool ClubStateAssignment::has_short_name() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ClubStateAssignment::set_has_short_name() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ClubStateAssignment::clear_has_short_name() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ClubStateAssignment::clear_short_name() {
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_->clear();
+  }
+  clear_has_short_name();
+}
+inline const ::std::string& ClubStateAssignment::short_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStateAssignment.short_name)
+  return *short_name_;
+}
+inline void ClubStateAssignment::set_short_name(const ::std::string& value) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubStateAssignment.short_name)
+}
+inline void ClubStateAssignment::set_short_name(const char* value) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubStateAssignment.short_name)
+}
+inline void ClubStateAssignment::set_short_name(const char* value, size_t size) {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  short_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubStateAssignment.short_name)
+}
+inline ::std::string* ClubStateAssignment::mutable_short_name() {
+  set_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    short_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStateAssignment.short_name)
+  return short_name_;
+}
+inline ::std::string* ClubStateAssignment::release_short_name() {
+  clear_has_short_name();
+  if (short_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = short_name_;
+    short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubStateAssignment::set_allocated_short_name(::std::string* short_name) {
+  if (short_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete short_name_;
+  }
+  if (short_name) {
+    set_has_short_name();
+    short_name_ = short_name;
+  } else {
+    clear_has_short_name();
+    short_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStateAssignment.short_name)
+}
+
+// -------------------------------------------------------------------
+
+// StreamSettings
+
+// optional uint64 stream_id = 1;
+inline bool StreamSettings::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamSettings::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamSettings::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamSettings::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamSettings::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamSettings.stream_id)
+  return stream_id_;
+}
+inline void StreamSettings::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamSettings.stream_id)
+}
+
+// optional .bgs.protocol.club.v1.StreamNotificationFilter filter = 2;
+inline bool StreamSettings::has_filter() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamSettings::set_has_filter() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamSettings::clear_has_filter() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamSettings::clear_filter() {
+  filter_ = 0;
+  clear_has_filter();
+}
+inline ::bgs::protocol::club::v1::StreamNotificationFilter StreamSettings::filter() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamSettings.filter)
+  return static_cast< ::bgs::protocol::club::v1::StreamNotificationFilter >(filter_);
+}
+inline void StreamSettings::set_filter(::bgs::protocol::club::v1::StreamNotificationFilter value) {
+  assert(::bgs::protocol::club::v1::StreamNotificationFilter_IsValid(value));
+  set_has_filter();
+  filter_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamSettings.filter)
+}
+
+// -------------------------------------------------------------------
+
+// ClubSettings
+
+// repeated .bgs.protocol.club.v1.StreamSettings stream = 1;
+inline int ClubSettings::stream_size() const {
+  return stream_.size();
+}
+inline void ClubSettings::clear_stream() {
+  stream_.Clear();
+}
+inline const ::bgs::protocol::club::v1::StreamSettings& ClubSettings::stream(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSettings.stream)
+  return stream_.Get(index);
+}
+inline ::bgs::protocol::club::v1::StreamSettings* ClubSettings::mutable_stream(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSettings.stream)
+  return stream_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::StreamSettings* ClubSettings::add_stream() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubSettings.stream)
+  return stream_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >&
+ClubSettings::stream() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubSettings.stream)
+  return stream_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >*
+ClubSettings::mutable_stream() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubSettings.stream)
+  return &stream_;
+}
+
+// optional bool stream_notification_filter_all = 2;
+inline bool ClubSettings::has_stream_notification_filter_all() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubSettings::set_has_stream_notification_filter_all() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubSettings::clear_has_stream_notification_filter_all() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubSettings::clear_stream_notification_filter_all() {
+  stream_notification_filter_all_ = false;
+  clear_has_stream_notification_filter_all();
+}
+inline bool ClubSettings::stream_notification_filter_all() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSettings.stream_notification_filter_all)
+  return stream_notification_filter_all_;
+}
+inline void ClubSettings::set_stream_notification_filter_all(bool value) {
+  set_has_stream_notification_filter_all();
+  stream_notification_filter_all_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubSettings.stream_notification_filter_all)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 3;
+inline int ClubSettings::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClubSettings::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& ClubSettings::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSettings.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubSettings::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSettings.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubSettings::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubSettings.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+ClubSettings::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubSettings.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+ClubSettings::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubSettings.attribute)
+  return &attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// ClubSettingsOptions
+
+// repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+inline int ClubSettingsOptions::stream_size() const {
+  return stream_.size();
+}
+inline void ClubSettingsOptions::clear_stream() {
+  stream_.Clear();
+}
+inline const ::bgs::protocol::club::v1::StreamSettings& ClubSettingsOptions::stream(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSettingsOptions.stream)
+  return stream_.Get(index);
+}
+inline ::bgs::protocol::club::v1::StreamSettings* ClubSettingsOptions::mutable_stream(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSettingsOptions.stream)
+  return stream_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::StreamSettings* ClubSettingsOptions::add_stream() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubSettingsOptions.stream)
+  return stream_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >&
+ClubSettingsOptions::stream() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubSettingsOptions.stream)
+  return stream_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >*
+ClubSettingsOptions::mutable_stream() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubSettingsOptions.stream)
+  return &stream_;
+}
+
+// optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+inline bool ClubSettingsOptions::has_settings() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubSettingsOptions::set_has_settings() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubSettingsOptions::clear_has_settings() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubSettingsOptions::clear_settings() {
+  if (settings_ != NULL) settings_->::bgs::protocol::club::v1::ClubSettings::Clear();
+  clear_has_settings();
+}
+inline const ::bgs::protocol::club::v1::ClubSettings& ClubSettingsOptions::settings() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSettingsOptions.settings)
+  return settings_ != NULL ? *settings_ : *default_instance_->settings_;
+}
+inline ::bgs::protocol::club::v1::ClubSettings* ClubSettingsOptions::mutable_settings() {
+  set_has_settings();
+  if (settings_ == NULL) settings_ = new ::bgs::protocol::club::v1::ClubSettings;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSettingsOptions.settings)
+  return settings_;
+}
+inline ::bgs::protocol::club::v1::ClubSettings* ClubSettingsOptions::release_settings() {
+  clear_has_settings();
+  ::bgs::protocol::club::v1::ClubSettings* temp = settings_;
+  settings_ = NULL;
+  return temp;
+}
+inline void ClubSettingsOptions::set_allocated_settings(::bgs::protocol::club::v1::ClubSettings* settings) {
+  delete settings_;
+  settings_ = settings;
+  if (settings) {
+    set_has_settings();
+  } else {
+    clear_has_settings();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubSettingsOptions.settings)
+}
+
+// optional uint32 version = 3;
+inline bool ClubSettingsOptions::has_version() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubSettingsOptions::set_has_version() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubSettingsOptions::clear_has_version() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubSettingsOptions::clear_version() {
+  version_ = 0u;
+  clear_has_version();
+}
+inline ::google::protobuf::uint32 ClubSettingsOptions::version() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSettingsOptions.version)
+  return version_;
+}
+inline void ClubSettingsOptions::set_version(::google::protobuf::uint32 value) {
+  set_has_version();
+  version_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubSettingsOptions.version)
+}
+
+// -------------------------------------------------------------------
+
+// ClubSettingsAssignment
+
+// repeated .bgs.protocol.club.v1.StreamSettings stream = 1 [deprecated = true];
+inline int ClubSettingsAssignment::stream_size() const {
+  return stream_.size();
+}
+inline void ClubSettingsAssignment::clear_stream() {
+  stream_.Clear();
+}
+inline const ::bgs::protocol::club::v1::StreamSettings& ClubSettingsAssignment::stream(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSettingsAssignment.stream)
+  return stream_.Get(index);
+}
+inline ::bgs::protocol::club::v1::StreamSettings* ClubSettingsAssignment::mutable_stream(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSettingsAssignment.stream)
+  return stream_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::StreamSettings* ClubSettingsAssignment::add_stream() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubSettingsAssignment.stream)
+  return stream_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >&
+ClubSettingsAssignment::stream() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubSettingsAssignment.stream)
+  return stream_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamSettings >*
+ClubSettingsAssignment::mutable_stream() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubSettingsAssignment.stream)
+  return &stream_;
+}
+
+// optional .bgs.protocol.club.v1.ClubSettings settings = 2;
+inline bool ClubSettingsAssignment::has_settings() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubSettingsAssignment::set_has_settings() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubSettingsAssignment::clear_has_settings() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubSettingsAssignment::clear_settings() {
+  if (settings_ != NULL) settings_->::bgs::protocol::club::v1::ClubSettings::Clear();
+  clear_has_settings();
+}
+inline const ::bgs::protocol::club::v1::ClubSettings& ClubSettingsAssignment::settings() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSettingsAssignment.settings)
+  return settings_ != NULL ? *settings_ : *default_instance_->settings_;
+}
+inline ::bgs::protocol::club::v1::ClubSettings* ClubSettingsAssignment::mutable_settings() {
+  set_has_settings();
+  if (settings_ == NULL) settings_ = new ::bgs::protocol::club::v1::ClubSettings;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSettingsAssignment.settings)
+  return settings_;
+}
+inline ::bgs::protocol::club::v1::ClubSettings* ClubSettingsAssignment::release_settings() {
+  clear_has_settings();
+  ::bgs::protocol::club::v1::ClubSettings* temp = settings_;
+  settings_ = NULL;
+  return temp;
+}
+inline void ClubSettingsAssignment::set_allocated_settings(::bgs::protocol::club::v1::ClubSettings* settings) {
+  delete settings_;
+  settings_ = settings;
+  if (settings) {
+    set_has_settings();
+  } else {
+    clear_has_settings();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubSettingsAssignment.settings)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5fcore_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_enum.pb.cc b/src/server/proto/Client/club_enum.pb.cc
new file mode 100644
index 00000000000..f20ab51302e
--- /dev/null
+++ b/src/server/proto/Client/club_enum.pb.cc
@@ -0,0 +1,250 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_enum.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_enum.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::EnumDescriptor* PrivacyLevel_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* VisibilityLevel_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* ClubRemovedReason_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* StreamVoiceLevel_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* VoiceMicrophoneState_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* PresenceLevel_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* WhisperLevel_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* StreamNotificationFilter_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5fenum_2eproto() {
+  protobuf_AddDesc_club_5fenum_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_enum.proto");
+  GOOGLE_CHECK(file != NULL);
+  PrivacyLevel_descriptor_ = file->enum_type(0);
+  VisibilityLevel_descriptor_ = file->enum_type(1);
+  ClubRemovedReason_descriptor_ = file->enum_type(2);
+  StreamVoiceLevel_descriptor_ = file->enum_type(3);
+  VoiceMicrophoneState_descriptor_ = file->enum_type(4);
+  PresenceLevel_descriptor_ = file->enum_type(5);
+  WhisperLevel_descriptor_ = file->enum_type(6);
+  StreamNotificationFilter_descriptor_ = file->enum_type(7);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5fenum_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5fenum_2eproto() {
+}
+
+void protobuf_AddDesc_club_5fenum_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\017club_enum.proto\022\024bgs.protocol.club.v1*"
+    "\202\001\n\014PrivacyLevel\022\030\n\024PRIVACY_LEVEL_CLOSED"
+    "\020\000\022!\n\035PRIVACY_LEVEL_OPEN_INVITATION\020\001\022\035\n"
+    "\031PRIVACY_LEVEL_OPEN_TICKET\020\002\022\026\n\022PRIVACY_"
+    "LEVEL_OPEN\020\003*L\n\017VisibilityLevel\022\034\n\030VISIB"
+    "ILITY_LEVEL_PRIVATE\020\000\022\033\n\027VISIBILITY_LEVE"
+    "L_PUBLIC\020\001*\262\002\n\021ClubRemovedReason\022\034\n\030CLUB"
+    "_REMOVED_REASON_NONE\020\000\022#\n\037CLUB_REMOVED_R"
+    "EASON_MEMBER_LEFT\020\001\022%\n!CLUB_REMOVED_REAS"
+    "ON_MEMBER_KICKED\020\002\022%\n!CLUB_REMOVED_REASO"
+    "N_MEMBER_BANNED\020\003\0221\n-CLUB_REMOVED_REASON"
+    "_MEMBER_REMOVED_BY_SERVICE\020\004\022+\n\'CLUB_REM"
+    "OVED_REASON_DESTROYED_BY_MEMBER\020\005\022,\n(CLU"
+    "B_REMOVED_REASON_DESTROYED_BY_SERVICE\020\006*"
+    "d\n\020StreamVoiceLevel\022\030\n\024VOICE_LEVEL_DISAB"
+    "LED\020\000\022\034\n\030VOICE_LEVEL_PUSH_TO_TALK\020\001\022\030\n\024V"
+    "OICE_LEVEL_OPEN_MIC\020\002*s\n\024VoiceMicrophone"
+    "State\022\033\n\027MICROPHONE_STATE_NORMAL\020\000\022\036\n\032MI"
+    "CROPHONE_STATE_SELF_MUTE\020\001\022\036\n\032MICROPHONE"
+    "_STATE_SELF_DEAF\020\002*[\n\rPresenceLevel\022\027\n\023P"
+    "RESENCE_LEVEL_NONE\020\000\022\030\n\024PRESENCE_LEVEL_B"
+    "ASIC\020\001\022\027\n\023PRESENCE_LEVEL_RICH\020\002*D\n\014Whisp"
+    "erLevel\022\026\n\022WHISPER_LEVEL_OPEN\020\000\022\034\n\030WHISP"
+    "ER_LEVEL_RESTRICTED\020\001*\213\001\n\030StreamNotifica"
+    "tionFilter\022#\n\037STREAM_NOTIFICATION_FILTER"
+    "_NONE\020\000\022&\n\"STREAM_NOTIFICATION_FILTER_ME"
+    "NTION\020\001\022\"\n\036STREAM_NOTIFICATION_FILTER_AL"
+    "L\020\002B\002H\001", 1087);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_enum.proto", &protobuf_RegisterTypes);
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5fenum_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5fenum_2eproto {
+  StaticDescriptorInitializer_club_5fenum_2eproto() {
+    protobuf_AddDesc_club_5fenum_2eproto();
+  }
+} static_descriptor_initializer_club_5fenum_2eproto_;
+const ::google::protobuf::EnumDescriptor* PrivacyLevel_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PrivacyLevel_descriptor_;
+}
+bool PrivacyLevel_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* VisibilityLevel_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return VisibilityLevel_descriptor_;
+}
+bool VisibilityLevel_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* ClubRemovedReason_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubRemovedReason_descriptor_;
+}
+bool ClubRemovedReason_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* StreamVoiceLevel_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamVoiceLevel_descriptor_;
+}
+bool StreamVoiceLevel_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* VoiceMicrophoneState_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return VoiceMicrophoneState_descriptor_;
+}
+bool VoiceMicrophoneState_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* PresenceLevel_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PresenceLevel_descriptor_;
+}
+bool PresenceLevel_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* WhisperLevel_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return WhisperLevel_descriptor_;
+}
+bool WhisperLevel_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* StreamNotificationFilter_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamNotificationFilter_descriptor_;
+}
+bool StreamNotificationFilter_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_enum.pb.h b/src/server/proto/Client/club_enum.pb.h
new file mode 100644
index 00000000000..6705419c687
--- /dev/null
+++ b/src/server/proto/Client/club_enum.pb.h
@@ -0,0 +1,273 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_enum.proto
+
+#ifndef PROTOBUF_club_5fenum_2eproto__INCLUDED
+#define PROTOBUF_club_5fenum_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5fenum_2eproto();
+void protobuf_AssignDesc_club_5fenum_2eproto();
+void protobuf_ShutdownFile_club_5fenum_2eproto();
+
+
+enum PrivacyLevel {
+  PRIVACY_LEVEL_CLOSED = 0,
+  PRIVACY_LEVEL_OPEN_INVITATION = 1,
+  PRIVACY_LEVEL_OPEN_TICKET = 2,
+  PRIVACY_LEVEL_OPEN = 3
+};
+TC_PROTO_API bool PrivacyLevel_IsValid(int value);
+const PrivacyLevel PrivacyLevel_MIN = PRIVACY_LEVEL_CLOSED;
+const PrivacyLevel PrivacyLevel_MAX = PRIVACY_LEVEL_OPEN;
+const int PrivacyLevel_ARRAYSIZE = PrivacyLevel_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* PrivacyLevel_descriptor();
+inline const ::std::string& PrivacyLevel_Name(PrivacyLevel value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    PrivacyLevel_descriptor(), value);
+}
+inline bool PrivacyLevel_Parse(
+    const ::std::string& name, PrivacyLevel* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<PrivacyLevel>(
+    PrivacyLevel_descriptor(), name, value);
+}
+enum VisibilityLevel {
+  VISIBILITY_LEVEL_PRIVATE = 0,
+  VISIBILITY_LEVEL_PUBLIC = 1
+};
+TC_PROTO_API bool VisibilityLevel_IsValid(int value);
+const VisibilityLevel VisibilityLevel_MIN = VISIBILITY_LEVEL_PRIVATE;
+const VisibilityLevel VisibilityLevel_MAX = VISIBILITY_LEVEL_PUBLIC;
+const int VisibilityLevel_ARRAYSIZE = VisibilityLevel_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* VisibilityLevel_descriptor();
+inline const ::std::string& VisibilityLevel_Name(VisibilityLevel value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    VisibilityLevel_descriptor(), value);
+}
+inline bool VisibilityLevel_Parse(
+    const ::std::string& name, VisibilityLevel* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<VisibilityLevel>(
+    VisibilityLevel_descriptor(), name, value);
+}
+enum ClubRemovedReason {
+  CLUB_REMOVED_REASON_NONE = 0,
+  CLUB_REMOVED_REASON_MEMBER_LEFT = 1,
+  CLUB_REMOVED_REASON_MEMBER_KICKED = 2,
+  CLUB_REMOVED_REASON_MEMBER_BANNED = 3,
+  CLUB_REMOVED_REASON_MEMBER_REMOVED_BY_SERVICE = 4,
+  CLUB_REMOVED_REASON_DESTROYED_BY_MEMBER = 5,
+  CLUB_REMOVED_REASON_DESTROYED_BY_SERVICE = 6
+};
+TC_PROTO_API bool ClubRemovedReason_IsValid(int value);
+const ClubRemovedReason ClubRemovedReason_MIN = CLUB_REMOVED_REASON_NONE;
+const ClubRemovedReason ClubRemovedReason_MAX = CLUB_REMOVED_REASON_DESTROYED_BY_SERVICE;
+const int ClubRemovedReason_ARRAYSIZE = ClubRemovedReason_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* ClubRemovedReason_descriptor();
+inline const ::std::string& ClubRemovedReason_Name(ClubRemovedReason value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ClubRemovedReason_descriptor(), value);
+}
+inline bool ClubRemovedReason_Parse(
+    const ::std::string& name, ClubRemovedReason* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ClubRemovedReason>(
+    ClubRemovedReason_descriptor(), name, value);
+}
+enum StreamVoiceLevel {
+  VOICE_LEVEL_DISABLED = 0,
+  VOICE_LEVEL_PUSH_TO_TALK = 1,
+  VOICE_LEVEL_OPEN_MIC = 2
+};
+TC_PROTO_API bool StreamVoiceLevel_IsValid(int value);
+const StreamVoiceLevel StreamVoiceLevel_MIN = VOICE_LEVEL_DISABLED;
+const StreamVoiceLevel StreamVoiceLevel_MAX = VOICE_LEVEL_OPEN_MIC;
+const int StreamVoiceLevel_ARRAYSIZE = StreamVoiceLevel_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* StreamVoiceLevel_descriptor();
+inline const ::std::string& StreamVoiceLevel_Name(StreamVoiceLevel value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    StreamVoiceLevel_descriptor(), value);
+}
+inline bool StreamVoiceLevel_Parse(
+    const ::std::string& name, StreamVoiceLevel* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<StreamVoiceLevel>(
+    StreamVoiceLevel_descriptor(), name, value);
+}
+enum VoiceMicrophoneState {
+  MICROPHONE_STATE_NORMAL = 0,
+  MICROPHONE_STATE_SELF_MUTE = 1,
+  MICROPHONE_STATE_SELF_DEAF = 2
+};
+TC_PROTO_API bool VoiceMicrophoneState_IsValid(int value);
+const VoiceMicrophoneState VoiceMicrophoneState_MIN = MICROPHONE_STATE_NORMAL;
+const VoiceMicrophoneState VoiceMicrophoneState_MAX = MICROPHONE_STATE_SELF_DEAF;
+const int VoiceMicrophoneState_ARRAYSIZE = VoiceMicrophoneState_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* VoiceMicrophoneState_descriptor();
+inline const ::std::string& VoiceMicrophoneState_Name(VoiceMicrophoneState value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    VoiceMicrophoneState_descriptor(), value);
+}
+inline bool VoiceMicrophoneState_Parse(
+    const ::std::string& name, VoiceMicrophoneState* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<VoiceMicrophoneState>(
+    VoiceMicrophoneState_descriptor(), name, value);
+}
+enum PresenceLevel {
+  PRESENCE_LEVEL_NONE = 0,
+  PRESENCE_LEVEL_BASIC = 1,
+  PRESENCE_LEVEL_RICH = 2
+};
+TC_PROTO_API bool PresenceLevel_IsValid(int value);
+const PresenceLevel PresenceLevel_MIN = PRESENCE_LEVEL_NONE;
+const PresenceLevel PresenceLevel_MAX = PRESENCE_LEVEL_RICH;
+const int PresenceLevel_ARRAYSIZE = PresenceLevel_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* PresenceLevel_descriptor();
+inline const ::std::string& PresenceLevel_Name(PresenceLevel value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    PresenceLevel_descriptor(), value);
+}
+inline bool PresenceLevel_Parse(
+    const ::std::string& name, PresenceLevel* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<PresenceLevel>(
+    PresenceLevel_descriptor(), name, value);
+}
+enum WhisperLevel {
+  WHISPER_LEVEL_OPEN = 0,
+  WHISPER_LEVEL_RESTRICTED = 1
+};
+TC_PROTO_API bool WhisperLevel_IsValid(int value);
+const WhisperLevel WhisperLevel_MIN = WHISPER_LEVEL_OPEN;
+const WhisperLevel WhisperLevel_MAX = WHISPER_LEVEL_RESTRICTED;
+const int WhisperLevel_ARRAYSIZE = WhisperLevel_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* WhisperLevel_descriptor();
+inline const ::std::string& WhisperLevel_Name(WhisperLevel value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    WhisperLevel_descriptor(), value);
+}
+inline bool WhisperLevel_Parse(
+    const ::std::string& name, WhisperLevel* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<WhisperLevel>(
+    WhisperLevel_descriptor(), name, value);
+}
+enum StreamNotificationFilter {
+  STREAM_NOTIFICATION_FILTER_NONE = 0,
+  STREAM_NOTIFICATION_FILTER_MENTION = 1,
+  STREAM_NOTIFICATION_FILTER_ALL = 2
+};
+TC_PROTO_API bool StreamNotificationFilter_IsValid(int value);
+const StreamNotificationFilter StreamNotificationFilter_MIN = STREAM_NOTIFICATION_FILTER_NONE;
+const StreamNotificationFilter StreamNotificationFilter_MAX = STREAM_NOTIFICATION_FILTER_ALL;
+const int StreamNotificationFilter_ARRAYSIZE = StreamNotificationFilter_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* StreamNotificationFilter_descriptor();
+inline const ::std::string& StreamNotificationFilter_Name(StreamNotificationFilter value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    StreamNotificationFilter_descriptor(), value);
+}
+inline bool StreamNotificationFilter_Parse(
+    const ::std::string& name, StreamNotificationFilter* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<StreamNotificationFilter>(
+    StreamNotificationFilter_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::club::v1::PrivacyLevel> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::club::v1::PrivacyLevel>() {
+  return ::bgs::protocol::club::v1::PrivacyLevel_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::club::v1::VisibilityLevel> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::club::v1::VisibilityLevel>() {
+  return ::bgs::protocol::club::v1::VisibilityLevel_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::club::v1::ClubRemovedReason> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::club::v1::ClubRemovedReason>() {
+  return ::bgs::protocol::club::v1::ClubRemovedReason_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::club::v1::StreamVoiceLevel> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::club::v1::StreamVoiceLevel>() {
+  return ::bgs::protocol::club::v1::StreamVoiceLevel_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::club::v1::VoiceMicrophoneState> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::club::v1::VoiceMicrophoneState>() {
+  return ::bgs::protocol::club::v1::VoiceMicrophoneState_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::club::v1::PresenceLevel> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::club::v1::PresenceLevel>() {
+  return ::bgs::protocol::club::v1::PresenceLevel_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::club::v1::WhisperLevel> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::club::v1::WhisperLevel>() {
+  return ::bgs::protocol::club::v1::WhisperLevel_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::club::v1::StreamNotificationFilter> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::club::v1::StreamNotificationFilter>() {
+  return ::bgs::protocol::club::v1::StreamNotificationFilter_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5fenum_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_invitation.pb.cc b/src/server/proto/Client/club_invitation.pb.cc
new file mode 100644
index 00000000000..28ba0a6086e
--- /dev/null
+++ b/src/server/proto/Client/club_invitation.pb.cc
@@ -0,0 +1,3302 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_invitation.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_invitation.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ClubSlot_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubSlot_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendInvitationOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendInvitationOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubInvitation_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubInvitation_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendSuggestionOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendSuggestionOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubSuggestion_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubSuggestion_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateTicketOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateTicketOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubTicket_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubTicket_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5finvitation_2eproto() {
+  protobuf_AddDesc_club_5finvitation_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_invitation.proto");
+  GOOGLE_CHECK(file != NULL);
+  ClubSlot_descriptor_ = file->message_type(0);
+  static const int ClubSlot_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSlot, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSlot, default_stream_id_),
+  };
+  ClubSlot_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubSlot_descriptor_,
+      ClubSlot::default_instance_,
+      ClubSlot_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSlot, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSlot, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubSlot));
+  SendInvitationOptions_descriptor_ = file->message_type(1);
+  static const int SendInvitationOptions_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationOptions, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationOptions, slot_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationOptions, attribute_),
+  };
+  SendInvitationOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendInvitationOptions_descriptor_,
+      SendInvitationOptions::default_instance_,
+      SendInvitationOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendInvitationOptions));
+  ClubInvitation_descriptor_ = file->message_type(2);
+  static const int ClubInvitation_offsets_[9] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, inviter_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, invitee_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, club_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, slot_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, creation_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, expiration_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, suggester_),
+  };
+  ClubInvitation_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubInvitation_descriptor_,
+      ClubInvitation::default_instance_,
+      ClubInvitation_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitation, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubInvitation));
+  SendSuggestionOptions_descriptor_ = file->message_type(3);
+  static const int SendSuggestionOptions_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionOptions, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionOptions, slot_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionOptions, attribute_),
+  };
+  SendSuggestionOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendSuggestionOptions_descriptor_,
+      SendSuggestionOptions::default_instance_,
+      SendSuggestionOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendSuggestionOptions));
+  ClubSuggestion_descriptor_ = file->message_type(4);
+  static const int ClubSuggestion_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, suggester_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, suggestee_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, slot_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, creation_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, expiration_time_),
+  };
+  ClubSuggestion_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubSuggestion_descriptor_,
+      ClubSuggestion::default_instance_,
+      ClubSuggestion_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestion, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubSuggestion));
+  CreateTicketOptions_descriptor_ = file->message_type(5);
+  static const int CreateTicketOptions_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketOptions, slot_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketOptions, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketOptions, allowed_redeem_count_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketOptions, expiration_time_),
+  };
+  CreateTicketOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateTicketOptions_descriptor_,
+      CreateTicketOptions::default_instance_,
+      CreateTicketOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateTicketOptions));
+  ClubTicket_descriptor_ = file->message_type(6);
+  static const int ClubTicket_offsets_[9] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, creator_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, club_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, slot_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, current_redeem_count_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, allowed_redeem_count_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, creation_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, expiration_time_),
+  };
+  ClubTicket_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubTicket_descriptor_,
+      ClubTicket::default_instance_,
+      ClubTicket_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicket, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubTicket));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5finvitation_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubSlot_descriptor_, &ClubSlot::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendInvitationOptions_descriptor_, &SendInvitationOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubInvitation_descriptor_, &ClubInvitation::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendSuggestionOptions_descriptor_, &SendSuggestionOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubSuggestion_descriptor_, &ClubSuggestion::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateTicketOptions_descriptor_, &CreateTicketOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubTicket_descriptor_, &ClubTicket::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5finvitation_2eproto() {
+  delete ClubSlot::default_instance_;
+  delete ClubSlot_reflection_;
+  delete SendInvitationOptions::default_instance_;
+  delete SendInvitationOptions_reflection_;
+  delete ClubInvitation::default_instance_;
+  delete ClubInvitation_reflection_;
+  delete SendSuggestionOptions::default_instance_;
+  delete SendSuggestionOptions_reflection_;
+  delete ClubSuggestion::default_instance_;
+  delete ClubSuggestion_reflection_;
+  delete CreateTicketOptions::default_instance_;
+  delete CreateTicketOptions_reflection_;
+  delete ClubTicket::default_instance_;
+  delete ClubTicket_reflection_;
+}
+
+void protobuf_AddDesc_club_5finvitation_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fcore_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fmember_2eproto();
+  ::bgs::protocol::v2::protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\025club_invitation.proto\022\024bgs.protocol.cl"
+    "ub.v1\032\017club_core.proto\032\021club_member.prot"
+    "o\032#api/client/v2/attribute_types.proto\"3"
+    "\n\010ClubSlot\022\014\n\004role\030\001 \001(\r\022\031\n\021default_stre"
+    "am_id\030\002 \001(\004\"\247\001\n\025SendInvitationOptions\0221\n"
+    "\ttarget_id\030\001 \001(\0132\036.bgs.protocol.club.v1."
+    "MemberId\022,\n\004slot\030\002 \001(\0132\036.bgs.protocol.cl"
+    "ub.v1.ClubSlot\022-\n\tattribute\030\003 \003(\0132\032.bgs."
+    "protocol.v2.Attribute\"\216\003\n\016ClubInvitation"
+    "\022\n\n\002id\030\001 \001(\006\0228\n\007inviter\030\002 \001(\0132\'.bgs.prot"
+    "ocol.club.v1.MemberDescription\0228\n\007invite"
+    "e\030\003 \001(\0132\'.bgs.protocol.club.v1.MemberDes"
+    "cription\0223\n\004club\030\004 \001(\0132%.bgs.protocol.cl"
+    "ub.v1.ClubDescription\022,\n\004slot\030\005 \001(\0132\036.bg"
+    "s.protocol.club.v1.ClubSlot\022-\n\tattribute"
+    "\030\006 \003(\0132\032.bgs.protocol.v2.Attribute\022\025\n\rcr"
+    "eation_time\030\007 \001(\004\022\027\n\017expiration_time\030\010 \001"
+    "(\004\022:\n\tsuggester\030\t \001(\0132\'.bgs.protocol.clu"
+    "b.v1.MemberDescription\"\247\001\n\025SendSuggestio"
+    "nOptions\0221\n\ttarget_id\030\001 \001(\0132\036.bgs.protoc"
+    "ol.club.v1.MemberId\022,\n\004slot\030\002 \001(\0132\036.bgs."
+    "protocol.club.v1.ClubSlot\022-\n\tattribute\030\003"
+    " \003(\0132\032.bgs.protocol.v2.Attribute\"\262\002\n\016Clu"
+    "bSuggestion\022\n\n\002id\030\001 \001(\006\022\017\n\007club_id\030\002 \001(\004"
+    "\022:\n\tsuggester\030\003 \001(\0132\'.bgs.protocol.club."
+    "v1.MemberDescription\022:\n\tsuggestee\030\004 \001(\0132"
+    "\'.bgs.protocol.club.v1.MemberDescription"
+    "\022,\n\004slot\030\005 \001(\0132\036.bgs.protocol.club.v1.Cl"
+    "ubSlot\022-\n\tattribute\030\006 \003(\0132\032.bgs.protocol"
+    ".v2.Attribute\022\025\n\rcreation_time\030\007 \001(\004\022\027\n\017"
+    "expiration_time\030\010 \001(\004\"\251\001\n\023CreateTicketOp"
+    "tions\022,\n\004slot\030\001 \001(\0132\036.bgs.protocol.club."
+    "v1.ClubSlot\022-\n\tattribute\030\002 \003(\0132\032.bgs.pro"
+    "tocol.v2.Attribute\022\034\n\024allowed_redeem_cou"
+    "nt\030\003 \001(\r\022\027\n\017expiration_time\030\004 \001(\004\"\320\002\n\nCl"
+    "ubTicket\022\n\n\002id\030\001 \001(\t\0228\n\007creator\030\002 \001(\0132\'."
+    "bgs.protocol.club.v1.MemberDescription\0223"
+    "\n\004club\030\003 \001(\0132%.bgs.protocol.club.v1.Club"
+    "Description\022,\n\004slot\030\004 \001(\0132\036.bgs.protocol"
+    ".club.v1.ClubSlot\022-\n\tattribute\030\005 \003(\0132\032.b"
+    "gs.protocol.v2.Attribute\022\034\n\024current_rede"
+    "em_count\030\006 \001(\r\022\034\n\024allowed_redeem_count\030\007"
+    " \001(\r\022\025\n\rcreation_time\030\010 \001(\004\022\027\n\017expiratio"
+    "n_time\030\t \001(\004B\002H\001", 1736);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_invitation.proto", &protobuf_RegisterTypes);
+  ClubSlot::default_instance_ = new ClubSlot();
+  SendInvitationOptions::default_instance_ = new SendInvitationOptions();
+  ClubInvitation::default_instance_ = new ClubInvitation();
+  SendSuggestionOptions::default_instance_ = new SendSuggestionOptions();
+  ClubSuggestion::default_instance_ = new ClubSuggestion();
+  CreateTicketOptions::default_instance_ = new CreateTicketOptions();
+  ClubTicket::default_instance_ = new ClubTicket();
+  ClubSlot::default_instance_->InitAsDefaultInstance();
+  SendInvitationOptions::default_instance_->InitAsDefaultInstance();
+  ClubInvitation::default_instance_->InitAsDefaultInstance();
+  SendSuggestionOptions::default_instance_->InitAsDefaultInstance();
+  ClubSuggestion::default_instance_->InitAsDefaultInstance();
+  CreateTicketOptions::default_instance_->InitAsDefaultInstance();
+  ClubTicket::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5finvitation_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5finvitation_2eproto {
+  StaticDescriptorInitializer_club_5finvitation_2eproto() {
+    protobuf_AddDesc_club_5finvitation_2eproto();
+  }
+} static_descriptor_initializer_club_5finvitation_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubSlot::kRoleFieldNumber;
+const int ClubSlot::kDefaultStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+ClubSlot::ClubSlot()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubSlot)
+}
+
+void ClubSlot::InitAsDefaultInstance() {
+}
+
+ClubSlot::ClubSlot(const ClubSlot& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubSlot)
+}
+
+void ClubSlot::SharedCtor() {
+  _cached_size_ = 0;
+  role_ = 0u;
+  default_stream_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubSlot::~ClubSlot() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubSlot)
+  SharedDtor();
+}
+
+void ClubSlot::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ClubSlot::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubSlot::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSlot_descriptor_;
+}
+
+const ClubSlot& ClubSlot::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5finvitation_2eproto();
+  return *default_instance_;
+}
+
+ClubSlot* ClubSlot::default_instance_ = NULL;
+
+ClubSlot* ClubSlot::New() const {
+  return new ClubSlot;
+}
+
+void ClubSlot::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClubSlot*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(default_stream_id_, role_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubSlot::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubSlot)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 role = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &role_)));
+          set_has_role();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_default_stream_id;
+        break;
+      }
+
+      // optional uint64 default_stream_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_default_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &default_stream_id_)));
+          set_has_default_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubSlot)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubSlot)
+  return false;
+#undef DO_
+}
+
+void ClubSlot::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubSlot)
+  // optional uint32 role = 1;
+  if (has_role()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->role(), output);
+  }
+
+  // optional uint64 default_stream_id = 2;
+  if (has_default_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->default_stream_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubSlot)
+}
+
+::google::protobuf::uint8* ClubSlot::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubSlot)
+  // optional uint32 role = 1;
+  if (has_role()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->role(), target);
+  }
+
+  // optional uint64 default_stream_id = 2;
+  if (has_default_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->default_stream_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubSlot)
+  return target;
+}
+
+int ClubSlot::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 role = 1;
+    if (has_role()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->role());
+    }
+
+    // optional uint64 default_stream_id = 2;
+    if (has_default_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->default_stream_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubSlot::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubSlot* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubSlot*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubSlot::MergeFrom(const ClubSlot& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_role()) {
+      set_role(from.role());
+    }
+    if (from.has_default_stream_id()) {
+      set_default_stream_id(from.default_stream_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubSlot::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubSlot::CopyFrom(const ClubSlot& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubSlot::IsInitialized() const {
+
+  return true;
+}
+
+void ClubSlot::Swap(ClubSlot* other) {
+  if (other != this) {
+    std::swap(role_, other->role_);
+    std::swap(default_stream_id_, other->default_stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubSlot::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubSlot_descriptor_;
+  metadata.reflection = ClubSlot_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendInvitationOptions::kTargetIdFieldNumber;
+const int SendInvitationOptions::kSlotFieldNumber;
+const int SendInvitationOptions::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+SendInvitationOptions::SendInvitationOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SendInvitationOptions)
+}
+
+void SendInvitationOptions::InitAsDefaultInstance() {
+  target_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  slot_ = const_cast< ::bgs::protocol::club::v1::ClubSlot*>(&::bgs::protocol::club::v1::ClubSlot::default_instance());
+}
+
+SendInvitationOptions::SendInvitationOptions(const SendInvitationOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SendInvitationOptions)
+}
+
+void SendInvitationOptions::SharedCtor() {
+  _cached_size_ = 0;
+  target_id_ = NULL;
+  slot_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendInvitationOptions::~SendInvitationOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SendInvitationOptions)
+  SharedDtor();
+}
+
+void SendInvitationOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete target_id_;
+    delete slot_;
+  }
+}
+
+void SendInvitationOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendInvitationOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendInvitationOptions_descriptor_;
+}
+
+const SendInvitationOptions& SendInvitationOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5finvitation_2eproto();
+  return *default_instance_;
+}
+
+SendInvitationOptions* SendInvitationOptions::default_instance_ = NULL;
+
+SendInvitationOptions* SendInvitationOptions::New() const {
+  return new SendInvitationOptions;
+}
+
+void SendInvitationOptions::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_slot()) {
+      if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+    }
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendInvitationOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SendInvitationOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_slot;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_slot:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_slot()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SendInvitationOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SendInvitationOptions)
+  return false;
+#undef DO_
+}
+
+void SendInvitationOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SendInvitationOptions)
+  // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->target_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+  if (has_slot()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->slot(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SendInvitationOptions)
+}
+
+::google::protobuf::uint8* SendInvitationOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SendInvitationOptions)
+  // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->target_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+  if (has_slot()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->slot(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SendInvitationOptions)
+  return target;
+}
+
+int SendInvitationOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+    if (has_slot()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->slot());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendInvitationOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendInvitationOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendInvitationOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendInvitationOptions::MergeFrom(const SendInvitationOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.target_id());
+    }
+    if (from.has_slot()) {
+      mutable_slot()->::bgs::protocol::club::v1::ClubSlot::MergeFrom(from.slot());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendInvitationOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendInvitationOptions::CopyFrom(const SendInvitationOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendInvitationOptions::IsInitialized() const {
+
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendInvitationOptions::Swap(SendInvitationOptions* other) {
+  if (other != this) {
+    std::swap(target_id_, other->target_id_);
+    std::swap(slot_, other->slot_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendInvitationOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendInvitationOptions_descriptor_;
+  metadata.reflection = SendInvitationOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubInvitation::kIdFieldNumber;
+const int ClubInvitation::kInviterFieldNumber;
+const int ClubInvitation::kInviteeFieldNumber;
+const int ClubInvitation::kClubFieldNumber;
+const int ClubInvitation::kSlotFieldNumber;
+const int ClubInvitation::kAttributeFieldNumber;
+const int ClubInvitation::kCreationTimeFieldNumber;
+const int ClubInvitation::kExpirationTimeFieldNumber;
+const int ClubInvitation::kSuggesterFieldNumber;
+#endif  // !_MSC_VER
+
+ClubInvitation::ClubInvitation()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubInvitation)
+}
+
+void ClubInvitation::InitAsDefaultInstance() {
+  inviter_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+  invitee_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+  club_ = const_cast< ::bgs::protocol::club::v1::ClubDescription*>(&::bgs::protocol::club::v1::ClubDescription::default_instance());
+  slot_ = const_cast< ::bgs::protocol::club::v1::ClubSlot*>(&::bgs::protocol::club::v1::ClubSlot::default_instance());
+  suggester_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+}
+
+ClubInvitation::ClubInvitation(const ClubInvitation& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubInvitation)
+}
+
+void ClubInvitation::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = GOOGLE_ULONGLONG(0);
+  inviter_ = NULL;
+  invitee_ = NULL;
+  club_ = NULL;
+  slot_ = NULL;
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  suggester_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubInvitation::~ClubInvitation() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubInvitation)
+  SharedDtor();
+}
+
+void ClubInvitation::SharedDtor() {
+  if (this != default_instance_) {
+    delete inviter_;
+    delete invitee_;
+    delete club_;
+    delete slot_;
+    delete suggester_;
+  }
+}
+
+void ClubInvitation::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubInvitation::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubInvitation_descriptor_;
+}
+
+const ClubInvitation& ClubInvitation::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5finvitation_2eproto();
+  return *default_instance_;
+}
+
+ClubInvitation* ClubInvitation::default_instance_ = NULL;
+
+ClubInvitation* ClubInvitation::New() const {
+  return new ClubInvitation;
+}
+
+void ClubInvitation::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClubInvitation*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 223) {
+    ZR_(creation_time_, expiration_time_);
+    id_ = GOOGLE_ULONGLONG(0);
+    if (has_inviter()) {
+      if (inviter_ != NULL) inviter_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+    if (has_invitee()) {
+      if (invitee_ != NULL) invitee_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+    if (has_club()) {
+      if (club_ != NULL) club_->::bgs::protocol::club::v1::ClubDescription::Clear();
+    }
+    if (has_slot()) {
+      if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+    }
+  }
+  if (has_suggester()) {
+    if (suggester_ != NULL) suggester_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubInvitation::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubInvitation)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed64 id = 1;
+      case 1: {
+        if (tag == 9) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_inviter;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription inviter = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_inviter:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_inviter()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_invitee;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription invitee = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_invitee:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_invitee()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_club;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubDescription club = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_club:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_club()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_slot;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_slot:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_slot()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_attribute;
+        if (input->ExpectTag(56)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_expiration_time;
+        break;
+      }
+
+      // optional uint64 expiration_time = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_expiration_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &expiration_time_)));
+          set_has_expiration_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_suggester;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription suggester = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_suggester:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suggester()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubInvitation)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubInvitation)
+  return false;
+#undef DO_
+}
+
+void ClubInvitation::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubInvitation)
+  // optional fixed64 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription inviter = 2;
+  if (has_inviter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->inviter(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription invitee = 3;
+  if (has_invitee()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->invitee(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 4;
+  if (has_club()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->club(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+  if (has_slot()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->slot(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 6;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->attribute(i), output);
+  }
+
+  // optional uint64 creation_time = 7;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->creation_time(), output);
+  }
+
+  // optional uint64 expiration_time = 8;
+  if (has_expiration_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->expiration_time(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription suggester = 9;
+  if (has_suggester()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      9, this->suggester(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubInvitation)
+}
+
+::google::protobuf::uint8* ClubInvitation::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubInvitation)
+  // optional fixed64 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription inviter = 2;
+  if (has_inviter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->inviter(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription invitee = 3;
+  if (has_invitee()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->invitee(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 4;
+  if (has_club()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->club(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+  if (has_slot()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->slot(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 6;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->attribute(i), target);
+  }
+
+  // optional uint64 creation_time = 7;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->creation_time(), target);
+  }
+
+  // optional uint64 expiration_time = 8;
+  if (has_expiration_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->expiration_time(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription suggester = 9;
+  if (has_suggester()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        9, this->suggester(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubInvitation)
+  return target;
+}
+
+int ClubInvitation::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed64 id = 1;
+    if (has_id()) {
+      total_size += 1 + 8;
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription inviter = 2;
+    if (has_inviter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->inviter());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription invitee = 3;
+    if (has_invitee()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->invitee());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubDescription club = 4;
+    if (has_club()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->club());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+    if (has_slot()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->slot());
+    }
+
+    // optional uint64 creation_time = 7;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+    // optional uint64 expiration_time = 8;
+    if (has_expiration_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->expiration_time());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberDescription suggester = 9;
+    if (has_suggester()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suggester());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 6;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubInvitation::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubInvitation* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubInvitation*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubInvitation::MergeFrom(const ClubInvitation& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_inviter()) {
+      mutable_inviter()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.inviter());
+    }
+    if (from.has_invitee()) {
+      mutable_invitee()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.invitee());
+    }
+    if (from.has_club()) {
+      mutable_club()->::bgs::protocol::club::v1::ClubDescription::MergeFrom(from.club());
+    }
+    if (from.has_slot()) {
+      mutable_slot()->::bgs::protocol::club::v1::ClubSlot::MergeFrom(from.slot());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+    if (from.has_expiration_time()) {
+      set_expiration_time(from.expiration_time());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_suggester()) {
+      mutable_suggester()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.suggester());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubInvitation::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubInvitation::CopyFrom(const ClubInvitation& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubInvitation::IsInitialized() const {
+
+  if (has_inviter()) {
+    if (!this->inviter().IsInitialized()) return false;
+  }
+  if (has_invitee()) {
+    if (!this->invitee().IsInitialized()) return false;
+  }
+  if (has_club()) {
+    if (!this->club().IsInitialized()) return false;
+  }
+  if (has_suggester()) {
+    if (!this->suggester().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubInvitation::Swap(ClubInvitation* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(inviter_, other->inviter_);
+    std::swap(invitee_, other->invitee_);
+    std::swap(club_, other->club_);
+    std::swap(slot_, other->slot_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(expiration_time_, other->expiration_time_);
+    std::swap(suggester_, other->suggester_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubInvitation::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubInvitation_descriptor_;
+  metadata.reflection = ClubInvitation_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendSuggestionOptions::kTargetIdFieldNumber;
+const int SendSuggestionOptions::kSlotFieldNumber;
+const int SendSuggestionOptions::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+SendSuggestionOptions::SendSuggestionOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SendSuggestionOptions)
+}
+
+void SendSuggestionOptions::InitAsDefaultInstance() {
+  target_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  slot_ = const_cast< ::bgs::protocol::club::v1::ClubSlot*>(&::bgs::protocol::club::v1::ClubSlot::default_instance());
+}
+
+SendSuggestionOptions::SendSuggestionOptions(const SendSuggestionOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SendSuggestionOptions)
+}
+
+void SendSuggestionOptions::SharedCtor() {
+  _cached_size_ = 0;
+  target_id_ = NULL;
+  slot_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendSuggestionOptions::~SendSuggestionOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SendSuggestionOptions)
+  SharedDtor();
+}
+
+void SendSuggestionOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete target_id_;
+    delete slot_;
+  }
+}
+
+void SendSuggestionOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendSuggestionOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendSuggestionOptions_descriptor_;
+}
+
+const SendSuggestionOptions& SendSuggestionOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5finvitation_2eproto();
+  return *default_instance_;
+}
+
+SendSuggestionOptions* SendSuggestionOptions::default_instance_ = NULL;
+
+SendSuggestionOptions* SendSuggestionOptions::New() const {
+  return new SendSuggestionOptions;
+}
+
+void SendSuggestionOptions::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_slot()) {
+      if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+    }
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendSuggestionOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SendSuggestionOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_slot;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_slot:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_slot()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SendSuggestionOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SendSuggestionOptions)
+  return false;
+#undef DO_
+}
+
+void SendSuggestionOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SendSuggestionOptions)
+  // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->target_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+  if (has_slot()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->slot(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SendSuggestionOptions)
+}
+
+::google::protobuf::uint8* SendSuggestionOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SendSuggestionOptions)
+  // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->target_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+  if (has_slot()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->slot(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SendSuggestionOptions)
+  return target;
+}
+
+int SendSuggestionOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+    if (has_slot()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->slot());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendSuggestionOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendSuggestionOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendSuggestionOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendSuggestionOptions::MergeFrom(const SendSuggestionOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.target_id());
+    }
+    if (from.has_slot()) {
+      mutable_slot()->::bgs::protocol::club::v1::ClubSlot::MergeFrom(from.slot());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendSuggestionOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendSuggestionOptions::CopyFrom(const SendSuggestionOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendSuggestionOptions::IsInitialized() const {
+
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendSuggestionOptions::Swap(SendSuggestionOptions* other) {
+  if (other != this) {
+    std::swap(target_id_, other->target_id_);
+    std::swap(slot_, other->slot_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendSuggestionOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendSuggestionOptions_descriptor_;
+  metadata.reflection = SendSuggestionOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubSuggestion::kIdFieldNumber;
+const int ClubSuggestion::kClubIdFieldNumber;
+const int ClubSuggestion::kSuggesterFieldNumber;
+const int ClubSuggestion::kSuggesteeFieldNumber;
+const int ClubSuggestion::kSlotFieldNumber;
+const int ClubSuggestion::kAttributeFieldNumber;
+const int ClubSuggestion::kCreationTimeFieldNumber;
+const int ClubSuggestion::kExpirationTimeFieldNumber;
+#endif  // !_MSC_VER
+
+ClubSuggestion::ClubSuggestion()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubSuggestion)
+}
+
+void ClubSuggestion::InitAsDefaultInstance() {
+  suggester_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+  suggestee_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+  slot_ = const_cast< ::bgs::protocol::club::v1::ClubSlot*>(&::bgs::protocol::club::v1::ClubSlot::default_instance());
+}
+
+ClubSuggestion::ClubSuggestion(const ClubSuggestion& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubSuggestion)
+}
+
+void ClubSuggestion::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = GOOGLE_ULONGLONG(0);
+  club_id_ = GOOGLE_ULONGLONG(0);
+  suggester_ = NULL;
+  suggestee_ = NULL;
+  slot_ = NULL;
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubSuggestion::~ClubSuggestion() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubSuggestion)
+  SharedDtor();
+}
+
+void ClubSuggestion::SharedDtor() {
+  if (this != default_instance_) {
+    delete suggester_;
+    delete suggestee_;
+    delete slot_;
+  }
+}
+
+void ClubSuggestion::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubSuggestion::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSuggestion_descriptor_;
+}
+
+const ClubSuggestion& ClubSuggestion::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5finvitation_2eproto();
+  return *default_instance_;
+}
+
+ClubSuggestion* ClubSuggestion::default_instance_ = NULL;
+
+ClubSuggestion* ClubSuggestion::New() const {
+  return new ClubSuggestion;
+}
+
+void ClubSuggestion::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClubSuggestion*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 223) {
+    ZR_(id_, club_id_);
+    ZR_(creation_time_, expiration_time_);
+    if (has_suggester()) {
+      if (suggester_ != NULL) suggester_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+    if (has_suggestee()) {
+      if (suggestee_ != NULL) suggestee_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+    if (has_slot()) {
+      if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubSuggestion::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubSuggestion)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed64 id = 1;
+      case 1: {
+        if (tag == 9) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_suggester;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription suggester = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_suggester:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suggester()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_suggestee;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription suggestee = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_suggestee:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suggestee()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_slot;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_slot:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_slot()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_attribute;
+        if (input->ExpectTag(56)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_expiration_time;
+        break;
+      }
+
+      // optional uint64 expiration_time = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_expiration_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &expiration_time_)));
+          set_has_expiration_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubSuggestion)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubSuggestion)
+  return false;
+#undef DO_
+}
+
+void ClubSuggestion::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubSuggestion)
+  // optional fixed64 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription suggester = 3;
+  if (has_suggester()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->suggester(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription suggestee = 4;
+  if (has_suggestee()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->suggestee(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+  if (has_slot()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->slot(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 6;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->attribute(i), output);
+  }
+
+  // optional uint64 creation_time = 7;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->creation_time(), output);
+  }
+
+  // optional uint64 expiration_time = 8;
+  if (has_expiration_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->expiration_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubSuggestion)
+}
+
+::google::protobuf::uint8* ClubSuggestion::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubSuggestion)
+  // optional fixed64 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription suggester = 3;
+  if (has_suggester()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->suggester(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription suggestee = 4;
+  if (has_suggestee()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->suggestee(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+  if (has_slot()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->slot(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 6;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->attribute(i), target);
+  }
+
+  // optional uint64 creation_time = 7;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->creation_time(), target);
+  }
+
+  // optional uint64 expiration_time = 8;
+  if (has_expiration_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->expiration_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubSuggestion)
+  return target;
+}
+
+int ClubSuggestion::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed64 id = 1;
+    if (has_id()) {
+      total_size += 1 + 8;
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription suggester = 3;
+    if (has_suggester()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suggester());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription suggestee = 4;
+    if (has_suggestee()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suggestee());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+    if (has_slot()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->slot());
+    }
+
+    // optional uint64 creation_time = 7;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+    // optional uint64 expiration_time = 8;
+    if (has_expiration_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->expiration_time());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 6;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubSuggestion::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubSuggestion* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubSuggestion*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubSuggestion::MergeFrom(const ClubSuggestion& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_suggester()) {
+      mutable_suggester()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.suggester());
+    }
+    if (from.has_suggestee()) {
+      mutable_suggestee()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.suggestee());
+    }
+    if (from.has_slot()) {
+      mutable_slot()->::bgs::protocol::club::v1::ClubSlot::MergeFrom(from.slot());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+    if (from.has_expiration_time()) {
+      set_expiration_time(from.expiration_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubSuggestion::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubSuggestion::CopyFrom(const ClubSuggestion& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubSuggestion::IsInitialized() const {
+
+  if (has_suggester()) {
+    if (!this->suggester().IsInitialized()) return false;
+  }
+  if (has_suggestee()) {
+    if (!this->suggestee().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubSuggestion::Swap(ClubSuggestion* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(suggester_, other->suggester_);
+    std::swap(suggestee_, other->suggestee_);
+    std::swap(slot_, other->slot_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(expiration_time_, other->expiration_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubSuggestion::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubSuggestion_descriptor_;
+  metadata.reflection = ClubSuggestion_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateTicketOptions::kSlotFieldNumber;
+const int CreateTicketOptions::kAttributeFieldNumber;
+const int CreateTicketOptions::kAllowedRedeemCountFieldNumber;
+const int CreateTicketOptions::kExpirationTimeFieldNumber;
+#endif  // !_MSC_VER
+
+CreateTicketOptions::CreateTicketOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateTicketOptions)
+}
+
+void CreateTicketOptions::InitAsDefaultInstance() {
+  slot_ = const_cast< ::bgs::protocol::club::v1::ClubSlot*>(&::bgs::protocol::club::v1::ClubSlot::default_instance());
+}
+
+CreateTicketOptions::CreateTicketOptions(const CreateTicketOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateTicketOptions)
+}
+
+void CreateTicketOptions::SharedCtor() {
+  _cached_size_ = 0;
+  slot_ = NULL;
+  allowed_redeem_count_ = 0u;
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateTicketOptions::~CreateTicketOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateTicketOptions)
+  SharedDtor();
+}
+
+void CreateTicketOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete slot_;
+  }
+}
+
+void CreateTicketOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateTicketOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateTicketOptions_descriptor_;
+}
+
+const CreateTicketOptions& CreateTicketOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5finvitation_2eproto();
+  return *default_instance_;
+}
+
+CreateTicketOptions* CreateTicketOptions::default_instance_ = NULL;
+
+CreateTicketOptions* CreateTicketOptions::New() const {
+  return new CreateTicketOptions;
+}
+
+void CreateTicketOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<CreateTicketOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 13) {
+    ZR_(expiration_time_, allowed_redeem_count_);
+    if (has_slot()) {
+      if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateTicketOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateTicketOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubSlot slot = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_slot()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectTag(24)) goto parse_allowed_redeem_count;
+        break;
+      }
+
+      // optional uint32 allowed_redeem_count = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_allowed_redeem_count:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &allowed_redeem_count_)));
+          set_has_allowed_redeem_count();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_expiration_time;
+        break;
+      }
+
+      // optional uint64 expiration_time = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_expiration_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &expiration_time_)));
+          set_has_expiration_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateTicketOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateTicketOptions)
+  return false;
+#undef DO_
+}
+
+void CreateTicketOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateTicketOptions)
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 1;
+  if (has_slot()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->slot(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  // optional uint32 allowed_redeem_count = 3;
+  if (has_allowed_redeem_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->allowed_redeem_count(), output);
+  }
+
+  // optional uint64 expiration_time = 4;
+  if (has_expiration_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->expiration_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateTicketOptions)
+}
+
+::google::protobuf::uint8* CreateTicketOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateTicketOptions)
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 1;
+  if (has_slot()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->slot(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  // optional uint32 allowed_redeem_count = 3;
+  if (has_allowed_redeem_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->allowed_redeem_count(), target);
+  }
+
+  // optional uint64 expiration_time = 4;
+  if (has_expiration_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->expiration_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateTicketOptions)
+  return target;
+}
+
+int CreateTicketOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubSlot slot = 1;
+    if (has_slot()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->slot());
+    }
+
+    // optional uint32 allowed_redeem_count = 3;
+    if (has_allowed_redeem_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->allowed_redeem_count());
+    }
+
+    // optional uint64 expiration_time = 4;
+    if (has_expiration_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->expiration_time());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateTicketOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateTicketOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateTicketOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateTicketOptions::MergeFrom(const CreateTicketOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_slot()) {
+      mutable_slot()->::bgs::protocol::club::v1::ClubSlot::MergeFrom(from.slot());
+    }
+    if (from.has_allowed_redeem_count()) {
+      set_allowed_redeem_count(from.allowed_redeem_count());
+    }
+    if (from.has_expiration_time()) {
+      set_expiration_time(from.expiration_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateTicketOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateTicketOptions::CopyFrom(const CreateTicketOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateTicketOptions::IsInitialized() const {
+
+  return true;
+}
+
+void CreateTicketOptions::Swap(CreateTicketOptions* other) {
+  if (other != this) {
+    std::swap(slot_, other->slot_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(allowed_redeem_count_, other->allowed_redeem_count_);
+    std::swap(expiration_time_, other->expiration_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateTicketOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateTicketOptions_descriptor_;
+  metadata.reflection = CreateTicketOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubTicket::kIdFieldNumber;
+const int ClubTicket::kCreatorFieldNumber;
+const int ClubTicket::kClubFieldNumber;
+const int ClubTicket::kSlotFieldNumber;
+const int ClubTicket::kAttributeFieldNumber;
+const int ClubTicket::kCurrentRedeemCountFieldNumber;
+const int ClubTicket::kAllowedRedeemCountFieldNumber;
+const int ClubTicket::kCreationTimeFieldNumber;
+const int ClubTicket::kExpirationTimeFieldNumber;
+#endif  // !_MSC_VER
+
+ClubTicket::ClubTicket()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubTicket)
+}
+
+void ClubTicket::InitAsDefaultInstance() {
+  creator_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+  club_ = const_cast< ::bgs::protocol::club::v1::ClubDescription*>(&::bgs::protocol::club::v1::ClubDescription::default_instance());
+  slot_ = const_cast< ::bgs::protocol::club::v1::ClubSlot*>(&::bgs::protocol::club::v1::ClubSlot::default_instance());
+}
+
+ClubTicket::ClubTicket(const ClubTicket& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubTicket)
+}
+
+void ClubTicket::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  creator_ = NULL;
+  club_ = NULL;
+  slot_ = NULL;
+  current_redeem_count_ = 0u;
+  allowed_redeem_count_ = 0u;
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubTicket::~ClubTicket() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubTicket)
+  SharedDtor();
+}
+
+void ClubTicket::SharedDtor() {
+  if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete id_;
+  }
+  if (this != default_instance_) {
+    delete creator_;
+    delete club_;
+    delete slot_;
+  }
+}
+
+void ClubTicket::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubTicket::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubTicket_descriptor_;
+}
+
+const ClubTicket& ClubTicket::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5finvitation_2eproto();
+  return *default_instance_;
+}
+
+ClubTicket* ClubTicket::default_instance_ = NULL;
+
+ClubTicket* ClubTicket::New() const {
+  return new ClubTicket;
+}
+
+void ClubTicket::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClubTicket*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 239) {
+    ZR_(current_redeem_count_, creation_time_);
+    if (has_id()) {
+      if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        id_->clear();
+      }
+    }
+    if (has_creator()) {
+      if (creator_ != NULL) creator_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+    if (has_club()) {
+      if (club_ != NULL) club_->::bgs::protocol::club::v1::ClubDescription::Clear();
+    }
+    if (has_slot()) {
+      if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+    }
+  }
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubTicket::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubTicket)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->id().data(), this->id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "id");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_creator;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_creator:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_creator()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_club;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubDescription club = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_club:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_club()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_slot;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSlot slot = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_slot:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_slot()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_attribute;
+        if (input->ExpectTag(48)) goto parse_current_redeem_count;
+        break;
+      }
+
+      // optional uint32 current_redeem_count = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_current_redeem_count:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &current_redeem_count_)));
+          set_has_current_redeem_count();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_allowed_redeem_count;
+        break;
+      }
+
+      // optional uint32 allowed_redeem_count = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_allowed_redeem_count:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &allowed_redeem_count_)));
+          set_has_allowed_redeem_count();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_expiration_time;
+        break;
+      }
+
+      // optional uint64 expiration_time = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_expiration_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &expiration_time_)));
+          set_has_expiration_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubTicket)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubTicket)
+  return false;
+#undef DO_
+}
+
+void ClubTicket::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubTicket)
+  // optional string id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->id().data(), this->id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+  if (has_creator()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->creator(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 3;
+  if (has_club()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->club(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 4;
+  if (has_slot()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->slot(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 5;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->attribute(i), output);
+  }
+
+  // optional uint32 current_redeem_count = 6;
+  if (has_current_redeem_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->current_redeem_count(), output);
+  }
+
+  // optional uint32 allowed_redeem_count = 7;
+  if (has_allowed_redeem_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->allowed_redeem_count(), output);
+  }
+
+  // optional uint64 creation_time = 8;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->creation_time(), output);
+  }
+
+  // optional uint64 expiration_time = 9;
+  if (has_expiration_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(9, this->expiration_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubTicket)
+}
+
+::google::protobuf::uint8* ClubTicket::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubTicket)
+  // optional string id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->id().data(), this->id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+  if (has_creator()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->creator(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 3;
+  if (has_club()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->club(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 4;
+  if (has_slot()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->slot(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 5;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->attribute(i), target);
+  }
+
+  // optional uint32 current_redeem_count = 6;
+  if (has_current_redeem_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->current_redeem_count(), target);
+  }
+
+  // optional uint32 allowed_redeem_count = 7;
+  if (has_allowed_redeem_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->allowed_redeem_count(), target);
+  }
+
+  // optional uint64 creation_time = 8;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->creation_time(), target);
+  }
+
+  // optional uint64 expiration_time = 9;
+  if (has_expiration_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(9, this->expiration_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubTicket)
+  return target;
+}
+
+int ClubTicket::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+    if (has_creator()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->creator());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubDescription club = 3;
+    if (has_club()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->club());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSlot slot = 4;
+    if (has_slot()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->slot());
+    }
+
+    // optional uint32 current_redeem_count = 6;
+    if (has_current_redeem_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->current_redeem_count());
+    }
+
+    // optional uint32 allowed_redeem_count = 7;
+    if (has_allowed_redeem_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->allowed_redeem_count());
+    }
+
+    // optional uint64 creation_time = 8;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional uint64 expiration_time = 9;
+    if (has_expiration_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->expiration_time());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 5;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubTicket::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubTicket* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubTicket*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubTicket::MergeFrom(const ClubTicket& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_creator()) {
+      mutable_creator()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.creator());
+    }
+    if (from.has_club()) {
+      mutable_club()->::bgs::protocol::club::v1::ClubDescription::MergeFrom(from.club());
+    }
+    if (from.has_slot()) {
+      mutable_slot()->::bgs::protocol::club::v1::ClubSlot::MergeFrom(from.slot());
+    }
+    if (from.has_current_redeem_count()) {
+      set_current_redeem_count(from.current_redeem_count());
+    }
+    if (from.has_allowed_redeem_count()) {
+      set_allowed_redeem_count(from.allowed_redeem_count());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_expiration_time()) {
+      set_expiration_time(from.expiration_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubTicket::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubTicket::CopyFrom(const ClubTicket& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubTicket::IsInitialized() const {
+
+  if (has_creator()) {
+    if (!this->creator().IsInitialized()) return false;
+  }
+  if (has_club()) {
+    if (!this->club().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubTicket::Swap(ClubTicket* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(creator_, other->creator_);
+    std::swap(club_, other->club_);
+    std::swap(slot_, other->slot_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(current_redeem_count_, other->current_redeem_count_);
+    std::swap(allowed_redeem_count_, other->allowed_redeem_count_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(expiration_time_, other->expiration_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubTicket::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubTicket_descriptor_;
+  metadata.reflection = ClubTicket_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_invitation.pb.h b/src/server/proto/Client/club_invitation.pb.h
new file mode 100644
index 00000000000..af71c8b1b87
--- /dev/null
+++ b/src/server/proto/Client/club_invitation.pb.h
@@ -0,0 +1,2294 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_invitation.proto
+
+#ifndef PROTOBUF_club_5finvitation_2eproto__INCLUDED
+#define PROTOBUF_club_5finvitation_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "club_core.pb.h"
+#include "club_member.pb.h"
+#include "api/client/v2/attribute_types.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5finvitation_2eproto();
+void protobuf_AssignDesc_club_5finvitation_2eproto();
+void protobuf_ShutdownFile_club_5finvitation_2eproto();
+
+class ClubSlot;
+class SendInvitationOptions;
+class ClubInvitation;
+class SendSuggestionOptions;
+class ClubSuggestion;
+class CreateTicketOptions;
+class ClubTicket;
+
+// ===================================================================
+
+class TC_PROTO_API ClubSlot : public ::google::protobuf::Message {
+ public:
+  ClubSlot();
+  virtual ~ClubSlot();
+
+  ClubSlot(const ClubSlot& from);
+
+  inline ClubSlot& operator=(const ClubSlot& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubSlot& default_instance();
+
+  void Swap(ClubSlot* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubSlot* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubSlot& from);
+  void MergeFrom(const ClubSlot& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint32 role = 1;
+  inline bool has_role() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 1;
+  inline ::google::protobuf::uint32 role() const;
+  inline void set_role(::google::protobuf::uint32 value);
+
+  // optional uint64 default_stream_id = 2;
+  inline bool has_default_stream_id() const;
+  inline void clear_default_stream_id();
+  static const int kDefaultStreamIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 default_stream_id() const;
+  inline void set_default_stream_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubSlot)
+ private:
+  inline void set_has_role();
+  inline void clear_has_role();
+  inline void set_has_default_stream_id();
+  inline void clear_has_default_stream_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 default_stream_id_;
+  ::google::protobuf::uint32 role_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5finvitation_2eproto();
+  friend void protobuf_AssignDesc_club_5finvitation_2eproto();
+  friend void protobuf_ShutdownFile_club_5finvitation_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubSlot* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SendInvitationOptions : public ::google::protobuf::Message {
+ public:
+  SendInvitationOptions();
+  virtual ~SendInvitationOptions();
+
+  SendInvitationOptions(const SendInvitationOptions& from);
+
+  inline SendInvitationOptions& operator=(const SendInvitationOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SendInvitationOptions& default_instance();
+
+  void Swap(SendInvitationOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  SendInvitationOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendInvitationOptions& from);
+  void MergeFrom(const SendInvitationOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& target_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_target_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id);
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+  inline bool has_slot() const;
+  inline void clear_slot();
+  static const int kSlotFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::ClubSlot& slot() const;
+  inline ::bgs::protocol::club::v1::ClubSlot* mutable_slot();
+  inline ::bgs::protocol::club::v1::ClubSlot* release_slot();
+  inline void set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 3;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SendInvitationOptions)
+ private:
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_slot();
+  inline void clear_has_slot();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* target_id_;
+  ::bgs::protocol::club::v1::ClubSlot* slot_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5finvitation_2eproto();
+  friend void protobuf_AssignDesc_club_5finvitation_2eproto();
+  friend void protobuf_ShutdownFile_club_5finvitation_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendInvitationOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubInvitation : public ::google::protobuf::Message {
+ public:
+  ClubInvitation();
+  virtual ~ClubInvitation();
+
+  ClubInvitation(const ClubInvitation& from);
+
+  inline ClubInvitation& operator=(const ClubInvitation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubInvitation& default_instance();
+
+  void Swap(ClubInvitation* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubInvitation* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubInvitation& from);
+  void MergeFrom(const ClubInvitation& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional fixed64 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 id() const;
+  inline void set_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.MemberDescription inviter = 2;
+  inline bool has_inviter() const;
+  inline void clear_inviter();
+  static const int kInviterFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberDescription& inviter() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_inviter();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_inviter();
+  inline void set_allocated_inviter(::bgs::protocol::club::v1::MemberDescription* inviter);
+
+  // optional .bgs.protocol.club.v1.MemberDescription invitee = 3;
+  inline bool has_invitee() const;
+  inline void clear_invitee();
+  static const int kInviteeFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberDescription& invitee() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_invitee();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_invitee();
+  inline void set_allocated_invitee(::bgs::protocol::club::v1::MemberDescription* invitee);
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 4;
+  inline bool has_club() const;
+  inline void clear_club();
+  static const int kClubFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::ClubDescription& club() const;
+  inline ::bgs::protocol::club::v1::ClubDescription* mutable_club();
+  inline ::bgs::protocol::club::v1::ClubDescription* release_club();
+  inline void set_allocated_club(::bgs::protocol::club::v1::ClubDescription* club);
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+  inline bool has_slot() const;
+  inline void clear_slot();
+  static const int kSlotFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::ClubSlot& slot() const;
+  inline ::bgs::protocol::club::v1::ClubSlot* mutable_slot();
+  inline ::bgs::protocol::club::v1::ClubSlot* release_slot();
+  inline void set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 6;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 6;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional uint64 creation_time = 7;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 7;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // optional uint64 expiration_time = 8;
+  inline bool has_expiration_time() const;
+  inline void clear_expiration_time();
+  static const int kExpirationTimeFieldNumber = 8;
+  inline ::google::protobuf::uint64 expiration_time() const;
+  inline void set_expiration_time(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.MemberDescription suggester = 9;
+  inline bool has_suggester() const;
+  inline void clear_suggester();
+  static const int kSuggesterFieldNumber = 9;
+  inline const ::bgs::protocol::club::v1::MemberDescription& suggester() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_suggester();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_suggester();
+  inline void set_allocated_suggester(::bgs::protocol::club::v1::MemberDescription* suggester);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubInvitation)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_inviter();
+  inline void clear_has_inviter();
+  inline void set_has_invitee();
+  inline void clear_has_invitee();
+  inline void set_has_club();
+  inline void clear_has_club();
+  inline void set_has_slot();
+  inline void clear_has_slot();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+  inline void set_has_expiration_time();
+  inline void clear_has_expiration_time();
+  inline void set_has_suggester();
+  inline void clear_has_suggester();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 id_;
+  ::bgs::protocol::club::v1::MemberDescription* inviter_;
+  ::bgs::protocol::club::v1::MemberDescription* invitee_;
+  ::bgs::protocol::club::v1::ClubDescription* club_;
+  ::bgs::protocol::club::v1::ClubSlot* slot_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::google::protobuf::uint64 creation_time_;
+  ::google::protobuf::uint64 expiration_time_;
+  ::bgs::protocol::club::v1::MemberDescription* suggester_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5finvitation_2eproto();
+  friend void protobuf_AssignDesc_club_5finvitation_2eproto();
+  friend void protobuf_ShutdownFile_club_5finvitation_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubInvitation* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SendSuggestionOptions : public ::google::protobuf::Message {
+ public:
+  SendSuggestionOptions();
+  virtual ~SendSuggestionOptions();
+
+  SendSuggestionOptions(const SendSuggestionOptions& from);
+
+  inline SendSuggestionOptions& operator=(const SendSuggestionOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SendSuggestionOptions& default_instance();
+
+  void Swap(SendSuggestionOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  SendSuggestionOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendSuggestionOptions& from);
+  void MergeFrom(const SendSuggestionOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 1;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& target_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_target_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id);
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+  inline bool has_slot() const;
+  inline void clear_slot();
+  static const int kSlotFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::ClubSlot& slot() const;
+  inline ::bgs::protocol::club::v1::ClubSlot* mutable_slot();
+  inline ::bgs::protocol::club::v1::ClubSlot* release_slot();
+  inline void set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 3;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SendSuggestionOptions)
+ private:
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_slot();
+  inline void clear_has_slot();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* target_id_;
+  ::bgs::protocol::club::v1::ClubSlot* slot_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5finvitation_2eproto();
+  friend void protobuf_AssignDesc_club_5finvitation_2eproto();
+  friend void protobuf_ShutdownFile_club_5finvitation_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendSuggestionOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubSuggestion : public ::google::protobuf::Message {
+ public:
+  ClubSuggestion();
+  virtual ~ClubSuggestion();
+
+  ClubSuggestion(const ClubSuggestion& from);
+
+  inline ClubSuggestion& operator=(const ClubSuggestion& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubSuggestion& default_instance();
+
+  void Swap(ClubSuggestion* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubSuggestion* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubSuggestion& from);
+  void MergeFrom(const ClubSuggestion& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional fixed64 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 id() const;
+  inline void set_id(::google::protobuf::uint64 value);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.MemberDescription suggester = 3;
+  inline bool has_suggester() const;
+  inline void clear_suggester();
+  static const int kSuggesterFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberDescription& suggester() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_suggester();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_suggester();
+  inline void set_allocated_suggester(::bgs::protocol::club::v1::MemberDescription* suggester);
+
+  // optional .bgs.protocol.club.v1.MemberDescription suggestee = 4;
+  inline bool has_suggestee() const;
+  inline void clear_suggestee();
+  static const int kSuggesteeFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::MemberDescription& suggestee() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_suggestee();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_suggestee();
+  inline void set_allocated_suggestee(::bgs::protocol::club::v1::MemberDescription* suggestee);
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+  inline bool has_slot() const;
+  inline void clear_slot();
+  static const int kSlotFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::ClubSlot& slot() const;
+  inline ::bgs::protocol::club::v1::ClubSlot* mutable_slot();
+  inline ::bgs::protocol::club::v1::ClubSlot* release_slot();
+  inline void set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 6;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 6;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional uint64 creation_time = 7;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 7;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // optional uint64 expiration_time = 8;
+  inline bool has_expiration_time() const;
+  inline void clear_expiration_time();
+  static const int kExpirationTimeFieldNumber = 8;
+  inline ::google::protobuf::uint64 expiration_time() const;
+  inline void set_expiration_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubSuggestion)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_suggester();
+  inline void clear_has_suggester();
+  inline void set_has_suggestee();
+  inline void clear_has_suggestee();
+  inline void set_has_slot();
+  inline void clear_has_slot();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+  inline void set_has_expiration_time();
+  inline void clear_has_expiration_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::MemberDescription* suggester_;
+  ::bgs::protocol::club::v1::MemberDescription* suggestee_;
+  ::bgs::protocol::club::v1::ClubSlot* slot_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::google::protobuf::uint64 creation_time_;
+  ::google::protobuf::uint64 expiration_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5finvitation_2eproto();
+  friend void protobuf_AssignDesc_club_5finvitation_2eproto();
+  friend void protobuf_ShutdownFile_club_5finvitation_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubSuggestion* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateTicketOptions : public ::google::protobuf::Message {
+ public:
+  CreateTicketOptions();
+  virtual ~CreateTicketOptions();
+
+  CreateTicketOptions(const CreateTicketOptions& from);
+
+  inline CreateTicketOptions& operator=(const CreateTicketOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateTicketOptions& default_instance();
+
+  void Swap(CreateTicketOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateTicketOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateTicketOptions& from);
+  void MergeFrom(const CreateTicketOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 1;
+  inline bool has_slot() const;
+  inline void clear_slot();
+  static const int kSlotFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubSlot& slot() const;
+  inline ::bgs::protocol::club::v1::ClubSlot* mutable_slot();
+  inline ::bgs::protocol::club::v1::ClubSlot* release_slot();
+  inline void set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional uint32 allowed_redeem_count = 3;
+  inline bool has_allowed_redeem_count() const;
+  inline void clear_allowed_redeem_count();
+  static const int kAllowedRedeemCountFieldNumber = 3;
+  inline ::google::protobuf::uint32 allowed_redeem_count() const;
+  inline void set_allowed_redeem_count(::google::protobuf::uint32 value);
+
+  // optional uint64 expiration_time = 4;
+  inline bool has_expiration_time() const;
+  inline void clear_expiration_time();
+  static const int kExpirationTimeFieldNumber = 4;
+  inline ::google::protobuf::uint64 expiration_time() const;
+  inline void set_expiration_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateTicketOptions)
+ private:
+  inline void set_has_slot();
+  inline void clear_has_slot();
+  inline void set_has_allowed_redeem_count();
+  inline void clear_has_allowed_redeem_count();
+  inline void set_has_expiration_time();
+  inline void clear_has_expiration_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubSlot* slot_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::google::protobuf::uint64 expiration_time_;
+  ::google::protobuf::uint32 allowed_redeem_count_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5finvitation_2eproto();
+  friend void protobuf_AssignDesc_club_5finvitation_2eproto();
+  friend void protobuf_ShutdownFile_club_5finvitation_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateTicketOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubTicket : public ::google::protobuf::Message {
+ public:
+  ClubTicket();
+  virtual ~ClubTicket();
+
+  ClubTicket(const ClubTicket& from);
+
+  inline ClubTicket& operator=(const ClubTicket& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubTicket& default_instance();
+
+  void Swap(ClubTicket* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubTicket* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubTicket& from);
+  void MergeFrom(const ClubTicket& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::std::string& id() const;
+  inline void set_id(const ::std::string& value);
+  inline void set_id(const char* value);
+  inline void set_id(const char* value, size_t size);
+  inline ::std::string* mutable_id();
+  inline ::std::string* release_id();
+  inline void set_allocated_id(::std::string* id);
+
+  // optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+  inline bool has_creator() const;
+  inline void clear_creator();
+  static const int kCreatorFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberDescription& creator() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_creator();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_creator();
+  inline void set_allocated_creator(::bgs::protocol::club::v1::MemberDescription* creator);
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 3;
+  inline bool has_club() const;
+  inline void clear_club();
+  static const int kClubFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::ClubDescription& club() const;
+  inline ::bgs::protocol::club::v1::ClubDescription* mutable_club();
+  inline ::bgs::protocol::club::v1::ClubDescription* release_club();
+  inline void set_allocated_club(::bgs::protocol::club::v1::ClubDescription* club);
+
+  // optional .bgs.protocol.club.v1.ClubSlot slot = 4;
+  inline bool has_slot() const;
+  inline void clear_slot();
+  static const int kSlotFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::ClubSlot& slot() const;
+  inline ::bgs::protocol::club::v1::ClubSlot* mutable_slot();
+  inline ::bgs::protocol::club::v1::ClubSlot* release_slot();
+  inline void set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 5;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 5;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional uint32 current_redeem_count = 6;
+  inline bool has_current_redeem_count() const;
+  inline void clear_current_redeem_count();
+  static const int kCurrentRedeemCountFieldNumber = 6;
+  inline ::google::protobuf::uint32 current_redeem_count() const;
+  inline void set_current_redeem_count(::google::protobuf::uint32 value);
+
+  // optional uint32 allowed_redeem_count = 7;
+  inline bool has_allowed_redeem_count() const;
+  inline void clear_allowed_redeem_count();
+  static const int kAllowedRedeemCountFieldNumber = 7;
+  inline ::google::protobuf::uint32 allowed_redeem_count() const;
+  inline void set_allowed_redeem_count(::google::protobuf::uint32 value);
+
+  // optional uint64 creation_time = 8;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 8;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // optional uint64 expiration_time = 9;
+  inline bool has_expiration_time() const;
+  inline void clear_expiration_time();
+  static const int kExpirationTimeFieldNumber = 9;
+  inline ::google::protobuf::uint64 expiration_time() const;
+  inline void set_expiration_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubTicket)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_creator();
+  inline void clear_has_creator();
+  inline void set_has_club();
+  inline void clear_has_club();
+  inline void set_has_slot();
+  inline void clear_has_slot();
+  inline void set_has_current_redeem_count();
+  inline void clear_has_current_redeem_count();
+  inline void set_has_allowed_redeem_count();
+  inline void clear_has_allowed_redeem_count();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+  inline void set_has_expiration_time();
+  inline void clear_has_expiration_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* id_;
+  ::bgs::protocol::club::v1::MemberDescription* creator_;
+  ::bgs::protocol::club::v1::ClubDescription* club_;
+  ::bgs::protocol::club::v1::ClubSlot* slot_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::google::protobuf::uint32 current_redeem_count_;
+  ::google::protobuf::uint32 allowed_redeem_count_;
+  ::google::protobuf::uint64 creation_time_;
+  ::google::protobuf::uint64 expiration_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5finvitation_2eproto();
+  friend void protobuf_AssignDesc_club_5finvitation_2eproto();
+  friend void protobuf_ShutdownFile_club_5finvitation_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubTicket* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ClubSlot
+
+// optional uint32 role = 1;
+inline bool ClubSlot::has_role() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubSlot::set_has_role() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubSlot::clear_has_role() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubSlot::clear_role() {
+  role_ = 0u;
+  clear_has_role();
+}
+inline ::google::protobuf::uint32 ClubSlot::role() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSlot.role)
+  return role_;
+}
+inline void ClubSlot::set_role(::google::protobuf::uint32 value) {
+  set_has_role();
+  role_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubSlot.role)
+}
+
+// optional uint64 default_stream_id = 2;
+inline bool ClubSlot::has_default_stream_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubSlot::set_has_default_stream_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubSlot::clear_has_default_stream_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubSlot::clear_default_stream_id() {
+  default_stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_default_stream_id();
+}
+inline ::google::protobuf::uint64 ClubSlot::default_stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSlot.default_stream_id)
+  return default_stream_id_;
+}
+inline void ClubSlot::set_default_stream_id(::google::protobuf::uint64 value) {
+  set_has_default_stream_id();
+  default_stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubSlot.default_stream_id)
+}
+
+// -------------------------------------------------------------------
+
+// SendInvitationOptions
+
+// optional .bgs.protocol.club.v1.MemberId target_id = 1;
+inline bool SendInvitationOptions::has_target_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendInvitationOptions::set_has_target_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendInvitationOptions::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendInvitationOptions::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SendInvitationOptions::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendInvitationOptions.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SendInvitationOptions::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendInvitationOptions.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SendInvitationOptions::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::club::v1::MemberId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void SendInvitationOptions::set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SendInvitationOptions.target_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+inline bool SendInvitationOptions::has_slot() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SendInvitationOptions::set_has_slot() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SendInvitationOptions::clear_has_slot() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SendInvitationOptions::clear_slot() {
+  if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+  clear_has_slot();
+}
+inline const ::bgs::protocol::club::v1::ClubSlot& SendInvitationOptions::slot() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendInvitationOptions.slot)
+  return slot_ != NULL ? *slot_ : *default_instance_->slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* SendInvitationOptions::mutable_slot() {
+  set_has_slot();
+  if (slot_ == NULL) slot_ = new ::bgs::protocol::club::v1::ClubSlot;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendInvitationOptions.slot)
+  return slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* SendInvitationOptions::release_slot() {
+  clear_has_slot();
+  ::bgs::protocol::club::v1::ClubSlot* temp = slot_;
+  slot_ = NULL;
+  return temp;
+}
+inline void SendInvitationOptions::set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot) {
+  delete slot_;
+  slot_ = slot;
+  if (slot) {
+    set_has_slot();
+  } else {
+    clear_has_slot();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SendInvitationOptions.slot)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 3;
+inline int SendInvitationOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void SendInvitationOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& SendInvitationOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendInvitationOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* SendInvitationOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendInvitationOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* SendInvitationOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.SendInvitationOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+SendInvitationOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.SendInvitationOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+SendInvitationOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.SendInvitationOptions.attribute)
+  return &attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// ClubInvitation
+
+// optional fixed64 id = 1;
+inline bool ClubInvitation::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubInvitation::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubInvitation::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubInvitation::clear_id() {
+  id_ = GOOGLE_ULONGLONG(0);
+  clear_has_id();
+}
+inline ::google::protobuf::uint64 ClubInvitation::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitation.id)
+  return id_;
+}
+inline void ClubInvitation::set_id(::google::protobuf::uint64 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubInvitation.id)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription inviter = 2;
+inline bool ClubInvitation::has_inviter() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubInvitation::set_has_inviter() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubInvitation::clear_has_inviter() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubInvitation::clear_inviter() {
+  if (inviter_ != NULL) inviter_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_inviter();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& ClubInvitation::inviter() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitation.inviter)
+  return inviter_ != NULL ? *inviter_ : *default_instance_->inviter_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubInvitation::mutable_inviter() {
+  set_has_inviter();
+  if (inviter_ == NULL) inviter_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubInvitation.inviter)
+  return inviter_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubInvitation::release_inviter() {
+  clear_has_inviter();
+  ::bgs::protocol::club::v1::MemberDescription* temp = inviter_;
+  inviter_ = NULL;
+  return temp;
+}
+inline void ClubInvitation::set_allocated_inviter(::bgs::protocol::club::v1::MemberDescription* inviter) {
+  delete inviter_;
+  inviter_ = inviter;
+  if (inviter) {
+    set_has_inviter();
+  } else {
+    clear_has_inviter();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubInvitation.inviter)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription invitee = 3;
+inline bool ClubInvitation::has_invitee() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubInvitation::set_has_invitee() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubInvitation::clear_has_invitee() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubInvitation::clear_invitee() {
+  if (invitee_ != NULL) invitee_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_invitee();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& ClubInvitation::invitee() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitation.invitee)
+  return invitee_ != NULL ? *invitee_ : *default_instance_->invitee_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubInvitation::mutable_invitee() {
+  set_has_invitee();
+  if (invitee_ == NULL) invitee_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubInvitation.invitee)
+  return invitee_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubInvitation::release_invitee() {
+  clear_has_invitee();
+  ::bgs::protocol::club::v1::MemberDescription* temp = invitee_;
+  invitee_ = NULL;
+  return temp;
+}
+inline void ClubInvitation::set_allocated_invitee(::bgs::protocol::club::v1::MemberDescription* invitee) {
+  delete invitee_;
+  invitee_ = invitee;
+  if (invitee) {
+    set_has_invitee();
+  } else {
+    clear_has_invitee();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubInvitation.invitee)
+}
+
+// optional .bgs.protocol.club.v1.ClubDescription club = 4;
+inline bool ClubInvitation::has_club() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubInvitation::set_has_club() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubInvitation::clear_has_club() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubInvitation::clear_club() {
+  if (club_ != NULL) club_->::bgs::protocol::club::v1::ClubDescription::Clear();
+  clear_has_club();
+}
+inline const ::bgs::protocol::club::v1::ClubDescription& ClubInvitation::club() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitation.club)
+  return club_ != NULL ? *club_ : *default_instance_->club_;
+}
+inline ::bgs::protocol::club::v1::ClubDescription* ClubInvitation::mutable_club() {
+  set_has_club();
+  if (club_ == NULL) club_ = new ::bgs::protocol::club::v1::ClubDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubInvitation.club)
+  return club_;
+}
+inline ::bgs::protocol::club::v1::ClubDescription* ClubInvitation::release_club() {
+  clear_has_club();
+  ::bgs::protocol::club::v1::ClubDescription* temp = club_;
+  club_ = NULL;
+  return temp;
+}
+inline void ClubInvitation::set_allocated_club(::bgs::protocol::club::v1::ClubDescription* club) {
+  delete club_;
+  club_ = club;
+  if (club) {
+    set_has_club();
+  } else {
+    clear_has_club();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubInvitation.club)
+}
+
+// optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+inline bool ClubInvitation::has_slot() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubInvitation::set_has_slot() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubInvitation::clear_has_slot() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubInvitation::clear_slot() {
+  if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+  clear_has_slot();
+}
+inline const ::bgs::protocol::club::v1::ClubSlot& ClubInvitation::slot() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitation.slot)
+  return slot_ != NULL ? *slot_ : *default_instance_->slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* ClubInvitation::mutable_slot() {
+  set_has_slot();
+  if (slot_ == NULL) slot_ = new ::bgs::protocol::club::v1::ClubSlot;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubInvitation.slot)
+  return slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* ClubInvitation::release_slot() {
+  clear_has_slot();
+  ::bgs::protocol::club::v1::ClubSlot* temp = slot_;
+  slot_ = NULL;
+  return temp;
+}
+inline void ClubInvitation::set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot) {
+  delete slot_;
+  slot_ = slot;
+  if (slot) {
+    set_has_slot();
+  } else {
+    clear_has_slot();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubInvitation.slot)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 6;
+inline int ClubInvitation::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClubInvitation::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& ClubInvitation::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitation.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubInvitation::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubInvitation.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubInvitation::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubInvitation.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+ClubInvitation::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubInvitation.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+ClubInvitation::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubInvitation.attribute)
+  return &attribute_;
+}
+
+// optional uint64 creation_time = 7;
+inline bool ClubInvitation::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClubInvitation::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClubInvitation::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClubInvitation::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 ClubInvitation::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitation.creation_time)
+  return creation_time_;
+}
+inline void ClubInvitation::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubInvitation.creation_time)
+}
+
+// optional uint64 expiration_time = 8;
+inline bool ClubInvitation::has_expiration_time() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClubInvitation::set_has_expiration_time() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClubInvitation::clear_has_expiration_time() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClubInvitation::clear_expiration_time() {
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_expiration_time();
+}
+inline ::google::protobuf::uint64 ClubInvitation::expiration_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitation.expiration_time)
+  return expiration_time_;
+}
+inline void ClubInvitation::set_expiration_time(::google::protobuf::uint64 value) {
+  set_has_expiration_time();
+  expiration_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubInvitation.expiration_time)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription suggester = 9;
+inline bool ClubInvitation::has_suggester() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ClubInvitation::set_has_suggester() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ClubInvitation::clear_has_suggester() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ClubInvitation::clear_suggester() {
+  if (suggester_ != NULL) suggester_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_suggester();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& ClubInvitation::suggester() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitation.suggester)
+  return suggester_ != NULL ? *suggester_ : *default_instance_->suggester_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubInvitation::mutable_suggester() {
+  set_has_suggester();
+  if (suggester_ == NULL) suggester_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubInvitation.suggester)
+  return suggester_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubInvitation::release_suggester() {
+  clear_has_suggester();
+  ::bgs::protocol::club::v1::MemberDescription* temp = suggester_;
+  suggester_ = NULL;
+  return temp;
+}
+inline void ClubInvitation::set_allocated_suggester(::bgs::protocol::club::v1::MemberDescription* suggester) {
+  delete suggester_;
+  suggester_ = suggester;
+  if (suggester) {
+    set_has_suggester();
+  } else {
+    clear_has_suggester();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubInvitation.suggester)
+}
+
+// -------------------------------------------------------------------
+
+// SendSuggestionOptions
+
+// optional .bgs.protocol.club.v1.MemberId target_id = 1;
+inline bool SendSuggestionOptions::has_target_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendSuggestionOptions::set_has_target_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendSuggestionOptions::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendSuggestionOptions::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SendSuggestionOptions::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendSuggestionOptions.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SendSuggestionOptions::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendSuggestionOptions.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SendSuggestionOptions::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::club::v1::MemberId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void SendSuggestionOptions::set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SendSuggestionOptions.target_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubSlot slot = 2;
+inline bool SendSuggestionOptions::has_slot() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SendSuggestionOptions::set_has_slot() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SendSuggestionOptions::clear_has_slot() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SendSuggestionOptions::clear_slot() {
+  if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+  clear_has_slot();
+}
+inline const ::bgs::protocol::club::v1::ClubSlot& SendSuggestionOptions::slot() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendSuggestionOptions.slot)
+  return slot_ != NULL ? *slot_ : *default_instance_->slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* SendSuggestionOptions::mutable_slot() {
+  set_has_slot();
+  if (slot_ == NULL) slot_ = new ::bgs::protocol::club::v1::ClubSlot;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendSuggestionOptions.slot)
+  return slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* SendSuggestionOptions::release_slot() {
+  clear_has_slot();
+  ::bgs::protocol::club::v1::ClubSlot* temp = slot_;
+  slot_ = NULL;
+  return temp;
+}
+inline void SendSuggestionOptions::set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot) {
+  delete slot_;
+  slot_ = slot;
+  if (slot) {
+    set_has_slot();
+  } else {
+    clear_has_slot();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SendSuggestionOptions.slot)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 3;
+inline int SendSuggestionOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void SendSuggestionOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& SendSuggestionOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendSuggestionOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* SendSuggestionOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendSuggestionOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* SendSuggestionOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.SendSuggestionOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+SendSuggestionOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.SendSuggestionOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+SendSuggestionOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.SendSuggestionOptions.attribute)
+  return &attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// ClubSuggestion
+
+// optional fixed64 id = 1;
+inline bool ClubSuggestion::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubSuggestion::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubSuggestion::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubSuggestion::clear_id() {
+  id_ = GOOGLE_ULONGLONG(0);
+  clear_has_id();
+}
+inline ::google::protobuf::uint64 ClubSuggestion::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSuggestion.id)
+  return id_;
+}
+inline void ClubSuggestion::set_id(::google::protobuf::uint64 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubSuggestion.id)
+}
+
+// optional uint64 club_id = 2;
+inline bool ClubSuggestion::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubSuggestion::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubSuggestion::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubSuggestion::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 ClubSuggestion::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSuggestion.club_id)
+  return club_id_;
+}
+inline void ClubSuggestion::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubSuggestion.club_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription suggester = 3;
+inline bool ClubSuggestion::has_suggester() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubSuggestion::set_has_suggester() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubSuggestion::clear_has_suggester() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubSuggestion::clear_suggester() {
+  if (suggester_ != NULL) suggester_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_suggester();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& ClubSuggestion::suggester() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSuggestion.suggester)
+  return suggester_ != NULL ? *suggester_ : *default_instance_->suggester_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubSuggestion::mutable_suggester() {
+  set_has_suggester();
+  if (suggester_ == NULL) suggester_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSuggestion.suggester)
+  return suggester_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubSuggestion::release_suggester() {
+  clear_has_suggester();
+  ::bgs::protocol::club::v1::MemberDescription* temp = suggester_;
+  suggester_ = NULL;
+  return temp;
+}
+inline void ClubSuggestion::set_allocated_suggester(::bgs::protocol::club::v1::MemberDescription* suggester) {
+  delete suggester_;
+  suggester_ = suggester;
+  if (suggester) {
+    set_has_suggester();
+  } else {
+    clear_has_suggester();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubSuggestion.suggester)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription suggestee = 4;
+inline bool ClubSuggestion::has_suggestee() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubSuggestion::set_has_suggestee() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubSuggestion::clear_has_suggestee() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubSuggestion::clear_suggestee() {
+  if (suggestee_ != NULL) suggestee_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_suggestee();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& ClubSuggestion::suggestee() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSuggestion.suggestee)
+  return suggestee_ != NULL ? *suggestee_ : *default_instance_->suggestee_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubSuggestion::mutable_suggestee() {
+  set_has_suggestee();
+  if (suggestee_ == NULL) suggestee_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSuggestion.suggestee)
+  return suggestee_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubSuggestion::release_suggestee() {
+  clear_has_suggestee();
+  ::bgs::protocol::club::v1::MemberDescription* temp = suggestee_;
+  suggestee_ = NULL;
+  return temp;
+}
+inline void ClubSuggestion::set_allocated_suggestee(::bgs::protocol::club::v1::MemberDescription* suggestee) {
+  delete suggestee_;
+  suggestee_ = suggestee;
+  if (suggestee) {
+    set_has_suggestee();
+  } else {
+    clear_has_suggestee();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubSuggestion.suggestee)
+}
+
+// optional .bgs.protocol.club.v1.ClubSlot slot = 5;
+inline bool ClubSuggestion::has_slot() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubSuggestion::set_has_slot() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubSuggestion::clear_has_slot() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubSuggestion::clear_slot() {
+  if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+  clear_has_slot();
+}
+inline const ::bgs::protocol::club::v1::ClubSlot& ClubSuggestion::slot() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSuggestion.slot)
+  return slot_ != NULL ? *slot_ : *default_instance_->slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* ClubSuggestion::mutable_slot() {
+  set_has_slot();
+  if (slot_ == NULL) slot_ = new ::bgs::protocol::club::v1::ClubSlot;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSuggestion.slot)
+  return slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* ClubSuggestion::release_slot() {
+  clear_has_slot();
+  ::bgs::protocol::club::v1::ClubSlot* temp = slot_;
+  slot_ = NULL;
+  return temp;
+}
+inline void ClubSuggestion::set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot) {
+  delete slot_;
+  slot_ = slot;
+  if (slot) {
+    set_has_slot();
+  } else {
+    clear_has_slot();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubSuggestion.slot)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 6;
+inline int ClubSuggestion::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClubSuggestion::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& ClubSuggestion::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSuggestion.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubSuggestion::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSuggestion.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubSuggestion::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubSuggestion.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+ClubSuggestion::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubSuggestion.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+ClubSuggestion::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubSuggestion.attribute)
+  return &attribute_;
+}
+
+// optional uint64 creation_time = 7;
+inline bool ClubSuggestion::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClubSuggestion::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClubSuggestion::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClubSuggestion::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 ClubSuggestion::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSuggestion.creation_time)
+  return creation_time_;
+}
+inline void ClubSuggestion::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubSuggestion.creation_time)
+}
+
+// optional uint64 expiration_time = 8;
+inline bool ClubSuggestion::has_expiration_time() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClubSuggestion::set_has_expiration_time() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClubSuggestion::clear_has_expiration_time() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClubSuggestion::clear_expiration_time() {
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_expiration_time();
+}
+inline ::google::protobuf::uint64 ClubSuggestion::expiration_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSuggestion.expiration_time)
+  return expiration_time_;
+}
+inline void ClubSuggestion::set_expiration_time(::google::protobuf::uint64 value) {
+  set_has_expiration_time();
+  expiration_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubSuggestion.expiration_time)
+}
+
+// -------------------------------------------------------------------
+
+// CreateTicketOptions
+
+// optional .bgs.protocol.club.v1.ClubSlot slot = 1;
+inline bool CreateTicketOptions::has_slot() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateTicketOptions::set_has_slot() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateTicketOptions::clear_has_slot() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateTicketOptions::clear_slot() {
+  if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+  clear_has_slot();
+}
+inline const ::bgs::protocol::club::v1::ClubSlot& CreateTicketOptions::slot() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateTicketOptions.slot)
+  return slot_ != NULL ? *slot_ : *default_instance_->slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* CreateTicketOptions::mutable_slot() {
+  set_has_slot();
+  if (slot_ == NULL) slot_ = new ::bgs::protocol::club::v1::ClubSlot;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateTicketOptions.slot)
+  return slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* CreateTicketOptions::release_slot() {
+  clear_has_slot();
+  ::bgs::protocol::club::v1::ClubSlot* temp = slot_;
+  slot_ = NULL;
+  return temp;
+}
+inline void CreateTicketOptions::set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot) {
+  delete slot_;
+  slot_ = slot;
+  if (slot) {
+    set_has_slot();
+  } else {
+    clear_has_slot();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateTicketOptions.slot)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 2;
+inline int CreateTicketOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void CreateTicketOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& CreateTicketOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateTicketOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* CreateTicketOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateTicketOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* CreateTicketOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.CreateTicketOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+CreateTicketOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.CreateTicketOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+CreateTicketOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.CreateTicketOptions.attribute)
+  return &attribute_;
+}
+
+// optional uint32 allowed_redeem_count = 3;
+inline bool CreateTicketOptions::has_allowed_redeem_count() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CreateTicketOptions::set_has_allowed_redeem_count() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CreateTicketOptions::clear_has_allowed_redeem_count() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CreateTicketOptions::clear_allowed_redeem_count() {
+  allowed_redeem_count_ = 0u;
+  clear_has_allowed_redeem_count();
+}
+inline ::google::protobuf::uint32 CreateTicketOptions::allowed_redeem_count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateTicketOptions.allowed_redeem_count)
+  return allowed_redeem_count_;
+}
+inline void CreateTicketOptions::set_allowed_redeem_count(::google::protobuf::uint32 value) {
+  set_has_allowed_redeem_count();
+  allowed_redeem_count_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateTicketOptions.allowed_redeem_count)
+}
+
+// optional uint64 expiration_time = 4;
+inline bool CreateTicketOptions::has_expiration_time() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void CreateTicketOptions::set_has_expiration_time() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void CreateTicketOptions::clear_has_expiration_time() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void CreateTicketOptions::clear_expiration_time() {
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_expiration_time();
+}
+inline ::google::protobuf::uint64 CreateTicketOptions::expiration_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateTicketOptions.expiration_time)
+  return expiration_time_;
+}
+inline void CreateTicketOptions::set_expiration_time(::google::protobuf::uint64 value) {
+  set_has_expiration_time();
+  expiration_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateTicketOptions.expiration_time)
+}
+
+// -------------------------------------------------------------------
+
+// ClubTicket
+
+// optional string id = 1;
+inline bool ClubTicket::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubTicket::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubTicket::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubTicket::clear_id() {
+  if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_->clear();
+  }
+  clear_has_id();
+}
+inline const ::std::string& ClubTicket::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicket.id)
+  return *id_;
+}
+inline void ClubTicket::set_id(const ::std::string& value) {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubTicket.id)
+}
+inline void ClubTicket::set_id(const char* value) {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubTicket.id)
+}
+inline void ClubTicket::set_id(const char* value, size_t size) {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubTicket.id)
+}
+inline ::std::string* ClubTicket::mutable_id() {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTicket.id)
+  return id_;
+}
+inline ::std::string* ClubTicket::release_id() {
+  clear_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = id_;
+    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubTicket::set_allocated_id(::std::string* id) {
+  if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete id_;
+  }
+  if (id) {
+    set_has_id();
+    id_ = id;
+  } else {
+    clear_has_id();
+    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTicket.id)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription creator = 2;
+inline bool ClubTicket::has_creator() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubTicket::set_has_creator() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubTicket::clear_has_creator() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubTicket::clear_creator() {
+  if (creator_ != NULL) creator_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_creator();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& ClubTicket::creator() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicket.creator)
+  return creator_ != NULL ? *creator_ : *default_instance_->creator_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubTicket::mutable_creator() {
+  set_has_creator();
+  if (creator_ == NULL) creator_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTicket.creator)
+  return creator_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* ClubTicket::release_creator() {
+  clear_has_creator();
+  ::bgs::protocol::club::v1::MemberDescription* temp = creator_;
+  creator_ = NULL;
+  return temp;
+}
+inline void ClubTicket::set_allocated_creator(::bgs::protocol::club::v1::MemberDescription* creator) {
+  delete creator_;
+  creator_ = creator;
+  if (creator) {
+    set_has_creator();
+  } else {
+    clear_has_creator();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTicket.creator)
+}
+
+// optional .bgs.protocol.club.v1.ClubDescription club = 3;
+inline bool ClubTicket::has_club() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubTicket::set_has_club() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubTicket::clear_has_club() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubTicket::clear_club() {
+  if (club_ != NULL) club_->::bgs::protocol::club::v1::ClubDescription::Clear();
+  clear_has_club();
+}
+inline const ::bgs::protocol::club::v1::ClubDescription& ClubTicket::club() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicket.club)
+  return club_ != NULL ? *club_ : *default_instance_->club_;
+}
+inline ::bgs::protocol::club::v1::ClubDescription* ClubTicket::mutable_club() {
+  set_has_club();
+  if (club_ == NULL) club_ = new ::bgs::protocol::club::v1::ClubDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTicket.club)
+  return club_;
+}
+inline ::bgs::protocol::club::v1::ClubDescription* ClubTicket::release_club() {
+  clear_has_club();
+  ::bgs::protocol::club::v1::ClubDescription* temp = club_;
+  club_ = NULL;
+  return temp;
+}
+inline void ClubTicket::set_allocated_club(::bgs::protocol::club::v1::ClubDescription* club) {
+  delete club_;
+  club_ = club;
+  if (club) {
+    set_has_club();
+  } else {
+    clear_has_club();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTicket.club)
+}
+
+// optional .bgs.protocol.club.v1.ClubSlot slot = 4;
+inline bool ClubTicket::has_slot() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubTicket::set_has_slot() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubTicket::clear_has_slot() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubTicket::clear_slot() {
+  if (slot_ != NULL) slot_->::bgs::protocol::club::v1::ClubSlot::Clear();
+  clear_has_slot();
+}
+inline const ::bgs::protocol::club::v1::ClubSlot& ClubTicket::slot() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicket.slot)
+  return slot_ != NULL ? *slot_ : *default_instance_->slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* ClubTicket::mutable_slot() {
+  set_has_slot();
+  if (slot_ == NULL) slot_ = new ::bgs::protocol::club::v1::ClubSlot;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTicket.slot)
+  return slot_;
+}
+inline ::bgs::protocol::club::v1::ClubSlot* ClubTicket::release_slot() {
+  clear_has_slot();
+  ::bgs::protocol::club::v1::ClubSlot* temp = slot_;
+  slot_ = NULL;
+  return temp;
+}
+inline void ClubTicket::set_allocated_slot(::bgs::protocol::club::v1::ClubSlot* slot) {
+  delete slot_;
+  slot_ = slot;
+  if (slot) {
+    set_has_slot();
+  } else {
+    clear_has_slot();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTicket.slot)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 5;
+inline int ClubTicket::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClubTicket::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& ClubTicket::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicket.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubTicket::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTicket.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* ClubTicket::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubTicket.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+ClubTicket::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubTicket.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+ClubTicket::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubTicket.attribute)
+  return &attribute_;
+}
+
+// optional uint32 current_redeem_count = 6;
+inline bool ClubTicket::has_current_redeem_count() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClubTicket::set_has_current_redeem_count() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClubTicket::clear_has_current_redeem_count() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClubTicket::clear_current_redeem_count() {
+  current_redeem_count_ = 0u;
+  clear_has_current_redeem_count();
+}
+inline ::google::protobuf::uint32 ClubTicket::current_redeem_count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicket.current_redeem_count)
+  return current_redeem_count_;
+}
+inline void ClubTicket::set_current_redeem_count(::google::protobuf::uint32 value) {
+  set_has_current_redeem_count();
+  current_redeem_count_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubTicket.current_redeem_count)
+}
+
+// optional uint32 allowed_redeem_count = 7;
+inline bool ClubTicket::has_allowed_redeem_count() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClubTicket::set_has_allowed_redeem_count() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClubTicket::clear_has_allowed_redeem_count() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClubTicket::clear_allowed_redeem_count() {
+  allowed_redeem_count_ = 0u;
+  clear_has_allowed_redeem_count();
+}
+inline ::google::protobuf::uint32 ClubTicket::allowed_redeem_count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicket.allowed_redeem_count)
+  return allowed_redeem_count_;
+}
+inline void ClubTicket::set_allowed_redeem_count(::google::protobuf::uint32 value) {
+  set_has_allowed_redeem_count();
+  allowed_redeem_count_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubTicket.allowed_redeem_count)
+}
+
+// optional uint64 creation_time = 8;
+inline bool ClubTicket::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClubTicket::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClubTicket::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClubTicket::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 ClubTicket::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicket.creation_time)
+  return creation_time_;
+}
+inline void ClubTicket::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubTicket.creation_time)
+}
+
+// optional uint64 expiration_time = 9;
+inline bool ClubTicket::has_expiration_time() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ClubTicket::set_has_expiration_time() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ClubTicket::clear_has_expiration_time() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ClubTicket::clear_expiration_time() {
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_expiration_time();
+}
+inline ::google::protobuf::uint64 ClubTicket::expiration_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicket.expiration_time)
+  return expiration_time_;
+}
+inline void ClubTicket::set_expiration_time(::google::protobuf::uint64 value) {
+  set_has_expiration_time();
+  expiration_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubTicket.expiration_time)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5finvitation_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_member.pb.cc b/src/server/proto/Client/club_member.pb.cc
new file mode 100644
index 00000000000..45b7788049a
--- /dev/null
+++ b/src/server/proto/Client/club_member.pb.cc
@@ -0,0 +1,5685 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_member.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_member.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* MemberId_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberId_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Member_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Member_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberResult_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberResult_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RemoveMemberOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RemoveMemberOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberRemovedAssignment_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberRemovedAssignment_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberVoiceOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberVoiceOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberVoiceState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberVoiceState_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateMemberOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateMemberOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberDescription_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberDescription_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RoleAssignment_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RoleAssignment_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberAttributeAssignment_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberAttributeAssignment_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscriberStateOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscriberStateOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscriberStateAssignment_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscriberStateAssignment_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberStateOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberStateOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberStateAssignment_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberStateAssignment_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5fmember_2eproto() {
+  protobuf_AddDesc_club_5fmember_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_member.proto");
+  GOOGLE_CHECK(file != NULL);
+  MemberId_descriptor_ = file->message_type(0);
+  static const int MemberId_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberId, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberId, unique_id_),
+  };
+  MemberId_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberId_descriptor_,
+      MemberId::default_instance_,
+      MemberId_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberId, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberId, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberId));
+  Member_descriptor_ = file->message_type(1);
+  static const int Member_offsets_[11] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, join_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, presence_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, moderator_mute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, whisper_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, note_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, active_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, voice_),
+  };
+  Member_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Member_descriptor_,
+      Member::default_instance_,
+      Member_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Member));
+  MemberResult_descriptor_ = file->message_type(2);
+  static const int MemberResult_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberResult, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberResult, status_),
+  };
+  MemberResult_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberResult_descriptor_,
+      MemberResult::default_instance_,
+      MemberResult_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberResult, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberResult, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberResult));
+  RemoveMemberOptions_descriptor_ = file->message_type(3);
+  static const int RemoveMemberOptions_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberOptions, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberOptions, reason_),
+  };
+  RemoveMemberOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RemoveMemberOptions_descriptor_,
+      RemoveMemberOptions::default_instance_,
+      RemoveMemberOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RemoveMemberOptions));
+  MemberRemovedAssignment_descriptor_ = file->message_type(4);
+  static const int MemberRemovedAssignment_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedAssignment, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedAssignment, reason_),
+  };
+  MemberRemovedAssignment_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberRemovedAssignment_descriptor_,
+      MemberRemovedAssignment::default_instance_,
+      MemberRemovedAssignment_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedAssignment, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedAssignment, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberRemovedAssignment));
+  MemberVoiceOptions_descriptor_ = file->message_type(5);
+  static const int MemberVoiceOptions_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceOptions, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceOptions, joined_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceOptions, microphone_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceOptions, active_),
+  };
+  MemberVoiceOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberVoiceOptions_descriptor_,
+      MemberVoiceOptions::default_instance_,
+      MemberVoiceOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberVoiceOptions));
+  MemberVoiceState_descriptor_ = file->message_type(6);
+  static const int MemberVoiceState_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceState, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceState, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceState, joined_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceState, microphone_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceState, active_),
+  };
+  MemberVoiceState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberVoiceState_descriptor_,
+      MemberVoiceState::default_instance_,
+      MemberVoiceState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberVoiceState, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberVoiceState));
+  CreateMemberOptions_descriptor_ = file->message_type(7);
+  static const int CreateMemberOptions_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMemberOptions, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMemberOptions, attribute_),
+  };
+  CreateMemberOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateMemberOptions_descriptor_,
+      CreateMemberOptions::default_instance_,
+      CreateMemberOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMemberOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMemberOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateMemberOptions));
+  MemberDescription_descriptor_ = file->message_type(8);
+  static const int MemberDescription_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberDescription, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberDescription, battle_tag_),
+  };
+  MemberDescription_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberDescription_descriptor_,
+      MemberDescription::default_instance_,
+      MemberDescription_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberDescription, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberDescription, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberDescription));
+  RoleAssignment_descriptor_ = file->message_type(9);
+  static const int RoleAssignment_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleAssignment, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleAssignment, role_),
+  };
+  RoleAssignment_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RoleAssignment_descriptor_,
+      RoleAssignment::default_instance_,
+      RoleAssignment_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleAssignment, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleAssignment, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RoleAssignment));
+  MemberAttributeAssignment_descriptor_ = file->message_type(10);
+  static const int MemberAttributeAssignment_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAttributeAssignment, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAttributeAssignment, attribute_),
+  };
+  MemberAttributeAssignment_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberAttributeAssignment_descriptor_,
+      MemberAttributeAssignment::default_instance_,
+      MemberAttributeAssignment_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAttributeAssignment, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAttributeAssignment, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberAttributeAssignment));
+  SubscriberStateOptions_descriptor_ = file->message_type(11);
+  static const int SubscriberStateOptions_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateOptions, voice_),
+  };
+  SubscriberStateOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscriberStateOptions_descriptor_,
+      SubscriberStateOptions::default_instance_,
+      SubscriberStateOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscriberStateOptions));
+  SubscriberStateAssignment_descriptor_ = file->message_type(12);
+  static const int SubscriberStateAssignment_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateAssignment, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateAssignment, active_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateAssignment, voice_),
+  };
+  SubscriberStateAssignment_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscriberStateAssignment_descriptor_,
+      SubscriberStateAssignment::default_instance_,
+      SubscriberStateAssignment_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateAssignment, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateAssignment, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscriberStateAssignment));
+  MemberStateOptions_descriptor_ = file->message_type(13);
+  static const int MemberStateOptions_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateOptions, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateOptions, presence_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateOptions, moderator_mute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateOptions, whisper_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateOptions, note_),
+  };
+  MemberStateOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberStateOptions_descriptor_,
+      MemberStateOptions::default_instance_,
+      MemberStateOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberStateOptions));
+  MemberStateAssignment_descriptor_ = file->message_type(14);
+  static const int MemberStateAssignment_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateAssignment, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateAssignment, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateAssignment, presence_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateAssignment, moderator_mute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateAssignment, whisper_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateAssignment, note_),
+  };
+  MemberStateAssignment_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberStateAssignment_descriptor_,
+      MemberStateAssignment::default_instance_,
+      MemberStateAssignment_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateAssignment, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateAssignment, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberStateAssignment));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5fmember_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberId_descriptor_, &MemberId::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Member_descriptor_, &Member::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberResult_descriptor_, &MemberResult::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RemoveMemberOptions_descriptor_, &RemoveMemberOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberRemovedAssignment_descriptor_, &MemberRemovedAssignment::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberVoiceOptions_descriptor_, &MemberVoiceOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberVoiceState_descriptor_, &MemberVoiceState::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateMemberOptions_descriptor_, &CreateMemberOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberDescription_descriptor_, &MemberDescription::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RoleAssignment_descriptor_, &RoleAssignment::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberAttributeAssignment_descriptor_, &MemberAttributeAssignment::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscriberStateOptions_descriptor_, &SubscriberStateOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscriberStateAssignment_descriptor_, &SubscriberStateAssignment::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberStateOptions_descriptor_, &MemberStateOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberStateAssignment_descriptor_, &MemberStateAssignment::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5fmember_2eproto() {
+  delete MemberId::default_instance_;
+  delete MemberId_reflection_;
+  delete Member::default_instance_;
+  delete Member_reflection_;
+  delete MemberResult::default_instance_;
+  delete MemberResult_reflection_;
+  delete RemoveMemberOptions::default_instance_;
+  delete RemoveMemberOptions_reflection_;
+  delete MemberRemovedAssignment::default_instance_;
+  delete MemberRemovedAssignment_reflection_;
+  delete MemberVoiceOptions::default_instance_;
+  delete MemberVoiceOptions_reflection_;
+  delete MemberVoiceState::default_instance_;
+  delete MemberVoiceState_reflection_;
+  delete CreateMemberOptions::default_instance_;
+  delete CreateMemberOptions_reflection_;
+  delete MemberDescription::default_instance_;
+  delete MemberDescription_reflection_;
+  delete RoleAssignment::default_instance_;
+  delete RoleAssignment_reflection_;
+  delete MemberAttributeAssignment::default_instance_;
+  delete MemberAttributeAssignment_reflection_;
+  delete SubscriberStateOptions::default_instance_;
+  delete SubscriberStateOptions_reflection_;
+  delete SubscriberStateAssignment::default_instance_;
+  delete SubscriberStateAssignment_reflection_;
+  delete MemberStateOptions::default_instance_;
+  delete MemberStateOptions_reflection_;
+  delete MemberStateAssignment::default_instance_;
+  delete MemberStateAssignment_reflection_;
+}
+
+void protobuf_AddDesc_club_5fmember_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2fmessage_5foptions_2eproto();
+  ::bgs::protocol::v2::protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fenum_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\021club_member.proto\022\024bgs.protocol.club.v"
+    "1\032\'global_extensions/message_options.pro"
+    "to\032#api/client/v2/attribute_types.proto\032"
+    "\023account_types.proto\032\017club_enum.proto\"]\n"
+    "\010MemberId\0226\n\naccount_id\030\001 \001(\0132\".bgs.prot"
+    "ocol.account.v1.AccountId\022\021\n\tunique_id\030\002"
+    " \001(\004:\006\202\371+\002\010\001\"\201\003\n\006Member\022*\n\002id\030\001 \001(\0132\036.bg"
+    "s.protocol.club.v1.MemberId\022\022\n\nbattle_ta"
+    "g\030\002 \001(\t\022\020\n\004role\030\003 \003(\rB\002\020\001\022-\n\tattribute\030\004"
+    " \003(\0132\032.bgs.protocol.v2.Attribute\022\021\n\tjoin"
+    "_time\030\005 \001(\004\022;\n\016presence_level\030\006 \001(\0162#.bg"
+    "s.protocol.club.v1.PresenceLevel\022\026\n\016mode"
+    "rator_mute\030\007 \001(\010\0229\n\rwhisper_level\030\010 \001(\0162"
+    "\".bgs.protocol.club.v1.WhisperLevel\022\014\n\004n"
+    "ote\030\t \001(\t\022\016\n\006active\0302 \001(\010\0225\n\005voice\0303 \001(\013"
+    "2&.bgs.protocol.club.v1.MemberVoiceState"
+    "\"Q\n\014MemberResult\0221\n\tmember_id\030\001 \001(\0132\036.bg"
+    "s.protocol.club.v1.MemberId\022\016\n\006status\030\002 "
+    "\001(\r\"z\n\023RemoveMemberOptions\022*\n\002id\030\001 \001(\0132\036"
+    ".bgs.protocol.club.v1.MemberId\0227\n\006reason"
+    "\030\002 \001(\0162\'.bgs.protocol.club.v1.ClubRemove"
+    "dReason\"~\n\027MemberRemovedAssignment\022*\n\002id"
+    "\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId\0227"
+    "\n\006reason\030\002 \001(\0162\'.bgs.protocol.club.v1.Cl"
+    "ubRemovedReason\"\207\001\n\022MemberVoiceOptions\022\021"
+    "\n\tstream_id\030\001 \001(\004\022\016\n\006joined\030\002 \001(\010\022>\n\nmic"
+    "rophone\030\003 \001(\0162*.bgs.protocol.club.v1.Voi"
+    "ceMicrophoneState\022\016\n\006active\030\004 \001(\010\"\221\001\n\020Me"
+    "mberVoiceState\022\n\n\002id\030\001 \001(\t\022\021\n\tstream_id\030"
+    "\002 \001(\004\022\016\n\006joined\030\003 \001(\010\022>\n\nmicrophone\030\004 \001("
+    "\0162*.bgs.protocol.club.v1.VoiceMicrophone"
+    "State\022\016\n\006active\030\005 \001(\010\"p\n\023CreateMemberOpt"
+    "ions\022*\n\002id\030\001 \001(\0132\036.bgs.protocol.club.v1."
+    "MemberId\022-\n\tattribute\030\002 \003(\0132\032.bgs.protoc"
+    "ol.v2.Attribute\"S\n\021MemberDescription\022*\n\002"
+    "id\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId"
+    "\022\022\n\nbattle_tag\030\002 \001(\t\"U\n\016RoleAssignment\0221"
+    "\n\tmember_id\030\001 \001(\0132\036.bgs.protocol.club.v1"
+    ".MemberId\022\020\n\004role\030\002 \003(\rB\002\020\001\"}\n\031MemberAtt"
+    "ributeAssignment\0221\n\tmember_id\030\001 \001(\0132\036.bg"
+    "s.protocol.club.v1.MemberId\022-\n\tattribute"
+    "\030\002 \003(\0132\032.bgs.protocol.v2.Attribute\"Q\n\026Su"
+    "bscriberStateOptions\0227\n\005voice\030\001 \001(\0132(.bg"
+    "s.protocol.club.v1.MemberVoiceOptions\"\225\001"
+    "\n\031SubscriberStateAssignment\0221\n\tmember_id"
+    "\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId\022\016"
+    "\n\006active\030\002 \001(\010\0225\n\005voice\030\003 \001(\0132&.bgs.prot"
+    "ocol.club.v1.MemberVoiceState\"\341\001\n\022Member"
+    "StateOptions\022-\n\tattribute\030\001 \003(\0132\032.bgs.pr"
+    "otocol.v2.Attribute\022;\n\016presence_level\030\002 "
+    "\001(\0162#.bgs.protocol.club.v1.PresenceLevel"
+    "\022\026\n\016moderator_mute\030\003 \001(\010\0229\n\rwhisper_leve"
+    "l\030\004 \001(\0162\".bgs.protocol.club.v1.WhisperLe"
+    "vel\022\014\n\004note\030\005 \001(\t\"\227\002\n\025MemberStateAssignm"
+    "ent\0221\n\tmember_id\030\001 \001(\0132\036.bgs.protocol.cl"
+    "ub.v1.MemberId\022-\n\tattribute\030\002 \003(\0132\032.bgs."
+    "protocol.v2.Attribute\022;\n\016presence_level\030"
+    "\003 \001(\0162#.bgs.protocol.club.v1.PresenceLev"
+    "el\022\026\n\016moderator_mute\030\004 \001(\010\0229\n\rwhisper_le"
+    "vel\030\005 \001(\0162\".bgs.protocol.club.v1.Whisper"
+    "Level\022\014\n\004note\030\006 \001(\tB\002H\001", 2423);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_member.proto", &protobuf_RegisterTypes);
+  MemberId::default_instance_ = new MemberId();
+  Member::default_instance_ = new Member();
+  MemberResult::default_instance_ = new MemberResult();
+  RemoveMemberOptions::default_instance_ = new RemoveMemberOptions();
+  MemberRemovedAssignment::default_instance_ = new MemberRemovedAssignment();
+  MemberVoiceOptions::default_instance_ = new MemberVoiceOptions();
+  MemberVoiceState::default_instance_ = new MemberVoiceState();
+  CreateMemberOptions::default_instance_ = new CreateMemberOptions();
+  MemberDescription::default_instance_ = new MemberDescription();
+  RoleAssignment::default_instance_ = new RoleAssignment();
+  MemberAttributeAssignment::default_instance_ = new MemberAttributeAssignment();
+  SubscriberStateOptions::default_instance_ = new SubscriberStateOptions();
+  SubscriberStateAssignment::default_instance_ = new SubscriberStateAssignment();
+  MemberStateOptions::default_instance_ = new MemberStateOptions();
+  MemberStateAssignment::default_instance_ = new MemberStateAssignment();
+  MemberId::default_instance_->InitAsDefaultInstance();
+  Member::default_instance_->InitAsDefaultInstance();
+  MemberResult::default_instance_->InitAsDefaultInstance();
+  RemoveMemberOptions::default_instance_->InitAsDefaultInstance();
+  MemberRemovedAssignment::default_instance_->InitAsDefaultInstance();
+  MemberVoiceOptions::default_instance_->InitAsDefaultInstance();
+  MemberVoiceState::default_instance_->InitAsDefaultInstance();
+  CreateMemberOptions::default_instance_->InitAsDefaultInstance();
+  MemberDescription::default_instance_->InitAsDefaultInstance();
+  RoleAssignment::default_instance_->InitAsDefaultInstance();
+  MemberAttributeAssignment::default_instance_->InitAsDefaultInstance();
+  SubscriberStateOptions::default_instance_->InitAsDefaultInstance();
+  SubscriberStateAssignment::default_instance_->InitAsDefaultInstance();
+  MemberStateOptions::default_instance_->InitAsDefaultInstance();
+  MemberStateAssignment::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5fmember_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5fmember_2eproto {
+  StaticDescriptorInitializer_club_5fmember_2eproto() {
+    protobuf_AddDesc_club_5fmember_2eproto();
+  }
+} static_descriptor_initializer_club_5fmember_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberId::kAccountIdFieldNumber;
+const int MemberId::kUniqueIdFieldNumber;
+#endif  // !_MSC_VER
+
+MemberId::MemberId()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberId)
+}
+
+void MemberId::InitAsDefaultInstance() {
+  account_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+MemberId::MemberId(const MemberId& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberId)
+}
+
+void MemberId::SharedCtor() {
+  _cached_size_ = 0;
+  account_id_ = NULL;
+  unique_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberId::~MemberId() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberId)
+  SharedDtor();
+}
+
+void MemberId::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_id_;
+  }
+}
+
+void MemberId::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberId::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberId_descriptor_;
+}
+
+const MemberId& MemberId::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+MemberId* MemberId::default_instance_ = NULL;
+
+MemberId* MemberId::New() const {
+  return new MemberId;
+}
+
+void MemberId::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    unique_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberId::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberId)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_unique_id;
+        break;
+      }
+
+      // optional uint64 unique_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_unique_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &unique_id_)));
+          set_has_unique_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberId)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberId)
+  return false;
+#undef DO_
+}
+
+void MemberId::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberId)
+  // optional .bgs.protocol.account.v1.AccountId account_id = 1;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_id(), output);
+  }
+
+  // optional uint64 unique_id = 2;
+  if (has_unique_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->unique_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberId)
+}
+
+::google::protobuf::uint8* MemberId::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberId)
+  // optional .bgs.protocol.account.v1.AccountId account_id = 1;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_id(), target);
+  }
+
+  // optional uint64 unique_id = 2;
+  if (has_unique_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->unique_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberId)
+  return target;
+}
+
+int MemberId::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId account_id = 1;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional uint64 unique_id = 2;
+    if (has_unique_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->unique_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberId::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberId* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberId*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberId::MergeFrom(const MemberId& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account_id());
+    }
+    if (from.has_unique_id()) {
+      set_unique_id(from.unique_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberId::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberId::CopyFrom(const MemberId& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberId::IsInitialized() const {
+
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void MemberId::Swap(MemberId* other) {
+  if (other != this) {
+    std::swap(account_id_, other->account_id_);
+    std::swap(unique_id_, other->unique_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberId::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberId_descriptor_;
+  metadata.reflection = MemberId_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Member::kIdFieldNumber;
+const int Member::kBattleTagFieldNumber;
+const int Member::kRoleFieldNumber;
+const int Member::kAttributeFieldNumber;
+const int Member::kJoinTimeFieldNumber;
+const int Member::kPresenceLevelFieldNumber;
+const int Member::kModeratorMuteFieldNumber;
+const int Member::kWhisperLevelFieldNumber;
+const int Member::kNoteFieldNumber;
+const int Member::kActiveFieldNumber;
+const int Member::kVoiceFieldNumber;
+#endif  // !_MSC_VER
+
+Member::Member()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.Member)
+}
+
+void Member::InitAsDefaultInstance() {
+  id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  voice_ = const_cast< ::bgs::protocol::club::v1::MemberVoiceState*>(&::bgs::protocol::club::v1::MemberVoiceState::default_instance());
+}
+
+Member::Member(const Member& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.Member)
+}
+
+void Member::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = NULL;
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  _role_cached_byte_size_ = 0;
+  join_time_ = GOOGLE_ULONGLONG(0);
+  presence_level_ = 0;
+  moderator_mute_ = false;
+  whisper_level_ = 0;
+  note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  active_ = false;
+  voice_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Member::~Member() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.Member)
+  SharedDtor();
+}
+
+void Member::SharedDtor() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete note_;
+  }
+  if (this != default_instance_) {
+    delete id_;
+    delete voice_;
+  }
+}
+
+void Member::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Member::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Member_descriptor_;
+}
+
+const Member& Member::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+Member* Member::default_instance_ = NULL;
+
+Member* Member::New() const {
+  return new Member;
+}
+
+void Member::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Member*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 243) {
+    ZR_(join_time_, whisper_level_);
+    if (has_id()) {
+      if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+    moderator_mute_ = false;
+  }
+  if (_has_bits_[8 / 32] & 1792) {
+    if (has_note()) {
+      if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        note_->clear();
+      }
+    }
+    active_ = false;
+    if (has_voice()) {
+      if (voice_ != NULL) voice_->::bgs::protocol::club::v1::MemberVoiceState::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  role_.Clear();
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Member::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.Member)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attribute;
+        if (input->ExpectTag(40)) goto parse_join_time;
+        break;
+      }
+
+      // optional uint64 join_time = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_join_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &join_time_)));
+          set_has_join_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_presence_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_presence_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::PresenceLevel_IsValid(value)) {
+            set_presence_level(static_cast< ::bgs::protocol::club::v1::PresenceLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(6, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_moderator_mute;
+        break;
+      }
+
+      // optional bool moderator_mute = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_moderator_mute:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &moderator_mute_)));
+          set_has_moderator_mute();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_whisper_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_whisper_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::WhisperLevel_IsValid(value)) {
+            set_whisper_level(static_cast< ::bgs::protocol::club::v1::WhisperLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(8, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_note;
+        break;
+      }
+
+      // optional string note = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_note:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_note()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->note().data(), this->note().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "note");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(400)) goto parse_active;
+        break;
+      }
+
+      // optional bool active = 50;
+      case 50: {
+        if (tag == 400) {
+         parse_active:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &active_)));
+          set_has_active();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(410)) goto parse_voice;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberVoiceState voice = 51;
+      case 51: {
+        if (tag == 410) {
+         parse_voice:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_voice()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.Member)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.Member)
+  return false;
+#undef DO_
+}
+
+void Member::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.Member)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->id(), output);
+  }
+
+  // optional string battle_tag = 2;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->battle_tag(), output);
+  }
+
+  // repeated uint32 role = 3 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 4;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->attribute(i), output);
+  }
+
+  // optional uint64 join_time = 5;
+  if (has_join_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->join_time(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 6;
+  if (has_presence_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->presence_level(), output);
+  }
+
+  // optional bool moderator_mute = 7;
+  if (has_moderator_mute()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->moderator_mute(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 8;
+  if (has_whisper_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      8, this->whisper_level(), output);
+  }
+
+  // optional string note = 9;
+  if (has_note()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->note().data(), this->note().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "note");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      9, this->note(), output);
+  }
+
+  // optional bool active = 50;
+  if (has_active()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(50, this->active(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberVoiceState voice = 51;
+  if (has_voice()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      51, this->voice(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.Member)
+}
+
+::google::protobuf::uint8* Member::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.Member)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->id(), target);
+  }
+
+  // optional string battle_tag = 2;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->battle_tag(), target);
+  }
+
+  // repeated uint32 role = 3 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      3,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 4;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->attribute(i), target);
+  }
+
+  // optional uint64 join_time = 5;
+  if (has_join_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->join_time(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 6;
+  if (has_presence_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      6, this->presence_level(), target);
+  }
+
+  // optional bool moderator_mute = 7;
+  if (has_moderator_mute()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->moderator_mute(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 8;
+  if (has_whisper_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      8, this->whisper_level(), target);
+  }
+
+  // optional string note = 9;
+  if (has_note()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->note().data(), this->note().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "note");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        9, this->note(), target);
+  }
+
+  // optional bool active = 50;
+  if (has_active()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(50, this->active(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberVoiceState voice = 51;
+  if (has_voice()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        51, this->voice(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.Member)
+  return target;
+}
+
+int Member::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->id());
+    }
+
+    // optional string battle_tag = 2;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+    // optional uint64 join_time = 5;
+    if (has_join_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->join_time());
+    }
+
+    // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 6;
+    if (has_presence_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->presence_level());
+    }
+
+    // optional bool moderator_mute = 7;
+    if (has_moderator_mute()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 8;
+    if (has_whisper_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->whisper_level());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional string note = 9;
+    if (has_note()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->note());
+    }
+
+    // optional bool active = 50;
+    if (has_active()) {
+      total_size += 2 + 1;
+    }
+
+    // optional .bgs.protocol.club.v1.MemberVoiceState voice = 51;
+    if (has_voice()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->voice());
+    }
+
+  }
+  // repeated uint32 role = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 4;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Member::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Member* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Member*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Member::MergeFrom(const Member& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      mutable_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.id());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+    if (from.has_join_time()) {
+      set_join_time(from.join_time());
+    }
+    if (from.has_presence_level()) {
+      set_presence_level(from.presence_level());
+    }
+    if (from.has_moderator_mute()) {
+      set_moderator_mute(from.moderator_mute());
+    }
+    if (from.has_whisper_level()) {
+      set_whisper_level(from.whisper_level());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_note()) {
+      set_note(from.note());
+    }
+    if (from.has_active()) {
+      set_active(from.active());
+    }
+    if (from.has_voice()) {
+      mutable_voice()->::bgs::protocol::club::v1::MemberVoiceState::MergeFrom(from.voice());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Member::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Member::CopyFrom(const Member& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Member::IsInitialized() const {
+
+  if (has_id()) {
+    if (!this->id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Member::Swap(Member* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(battle_tag_, other->battle_tag_);
+    role_.Swap(&other->role_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(join_time_, other->join_time_);
+    std::swap(presence_level_, other->presence_level_);
+    std::swap(moderator_mute_, other->moderator_mute_);
+    std::swap(whisper_level_, other->whisper_level_);
+    std::swap(note_, other->note_);
+    std::swap(active_, other->active_);
+    std::swap(voice_, other->voice_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Member::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Member_descriptor_;
+  metadata.reflection = Member_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberResult::kMemberIdFieldNumber;
+const int MemberResult::kStatusFieldNumber;
+#endif  // !_MSC_VER
+
+MemberResult::MemberResult()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberResult)
+}
+
+void MemberResult::InitAsDefaultInstance() {
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+MemberResult::MemberResult(const MemberResult& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberResult)
+}
+
+void MemberResult::SharedCtor() {
+  _cached_size_ = 0;
+  member_id_ = NULL;
+  status_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberResult::~MemberResult() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberResult)
+  SharedDtor();
+}
+
+void MemberResult::SharedDtor() {
+  if (this != default_instance_) {
+    delete member_id_;
+  }
+}
+
+void MemberResult::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberResult::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberResult_descriptor_;
+}
+
+const MemberResult& MemberResult::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+MemberResult* MemberResult::default_instance_ = NULL;
+
+MemberResult* MemberResult::New() const {
+  return new MemberResult;
+}
+
+void MemberResult::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    status_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberResult::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberResult)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_status;
+        break;
+      }
+
+      // optional uint32 status = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_status:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &status_)));
+          set_has_status();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberResult)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberResult)
+  return false;
+#undef DO_
+}
+
+void MemberResult::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberResult)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->member_id(), output);
+  }
+
+  // optional uint32 status = 2;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->status(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberResult)
+}
+
+::google::protobuf::uint8* MemberResult::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberResult)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->member_id(), target);
+  }
+
+  // optional uint32 status = 2;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->status(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberResult)
+  return target;
+}
+
+int MemberResult::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+    // optional uint32 status = 2;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->status());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberResult::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberResult* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberResult*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberResult::MergeFrom(const MemberResult& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberResult::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberResult::CopyFrom(const MemberResult& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberResult::IsInitialized() const {
+
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void MemberResult::Swap(MemberResult* other) {
+  if (other != this) {
+    std::swap(member_id_, other->member_id_);
+    std::swap(status_, other->status_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberResult::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberResult_descriptor_;
+  metadata.reflection = MemberResult_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RemoveMemberOptions::kIdFieldNumber;
+const int RemoveMemberOptions::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+RemoveMemberOptions::RemoveMemberOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.RemoveMemberOptions)
+}
+
+void RemoveMemberOptions::InitAsDefaultInstance() {
+  id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+RemoveMemberOptions::RemoveMemberOptions(const RemoveMemberOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.RemoveMemberOptions)
+}
+
+void RemoveMemberOptions::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = NULL;
+  reason_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RemoveMemberOptions::~RemoveMemberOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.RemoveMemberOptions)
+  SharedDtor();
+}
+
+void RemoveMemberOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete id_;
+  }
+}
+
+void RemoveMemberOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RemoveMemberOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RemoveMemberOptions_descriptor_;
+}
+
+const RemoveMemberOptions& RemoveMemberOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+RemoveMemberOptions* RemoveMemberOptions::default_instance_ = NULL;
+
+RemoveMemberOptions* RemoveMemberOptions::New() const {
+  return new RemoveMemberOptions;
+}
+
+void RemoveMemberOptions::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_id()) {
+      if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    reason_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RemoveMemberOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.RemoveMemberOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_reason;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_reason:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::ClubRemovedReason_IsValid(value)) {
+            set_reason(static_cast< ::bgs::protocol::club::v1::ClubRemovedReason >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(2, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.RemoveMemberOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.RemoveMemberOptions)
+  return false;
+#undef DO_
+}
+
+void RemoveMemberOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.RemoveMemberOptions)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.RemoveMemberOptions)
+}
+
+::google::protobuf::uint8* RemoveMemberOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.RemoveMemberOptions)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.RemoveMemberOptions)
+  return target;
+}
+
+int RemoveMemberOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->reason());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RemoveMemberOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RemoveMemberOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RemoveMemberOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RemoveMemberOptions::MergeFrom(const RemoveMemberOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      mutable_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RemoveMemberOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RemoveMemberOptions::CopyFrom(const RemoveMemberOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RemoveMemberOptions::IsInitialized() const {
+
+  if (has_id()) {
+    if (!this->id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RemoveMemberOptions::Swap(RemoveMemberOptions* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RemoveMemberOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RemoveMemberOptions_descriptor_;
+  metadata.reflection = RemoveMemberOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberRemovedAssignment::kIdFieldNumber;
+const int MemberRemovedAssignment::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+MemberRemovedAssignment::MemberRemovedAssignment()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberRemovedAssignment)
+}
+
+void MemberRemovedAssignment::InitAsDefaultInstance() {
+  id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+MemberRemovedAssignment::MemberRemovedAssignment(const MemberRemovedAssignment& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberRemovedAssignment)
+}
+
+void MemberRemovedAssignment::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = NULL;
+  reason_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberRemovedAssignment::~MemberRemovedAssignment() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberRemovedAssignment)
+  SharedDtor();
+}
+
+void MemberRemovedAssignment::SharedDtor() {
+  if (this != default_instance_) {
+    delete id_;
+  }
+}
+
+void MemberRemovedAssignment::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberRemovedAssignment::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberRemovedAssignment_descriptor_;
+}
+
+const MemberRemovedAssignment& MemberRemovedAssignment::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+MemberRemovedAssignment* MemberRemovedAssignment::default_instance_ = NULL;
+
+MemberRemovedAssignment* MemberRemovedAssignment::New() const {
+  return new MemberRemovedAssignment;
+}
+
+void MemberRemovedAssignment::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_id()) {
+      if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    reason_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberRemovedAssignment::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberRemovedAssignment)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_reason;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_reason:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::ClubRemovedReason_IsValid(value)) {
+            set_reason(static_cast< ::bgs::protocol::club::v1::ClubRemovedReason >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(2, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberRemovedAssignment)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberRemovedAssignment)
+  return false;
+#undef DO_
+}
+
+void MemberRemovedAssignment::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberRemovedAssignment)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberRemovedAssignment)
+}
+
+::google::protobuf::uint8* MemberRemovedAssignment::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberRemovedAssignment)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberRemovedAssignment)
+  return target;
+}
+
+int MemberRemovedAssignment::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->reason());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberRemovedAssignment::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberRemovedAssignment* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberRemovedAssignment*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberRemovedAssignment::MergeFrom(const MemberRemovedAssignment& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      mutable_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberRemovedAssignment::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberRemovedAssignment::CopyFrom(const MemberRemovedAssignment& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberRemovedAssignment::IsInitialized() const {
+
+  if (has_id()) {
+    if (!this->id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void MemberRemovedAssignment::Swap(MemberRemovedAssignment* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberRemovedAssignment::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberRemovedAssignment_descriptor_;
+  metadata.reflection = MemberRemovedAssignment_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberVoiceOptions::kStreamIdFieldNumber;
+const int MemberVoiceOptions::kJoinedFieldNumber;
+const int MemberVoiceOptions::kMicrophoneFieldNumber;
+const int MemberVoiceOptions::kActiveFieldNumber;
+#endif  // !_MSC_VER
+
+MemberVoiceOptions::MemberVoiceOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberVoiceOptions)
+}
+
+void MemberVoiceOptions::InitAsDefaultInstance() {
+}
+
+MemberVoiceOptions::MemberVoiceOptions(const MemberVoiceOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberVoiceOptions)
+}
+
+void MemberVoiceOptions::SharedCtor() {
+  _cached_size_ = 0;
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  joined_ = false;
+  microphone_ = 0;
+  active_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberVoiceOptions::~MemberVoiceOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberVoiceOptions)
+  SharedDtor();
+}
+
+void MemberVoiceOptions::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void MemberVoiceOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberVoiceOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberVoiceOptions_descriptor_;
+}
+
+const MemberVoiceOptions& MemberVoiceOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+MemberVoiceOptions* MemberVoiceOptions::default_instance_ = NULL;
+
+MemberVoiceOptions* MemberVoiceOptions::New() const {
+  return new MemberVoiceOptions;
+}
+
+void MemberVoiceOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<MemberVoiceOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(stream_id_, active_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberVoiceOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberVoiceOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 stream_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_joined;
+        break;
+      }
+
+      // optional bool joined = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_joined:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &joined_)));
+          set_has_joined();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_microphone;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_microphone:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::VoiceMicrophoneState_IsValid(value)) {
+            set_microphone(static_cast< ::bgs::protocol::club::v1::VoiceMicrophoneState >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(3, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_active;
+        break;
+      }
+
+      // optional bool active = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_active:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &active_)));
+          set_has_active();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberVoiceOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberVoiceOptions)
+  return false;
+#undef DO_
+}
+
+void MemberVoiceOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberVoiceOptions)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->stream_id(), output);
+  }
+
+  // optional bool joined = 2;
+  if (has_joined()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->joined(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 3;
+  if (has_microphone()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->microphone(), output);
+  }
+
+  // optional bool active = 4;
+  if (has_active()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->active(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberVoiceOptions)
+}
+
+::google::protobuf::uint8* MemberVoiceOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberVoiceOptions)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->stream_id(), target);
+  }
+
+  // optional bool joined = 2;
+  if (has_joined()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->joined(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 3;
+  if (has_microphone()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      3, this->microphone(), target);
+  }
+
+  // optional bool active = 4;
+  if (has_active()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->active(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberVoiceOptions)
+  return target;
+}
+
+int MemberVoiceOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 stream_id = 1;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional bool joined = 2;
+    if (has_joined()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 3;
+    if (has_microphone()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->microphone());
+    }
+
+    // optional bool active = 4;
+    if (has_active()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberVoiceOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberVoiceOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberVoiceOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberVoiceOptions::MergeFrom(const MemberVoiceOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_joined()) {
+      set_joined(from.joined());
+    }
+    if (from.has_microphone()) {
+      set_microphone(from.microphone());
+    }
+    if (from.has_active()) {
+      set_active(from.active());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberVoiceOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberVoiceOptions::CopyFrom(const MemberVoiceOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberVoiceOptions::IsInitialized() const {
+
+  return true;
+}
+
+void MemberVoiceOptions::Swap(MemberVoiceOptions* other) {
+  if (other != this) {
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(joined_, other->joined_);
+    std::swap(microphone_, other->microphone_);
+    std::swap(active_, other->active_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberVoiceOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberVoiceOptions_descriptor_;
+  metadata.reflection = MemberVoiceOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberVoiceState::kIdFieldNumber;
+const int MemberVoiceState::kStreamIdFieldNumber;
+const int MemberVoiceState::kJoinedFieldNumber;
+const int MemberVoiceState::kMicrophoneFieldNumber;
+const int MemberVoiceState::kActiveFieldNumber;
+#endif  // !_MSC_VER
+
+MemberVoiceState::MemberVoiceState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberVoiceState)
+}
+
+void MemberVoiceState::InitAsDefaultInstance() {
+}
+
+MemberVoiceState::MemberVoiceState(const MemberVoiceState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberVoiceState)
+}
+
+void MemberVoiceState::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  joined_ = false;
+  microphone_ = 0;
+  active_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberVoiceState::~MemberVoiceState() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberVoiceState)
+  SharedDtor();
+}
+
+void MemberVoiceState::SharedDtor() {
+  if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete id_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void MemberVoiceState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberVoiceState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberVoiceState_descriptor_;
+}
+
+const MemberVoiceState& MemberVoiceState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+MemberVoiceState* MemberVoiceState::default_instance_ = NULL;
+
+MemberVoiceState* MemberVoiceState::New() const {
+  return new MemberVoiceState;
+}
+
+void MemberVoiceState::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<MemberVoiceState*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(stream_id_, active_);
+    if (has_id()) {
+      if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        id_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberVoiceState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberVoiceState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->id().data(), this->id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "id");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_joined;
+        break;
+      }
+
+      // optional bool joined = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_joined:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &joined_)));
+          set_has_joined();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_microphone;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_microphone:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::VoiceMicrophoneState_IsValid(value)) {
+            set_microphone(static_cast< ::bgs::protocol::club::v1::VoiceMicrophoneState >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(4, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_active;
+        break;
+      }
+
+      // optional bool active = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_active:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &active_)));
+          set_has_active();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberVoiceState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberVoiceState)
+  return false;
+#undef DO_
+}
+
+void MemberVoiceState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberVoiceState)
+  // optional string id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->id().data(), this->id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->id(), output);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->stream_id(), output);
+  }
+
+  // optional bool joined = 3;
+  if (has_joined()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->joined(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 4;
+  if (has_microphone()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->microphone(), output);
+  }
+
+  // optional bool active = 5;
+  if (has_active()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->active(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberVoiceState)
+}
+
+::google::protobuf::uint8* MemberVoiceState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberVoiceState)
+  // optional string id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->id().data(), this->id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->id(), target);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->stream_id(), target);
+  }
+
+  // optional bool joined = 3;
+  if (has_joined()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->joined(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 4;
+  if (has_microphone()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      4, this->microphone(), target);
+  }
+
+  // optional bool active = 5;
+  if (has_active()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->active(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberVoiceState)
+  return target;
+}
+
+int MemberVoiceState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->id());
+    }
+
+    // optional uint64 stream_id = 2;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional bool joined = 3;
+    if (has_joined()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 4;
+    if (has_microphone()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->microphone());
+    }
+
+    // optional bool active = 5;
+    if (has_active()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberVoiceState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberVoiceState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberVoiceState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberVoiceState::MergeFrom(const MemberVoiceState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_joined()) {
+      set_joined(from.joined());
+    }
+    if (from.has_microphone()) {
+      set_microphone(from.microphone());
+    }
+    if (from.has_active()) {
+      set_active(from.active());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberVoiceState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberVoiceState::CopyFrom(const MemberVoiceState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberVoiceState::IsInitialized() const {
+
+  return true;
+}
+
+void MemberVoiceState::Swap(MemberVoiceState* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(joined_, other->joined_);
+    std::swap(microphone_, other->microphone_);
+    std::swap(active_, other->active_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberVoiceState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberVoiceState_descriptor_;
+  metadata.reflection = MemberVoiceState_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateMemberOptions::kIdFieldNumber;
+const int CreateMemberOptions::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+CreateMemberOptions::CreateMemberOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateMemberOptions)
+}
+
+void CreateMemberOptions::InitAsDefaultInstance() {
+  id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+CreateMemberOptions::CreateMemberOptions(const CreateMemberOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateMemberOptions)
+}
+
+void CreateMemberOptions::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateMemberOptions::~CreateMemberOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateMemberOptions)
+  SharedDtor();
+}
+
+void CreateMemberOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete id_;
+  }
+}
+
+void CreateMemberOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateMemberOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateMemberOptions_descriptor_;
+}
+
+const CreateMemberOptions& CreateMemberOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+CreateMemberOptions* CreateMemberOptions::default_instance_ = NULL;
+
+CreateMemberOptions* CreateMemberOptions::New() const {
+  return new CreateMemberOptions;
+}
+
+void CreateMemberOptions::Clear() {
+  if (has_id()) {
+    if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateMemberOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateMemberOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateMemberOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateMemberOptions)
+  return false;
+#undef DO_
+}
+
+void CreateMemberOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateMemberOptions)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->id(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateMemberOptions)
+}
+
+::google::protobuf::uint8* CreateMemberOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateMemberOptions)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->id(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateMemberOptions)
+  return target;
+}
+
+int CreateMemberOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->id());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateMemberOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateMemberOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateMemberOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateMemberOptions::MergeFrom(const CreateMemberOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      mutable_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateMemberOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateMemberOptions::CopyFrom(const CreateMemberOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateMemberOptions::IsInitialized() const {
+
+  if (has_id()) {
+    if (!this->id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CreateMemberOptions::Swap(CreateMemberOptions* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateMemberOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateMemberOptions_descriptor_;
+  metadata.reflection = CreateMemberOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberDescription::kIdFieldNumber;
+const int MemberDescription::kBattleTagFieldNumber;
+#endif  // !_MSC_VER
+
+MemberDescription::MemberDescription()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberDescription)
+}
+
+void MemberDescription::InitAsDefaultInstance() {
+  id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+MemberDescription::MemberDescription(const MemberDescription& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberDescription)
+}
+
+void MemberDescription::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = NULL;
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberDescription::~MemberDescription() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberDescription)
+  SharedDtor();
+}
+
+void MemberDescription::SharedDtor() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (this != default_instance_) {
+    delete id_;
+  }
+}
+
+void MemberDescription::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberDescription::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberDescription_descriptor_;
+}
+
+const MemberDescription& MemberDescription::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+MemberDescription* MemberDescription::default_instance_ = NULL;
+
+MemberDescription* MemberDescription::New() const {
+  return new MemberDescription;
+}
+
+void MemberDescription::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_id()) {
+      if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberDescription::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberDescription)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberDescription)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberDescription)
+  return false;
+#undef DO_
+}
+
+void MemberDescription::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberDescription)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->id(), output);
+  }
+
+  // optional string battle_tag = 2;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->battle_tag(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberDescription)
+}
+
+::google::protobuf::uint8* MemberDescription::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberDescription)
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->id(), target);
+  }
+
+  // optional string battle_tag = 2;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->battle_tag(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberDescription)
+  return target;
+}
+
+int MemberDescription::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->id());
+    }
+
+    // optional string battle_tag = 2;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberDescription::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberDescription* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberDescription*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberDescription::MergeFrom(const MemberDescription& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      mutable_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.id());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberDescription::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberDescription::CopyFrom(const MemberDescription& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberDescription::IsInitialized() const {
+
+  if (has_id()) {
+    if (!this->id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void MemberDescription::Swap(MemberDescription* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberDescription::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberDescription_descriptor_;
+  metadata.reflection = MemberDescription_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RoleAssignment::kMemberIdFieldNumber;
+const int RoleAssignment::kRoleFieldNumber;
+#endif  // !_MSC_VER
+
+RoleAssignment::RoleAssignment()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.RoleAssignment)
+}
+
+void RoleAssignment::InitAsDefaultInstance() {
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+RoleAssignment::RoleAssignment(const RoleAssignment& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.RoleAssignment)
+}
+
+void RoleAssignment::SharedCtor() {
+  _cached_size_ = 0;
+  member_id_ = NULL;
+  _role_cached_byte_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RoleAssignment::~RoleAssignment() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.RoleAssignment)
+  SharedDtor();
+}
+
+void RoleAssignment::SharedDtor() {
+  if (this != default_instance_) {
+    delete member_id_;
+  }
+}
+
+void RoleAssignment::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RoleAssignment::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RoleAssignment_descriptor_;
+}
+
+const RoleAssignment& RoleAssignment::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+RoleAssignment* RoleAssignment::default_instance_ = NULL;
+
+RoleAssignment* RoleAssignment::New() const {
+  return new RoleAssignment;
+}
+
+void RoleAssignment::Clear() {
+  if (has_member_id()) {
+    if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  }
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RoleAssignment::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.RoleAssignment)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 2 [packed = true];
+      case 2: {
+        if (tag == 18) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 18, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.RoleAssignment)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.RoleAssignment)
+  return false;
+#undef DO_
+}
+
+void RoleAssignment::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.RoleAssignment)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->member_id(), output);
+  }
+
+  // repeated uint32 role = 2 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.RoleAssignment)
+}
+
+::google::protobuf::uint8* RoleAssignment::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.RoleAssignment)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->member_id(), target);
+  }
+
+  // repeated uint32 role = 2 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      2,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.RoleAssignment)
+  return target;
+}
+
+int RoleAssignment::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+  }
+  // repeated uint32 role = 2 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RoleAssignment::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RoleAssignment* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RoleAssignment*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RoleAssignment::MergeFrom(const RoleAssignment& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RoleAssignment::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RoleAssignment::CopyFrom(const RoleAssignment& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RoleAssignment::IsInitialized() const {
+
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RoleAssignment::Swap(RoleAssignment* other) {
+  if (other != this) {
+    std::swap(member_id_, other->member_id_);
+    role_.Swap(&other->role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RoleAssignment::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RoleAssignment_descriptor_;
+  metadata.reflection = RoleAssignment_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberAttributeAssignment::kMemberIdFieldNumber;
+const int MemberAttributeAssignment::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+MemberAttributeAssignment::MemberAttributeAssignment()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberAttributeAssignment)
+}
+
+void MemberAttributeAssignment::InitAsDefaultInstance() {
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+MemberAttributeAssignment::MemberAttributeAssignment(const MemberAttributeAssignment& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberAttributeAssignment)
+}
+
+void MemberAttributeAssignment::SharedCtor() {
+  _cached_size_ = 0;
+  member_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberAttributeAssignment::~MemberAttributeAssignment() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberAttributeAssignment)
+  SharedDtor();
+}
+
+void MemberAttributeAssignment::SharedDtor() {
+  if (this != default_instance_) {
+    delete member_id_;
+  }
+}
+
+void MemberAttributeAssignment::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberAttributeAssignment::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberAttributeAssignment_descriptor_;
+}
+
+const MemberAttributeAssignment& MemberAttributeAssignment::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+MemberAttributeAssignment* MemberAttributeAssignment::default_instance_ = NULL;
+
+MemberAttributeAssignment* MemberAttributeAssignment::New() const {
+  return new MemberAttributeAssignment;
+}
+
+void MemberAttributeAssignment::Clear() {
+  if (has_member_id()) {
+    if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberAttributeAssignment::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberAttributeAssignment)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberAttributeAssignment)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberAttributeAssignment)
+  return false;
+#undef DO_
+}
+
+void MemberAttributeAssignment::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberAttributeAssignment)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->member_id(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberAttributeAssignment)
+}
+
+::google::protobuf::uint8* MemberAttributeAssignment::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberAttributeAssignment)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->member_id(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberAttributeAssignment)
+  return target;
+}
+
+int MemberAttributeAssignment::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberAttributeAssignment::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberAttributeAssignment* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberAttributeAssignment*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberAttributeAssignment::MergeFrom(const MemberAttributeAssignment& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberAttributeAssignment::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberAttributeAssignment::CopyFrom(const MemberAttributeAssignment& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberAttributeAssignment::IsInitialized() const {
+
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void MemberAttributeAssignment::Swap(MemberAttributeAssignment* other) {
+  if (other != this) {
+    std::swap(member_id_, other->member_id_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberAttributeAssignment::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberAttributeAssignment_descriptor_;
+  metadata.reflection = MemberAttributeAssignment_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscriberStateOptions::kVoiceFieldNumber;
+#endif  // !_MSC_VER
+
+SubscriberStateOptions::SubscriberStateOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SubscriberStateOptions)
+}
+
+void SubscriberStateOptions::InitAsDefaultInstance() {
+  voice_ = const_cast< ::bgs::protocol::club::v1::MemberVoiceOptions*>(&::bgs::protocol::club::v1::MemberVoiceOptions::default_instance());
+}
+
+SubscriberStateOptions::SubscriberStateOptions(const SubscriberStateOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SubscriberStateOptions)
+}
+
+void SubscriberStateOptions::SharedCtor() {
+  _cached_size_ = 0;
+  voice_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscriberStateOptions::~SubscriberStateOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SubscriberStateOptions)
+  SharedDtor();
+}
+
+void SubscriberStateOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete voice_;
+  }
+}
+
+void SubscriberStateOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscriberStateOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscriberStateOptions_descriptor_;
+}
+
+const SubscriberStateOptions& SubscriberStateOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+SubscriberStateOptions* SubscriberStateOptions::default_instance_ = NULL;
+
+SubscriberStateOptions* SubscriberStateOptions::New() const {
+  return new SubscriberStateOptions;
+}
+
+void SubscriberStateOptions::Clear() {
+  if (has_voice()) {
+    if (voice_ != NULL) voice_->::bgs::protocol::club::v1::MemberVoiceOptions::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscriberStateOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SubscriberStateOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberVoiceOptions voice = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_voice()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SubscriberStateOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SubscriberStateOptions)
+  return false;
+#undef DO_
+}
+
+void SubscriberStateOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SubscriberStateOptions)
+  // optional .bgs.protocol.club.v1.MemberVoiceOptions voice = 1;
+  if (has_voice()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->voice(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SubscriberStateOptions)
+}
+
+::google::protobuf::uint8* SubscriberStateOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SubscriberStateOptions)
+  // optional .bgs.protocol.club.v1.MemberVoiceOptions voice = 1;
+  if (has_voice()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->voice(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SubscriberStateOptions)
+  return target;
+}
+
+int SubscriberStateOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberVoiceOptions voice = 1;
+    if (has_voice()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->voice());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscriberStateOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscriberStateOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscriberStateOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscriberStateOptions::MergeFrom(const SubscriberStateOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_voice()) {
+      mutable_voice()->::bgs::protocol::club::v1::MemberVoiceOptions::MergeFrom(from.voice());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscriberStateOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscriberStateOptions::CopyFrom(const SubscriberStateOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscriberStateOptions::IsInitialized() const {
+
+  return true;
+}
+
+void SubscriberStateOptions::Swap(SubscriberStateOptions* other) {
+  if (other != this) {
+    std::swap(voice_, other->voice_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscriberStateOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscriberStateOptions_descriptor_;
+  metadata.reflection = SubscriberStateOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscriberStateAssignment::kMemberIdFieldNumber;
+const int SubscriberStateAssignment::kActiveFieldNumber;
+const int SubscriberStateAssignment::kVoiceFieldNumber;
+#endif  // !_MSC_VER
+
+SubscriberStateAssignment::SubscriberStateAssignment()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SubscriberStateAssignment)
+}
+
+void SubscriberStateAssignment::InitAsDefaultInstance() {
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  voice_ = const_cast< ::bgs::protocol::club::v1::MemberVoiceState*>(&::bgs::protocol::club::v1::MemberVoiceState::default_instance());
+}
+
+SubscriberStateAssignment::SubscriberStateAssignment(const SubscriberStateAssignment& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SubscriberStateAssignment)
+}
+
+void SubscriberStateAssignment::SharedCtor() {
+  _cached_size_ = 0;
+  member_id_ = NULL;
+  active_ = false;
+  voice_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscriberStateAssignment::~SubscriberStateAssignment() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SubscriberStateAssignment)
+  SharedDtor();
+}
+
+void SubscriberStateAssignment::SharedDtor() {
+  if (this != default_instance_) {
+    delete member_id_;
+    delete voice_;
+  }
+}
+
+void SubscriberStateAssignment::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscriberStateAssignment::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscriberStateAssignment_descriptor_;
+}
+
+const SubscriberStateAssignment& SubscriberStateAssignment::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+SubscriberStateAssignment* SubscriberStateAssignment::default_instance_ = NULL;
+
+SubscriberStateAssignment* SubscriberStateAssignment::New() const {
+  return new SubscriberStateAssignment;
+}
+
+void SubscriberStateAssignment::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    active_ = false;
+    if (has_voice()) {
+      if (voice_ != NULL) voice_->::bgs::protocol::club::v1::MemberVoiceState::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscriberStateAssignment::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SubscriberStateAssignment)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_active;
+        break;
+      }
+
+      // optional bool active = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_active:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &active_)));
+          set_has_active();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_voice;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberVoiceState voice = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_voice:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_voice()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SubscriberStateAssignment)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SubscriberStateAssignment)
+  return false;
+#undef DO_
+}
+
+void SubscriberStateAssignment::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SubscriberStateAssignment)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->member_id(), output);
+  }
+
+  // optional bool active = 2;
+  if (has_active()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->active(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberVoiceState voice = 3;
+  if (has_voice()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->voice(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SubscriberStateAssignment)
+}
+
+::google::protobuf::uint8* SubscriberStateAssignment::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SubscriberStateAssignment)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->member_id(), target);
+  }
+
+  // optional bool active = 2;
+  if (has_active()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->active(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberVoiceState voice = 3;
+  if (has_voice()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->voice(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SubscriberStateAssignment)
+  return target;
+}
+
+int SubscriberStateAssignment::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+    // optional bool active = 2;
+    if (has_active()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.club.v1.MemberVoiceState voice = 3;
+    if (has_voice()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->voice());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscriberStateAssignment::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscriberStateAssignment* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscriberStateAssignment*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscriberStateAssignment::MergeFrom(const SubscriberStateAssignment& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+    if (from.has_active()) {
+      set_active(from.active());
+    }
+    if (from.has_voice()) {
+      mutable_voice()->::bgs::protocol::club::v1::MemberVoiceState::MergeFrom(from.voice());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscriberStateAssignment::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscriberStateAssignment::CopyFrom(const SubscriberStateAssignment& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscriberStateAssignment::IsInitialized() const {
+
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscriberStateAssignment::Swap(SubscriberStateAssignment* other) {
+  if (other != this) {
+    std::swap(member_id_, other->member_id_);
+    std::swap(active_, other->active_);
+    std::swap(voice_, other->voice_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscriberStateAssignment::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscriberStateAssignment_descriptor_;
+  metadata.reflection = SubscriberStateAssignment_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberStateOptions::kAttributeFieldNumber;
+const int MemberStateOptions::kPresenceLevelFieldNumber;
+const int MemberStateOptions::kModeratorMuteFieldNumber;
+const int MemberStateOptions::kWhisperLevelFieldNumber;
+const int MemberStateOptions::kNoteFieldNumber;
+#endif  // !_MSC_VER
+
+MemberStateOptions::MemberStateOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberStateOptions)
+}
+
+void MemberStateOptions::InitAsDefaultInstance() {
+}
+
+MemberStateOptions::MemberStateOptions(const MemberStateOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberStateOptions)
+}
+
+void MemberStateOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  presence_level_ = 0;
+  moderator_mute_ = false;
+  whisper_level_ = 0;
+  note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberStateOptions::~MemberStateOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberStateOptions)
+  SharedDtor();
+}
+
+void MemberStateOptions::SharedDtor() {
+  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete note_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void MemberStateOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberStateOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberStateOptions_descriptor_;
+}
+
+const MemberStateOptions& MemberStateOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+MemberStateOptions* MemberStateOptions::default_instance_ = NULL;
+
+MemberStateOptions* MemberStateOptions::New() const {
+  return new MemberStateOptions;
+}
+
+void MemberStateOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<MemberStateOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 30) {
+    ZR_(presence_level_, moderator_mute_);
+    whisper_level_ = 0;
+    if (has_note()) {
+      if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        note_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberStateOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberStateOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.v2.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectTag(16)) goto parse_presence_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_presence_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::PresenceLevel_IsValid(value)) {
+            set_presence_level(static_cast< ::bgs::protocol::club::v1::PresenceLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(2, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_moderator_mute;
+        break;
+      }
+
+      // optional bool moderator_mute = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_moderator_mute:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &moderator_mute_)));
+          set_has_moderator_mute();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_whisper_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_whisper_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::WhisperLevel_IsValid(value)) {
+            set_whisper_level(static_cast< ::bgs::protocol::club::v1::WhisperLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(4, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_note;
+        break;
+      }
+
+      // optional string note = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_note:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_note()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->note().data(), this->note().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "note");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberStateOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberStateOptions)
+  return false;
+#undef DO_
+}
+
+void MemberStateOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberStateOptions)
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 2;
+  if (has_presence_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->presence_level(), output);
+  }
+
+  // optional bool moderator_mute = 3;
+  if (has_moderator_mute()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->moderator_mute(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 4;
+  if (has_whisper_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->whisper_level(), output);
+  }
+
+  // optional string note = 5;
+  if (has_note()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->note().data(), this->note().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "note");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->note(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberStateOptions)
+}
+
+::google::protobuf::uint8* MemberStateOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberStateOptions)
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 2;
+  if (has_presence_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->presence_level(), target);
+  }
+
+  // optional bool moderator_mute = 3;
+  if (has_moderator_mute()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->moderator_mute(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 4;
+  if (has_whisper_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      4, this->whisper_level(), target);
+  }
+
+  // optional string note = 5;
+  if (has_note()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->note().data(), this->note().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "note");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->note(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberStateOptions)
+  return target;
+}
+
+int MemberStateOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 2;
+    if (has_presence_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->presence_level());
+    }
+
+    // optional bool moderator_mute = 3;
+    if (has_moderator_mute()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 4;
+    if (has_whisper_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->whisper_level());
+    }
+
+    // optional string note = 5;
+    if (has_note()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->note());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberStateOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberStateOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberStateOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberStateOptions::MergeFrom(const MemberStateOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_presence_level()) {
+      set_presence_level(from.presence_level());
+    }
+    if (from.has_moderator_mute()) {
+      set_moderator_mute(from.moderator_mute());
+    }
+    if (from.has_whisper_level()) {
+      set_whisper_level(from.whisper_level());
+    }
+    if (from.has_note()) {
+      set_note(from.note());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberStateOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberStateOptions::CopyFrom(const MemberStateOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberStateOptions::IsInitialized() const {
+
+  return true;
+}
+
+void MemberStateOptions::Swap(MemberStateOptions* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    std::swap(presence_level_, other->presence_level_);
+    std::swap(moderator_mute_, other->moderator_mute_);
+    std::swap(whisper_level_, other->whisper_level_);
+    std::swap(note_, other->note_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberStateOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberStateOptions_descriptor_;
+  metadata.reflection = MemberStateOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberStateAssignment::kMemberIdFieldNumber;
+const int MemberStateAssignment::kAttributeFieldNumber;
+const int MemberStateAssignment::kPresenceLevelFieldNumber;
+const int MemberStateAssignment::kModeratorMuteFieldNumber;
+const int MemberStateAssignment::kWhisperLevelFieldNumber;
+const int MemberStateAssignment::kNoteFieldNumber;
+#endif  // !_MSC_VER
+
+MemberStateAssignment::MemberStateAssignment()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberStateAssignment)
+}
+
+void MemberStateAssignment::InitAsDefaultInstance() {
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+MemberStateAssignment::MemberStateAssignment(const MemberStateAssignment& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberStateAssignment)
+}
+
+void MemberStateAssignment::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  member_id_ = NULL;
+  presence_level_ = 0;
+  moderator_mute_ = false;
+  whisper_level_ = 0;
+  note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberStateAssignment::~MemberStateAssignment() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberStateAssignment)
+  SharedDtor();
+}
+
+void MemberStateAssignment::SharedDtor() {
+  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete note_;
+  }
+  if (this != default_instance_) {
+    delete member_id_;
+  }
+}
+
+void MemberStateAssignment::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberStateAssignment::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberStateAssignment_descriptor_;
+}
+
+const MemberStateAssignment& MemberStateAssignment::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmember_2eproto();
+  return *default_instance_;
+}
+
+MemberStateAssignment* MemberStateAssignment::default_instance_ = NULL;
+
+MemberStateAssignment* MemberStateAssignment::New() const {
+  return new MemberStateAssignment;
+}
+
+void MemberStateAssignment::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<MemberStateAssignment*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 61) {
+    ZR_(presence_level_, moderator_mute_);
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    whisper_level_ = 0;
+    if (has_note()) {
+      if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        note_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberStateAssignment::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberStateAssignment)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectTag(24)) goto parse_presence_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_presence_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::PresenceLevel_IsValid(value)) {
+            set_presence_level(static_cast< ::bgs::protocol::club::v1::PresenceLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(3, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_moderator_mute;
+        break;
+      }
+
+      // optional bool moderator_mute = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_moderator_mute:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &moderator_mute_)));
+          set_has_moderator_mute();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_whisper_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_whisper_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::WhisperLevel_IsValid(value)) {
+            set_whisper_level(static_cast< ::bgs::protocol::club::v1::WhisperLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(5, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_note;
+        break;
+      }
+
+      // optional string note = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_note:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_note()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->note().data(), this->note().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "note");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberStateAssignment)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberStateAssignment)
+  return false;
+#undef DO_
+}
+
+void MemberStateAssignment::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberStateAssignment)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->member_id(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 3;
+  if (has_presence_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      3, this->presence_level(), output);
+  }
+
+  // optional bool moderator_mute = 4;
+  if (has_moderator_mute()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->moderator_mute(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 5;
+  if (has_whisper_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->whisper_level(), output);
+  }
+
+  // optional string note = 6;
+  if (has_note()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->note().data(), this->note().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "note");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      6, this->note(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberStateAssignment)
+}
+
+::google::protobuf::uint8* MemberStateAssignment::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberStateAssignment)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->member_id(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 3;
+  if (has_presence_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      3, this->presence_level(), target);
+  }
+
+  // optional bool moderator_mute = 4;
+  if (has_moderator_mute()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->moderator_mute(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 5;
+  if (has_whisper_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      5, this->whisper_level(), target);
+  }
+
+  // optional string note = 6;
+  if (has_note()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->note().data(), this->note().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "note");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->note(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberStateAssignment)
+  return target;
+}
+
+int MemberStateAssignment::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+    // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 3;
+    if (has_presence_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->presence_level());
+    }
+
+    // optional bool moderator_mute = 4;
+    if (has_moderator_mute()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 5;
+    if (has_whisper_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->whisper_level());
+    }
+
+    // optional string note = 6;
+    if (has_note()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->note());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberStateAssignment::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberStateAssignment* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberStateAssignment*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberStateAssignment::MergeFrom(const MemberStateAssignment& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+    if (from.has_presence_level()) {
+      set_presence_level(from.presence_level());
+    }
+    if (from.has_moderator_mute()) {
+      set_moderator_mute(from.moderator_mute());
+    }
+    if (from.has_whisper_level()) {
+      set_whisper_level(from.whisper_level());
+    }
+    if (from.has_note()) {
+      set_note(from.note());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberStateAssignment::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberStateAssignment::CopyFrom(const MemberStateAssignment& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberStateAssignment::IsInitialized() const {
+
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void MemberStateAssignment::Swap(MemberStateAssignment* other) {
+  if (other != this) {
+    std::swap(member_id_, other->member_id_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(presence_level_, other->presence_level_);
+    std::swap(moderator_mute_, other->moderator_mute_);
+    std::swap(whisper_level_, other->whisper_level_);
+    std::swap(note_, other->note_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberStateAssignment::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberStateAssignment_descriptor_;
+  metadata.reflection = MemberStateAssignment_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_member.pb.h b/src/server/proto/Client/club_member.pb.h
new file mode 100644
index 00000000000..249ef006b38
--- /dev/null
+++ b/src/server/proto/Client/club_member.pb.h
@@ -0,0 +1,3597 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_member.proto
+
+#ifndef PROTOBUF_club_5fmember_2eproto__INCLUDED
+#define PROTOBUF_club_5fmember_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "global_extensions/message_options.pb.h"
+#include "api/client/v2/attribute_types.pb.h"
+#include "account_types.pb.h"
+#include "club_enum.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+void protobuf_AssignDesc_club_5fmember_2eproto();
+void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+class MemberId;
+class Member;
+class MemberResult;
+class RemoveMemberOptions;
+class MemberRemovedAssignment;
+class MemberVoiceOptions;
+class MemberVoiceState;
+class CreateMemberOptions;
+class MemberDescription;
+class RoleAssignment;
+class MemberAttributeAssignment;
+class SubscriberStateOptions;
+class SubscriberStateAssignment;
+class MemberStateOptions;
+class MemberStateAssignment;
+
+// ===================================================================
+
+class TC_PROTO_API MemberId : public ::google::protobuf::Message {
+ public:
+  MemberId();
+  virtual ~MemberId();
+
+  MemberId(const MemberId& from);
+
+  inline MemberId& operator=(const MemberId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberId& default_instance();
+
+  void Swap(MemberId* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberId* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberId& from);
+  void MergeFrom(const MemberId& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId account_id = 1;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& account_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_account_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_account_id();
+  inline void set_allocated_account_id(::bgs::protocol::account::v1::AccountId* account_id);
+
+  // optional uint64 unique_id = 2;
+  inline bool has_unique_id() const;
+  inline void clear_unique_id();
+  static const int kUniqueIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 unique_id() const;
+  inline void set_unique_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberId)
+ private:
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+  inline void set_has_unique_id();
+  inline void clear_has_unique_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* account_id_;
+  ::google::protobuf::uint64 unique_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberId* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API Member : public ::google::protobuf::Message {
+ public:
+  Member();
+  virtual ~Member();
+
+  Member(const Member& from);
+
+  inline Member& operator=(const Member& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Member& default_instance();
+
+  void Swap(Member* other);
+
+  // implements Message ----------------------------------------------
+
+  Member* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Member& from);
+  void MergeFrom(const Member& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_id();
+  inline void set_allocated_id(::bgs::protocol::club::v1::MemberId* id);
+
+  // optional string battle_tag = 2;
+  inline bool has_battle_tag() const;
+  inline void clear_battle_tag();
+  static const int kBattleTagFieldNumber = 2;
+  inline const ::std::string& battle_tag() const;
+  inline void set_battle_tag(const ::std::string& value);
+  inline void set_battle_tag(const char* value);
+  inline void set_battle_tag(const char* value, size_t size);
+  inline ::std::string* mutable_battle_tag();
+  inline ::std::string* release_battle_tag();
+  inline void set_allocated_battle_tag(::std::string* battle_tag);
+
+  // repeated uint32 role = 3 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 3;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 4;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 4;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional uint64 join_time = 5;
+  inline bool has_join_time() const;
+  inline void clear_join_time();
+  static const int kJoinTimeFieldNumber = 5;
+  inline ::google::protobuf::uint64 join_time() const;
+  inline void set_join_time(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 6;
+  inline bool has_presence_level() const;
+  inline void clear_presence_level();
+  static const int kPresenceLevelFieldNumber = 6;
+  inline ::bgs::protocol::club::v1::PresenceLevel presence_level() const;
+  inline void set_presence_level(::bgs::protocol::club::v1::PresenceLevel value);
+
+  // optional bool moderator_mute = 7;
+  inline bool has_moderator_mute() const;
+  inline void clear_moderator_mute();
+  static const int kModeratorMuteFieldNumber = 7;
+  inline bool moderator_mute() const;
+  inline void set_moderator_mute(bool value);
+
+  // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 8;
+  inline bool has_whisper_level() const;
+  inline void clear_whisper_level();
+  static const int kWhisperLevelFieldNumber = 8;
+  inline ::bgs::protocol::club::v1::WhisperLevel whisper_level() const;
+  inline void set_whisper_level(::bgs::protocol::club::v1::WhisperLevel value);
+
+  // optional string note = 9;
+  inline bool has_note() const;
+  inline void clear_note();
+  static const int kNoteFieldNumber = 9;
+  inline const ::std::string& note() const;
+  inline void set_note(const ::std::string& value);
+  inline void set_note(const char* value);
+  inline void set_note(const char* value, size_t size);
+  inline ::std::string* mutable_note();
+  inline ::std::string* release_note();
+  inline void set_allocated_note(::std::string* note);
+
+  // optional bool active = 50;
+  inline bool has_active() const;
+  inline void clear_active();
+  static const int kActiveFieldNumber = 50;
+  inline bool active() const;
+  inline void set_active(bool value);
+
+  // optional .bgs.protocol.club.v1.MemberVoiceState voice = 51;
+  inline bool has_voice() const;
+  inline void clear_voice();
+  static const int kVoiceFieldNumber = 51;
+  inline const ::bgs::protocol::club::v1::MemberVoiceState& voice() const;
+  inline ::bgs::protocol::club::v1::MemberVoiceState* mutable_voice();
+  inline ::bgs::protocol::club::v1::MemberVoiceState* release_voice();
+  inline void set_allocated_voice(::bgs::protocol::club::v1::MemberVoiceState* voice);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.Member)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+  inline void set_has_join_time();
+  inline void clear_has_join_time();
+  inline void set_has_presence_level();
+  inline void clear_has_presence_level();
+  inline void set_has_moderator_mute();
+  inline void clear_has_moderator_mute();
+  inline void set_has_whisper_level();
+  inline void clear_has_whisper_level();
+  inline void set_has_note();
+  inline void clear_has_note();
+  inline void set_has_active();
+  inline void clear_has_active();
+  inline void set_has_voice();
+  inline void clear_has_voice();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* id_;
+  ::std::string* battle_tag_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::google::protobuf::uint64 join_time_;
+  int presence_level_;
+  int whisper_level_;
+  ::std::string* note_;
+  ::bgs::protocol::club::v1::MemberVoiceState* voice_;
+  bool moderator_mute_;
+  bool active_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static Member* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberResult : public ::google::protobuf::Message {
+ public:
+  MemberResult();
+  virtual ~MemberResult();
+
+  MemberResult(const MemberResult& from);
+
+  inline MemberResult& operator=(const MemberResult& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberResult& default_instance();
+
+  void Swap(MemberResult* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberResult* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberResult& from);
+  void MergeFrom(const MemberResult& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // optional uint32 status = 2;
+  inline bool has_status() const;
+  inline void clear_status();
+  static const int kStatusFieldNumber = 2;
+  inline ::google::protobuf::uint32 status() const;
+  inline void set_status(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberResult)
+ private:
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+  inline void set_has_status();
+  inline void clear_has_status();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  ::google::protobuf::uint32 status_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberResult* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RemoveMemberOptions : public ::google::protobuf::Message {
+ public:
+  RemoveMemberOptions();
+  virtual ~RemoveMemberOptions();
+
+  RemoveMemberOptions(const RemoveMemberOptions& from);
+
+  inline RemoveMemberOptions& operator=(const RemoveMemberOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RemoveMemberOptions& default_instance();
+
+  void Swap(RemoveMemberOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  RemoveMemberOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RemoveMemberOptions& from);
+  void MergeFrom(const RemoveMemberOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_id();
+  inline void set_allocated_id(::bgs::protocol::club::v1::MemberId* id);
+
+  // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 2;
+  inline ::bgs::protocol::club::v1::ClubRemovedReason reason() const;
+  inline void set_reason(::bgs::protocol::club::v1::ClubRemovedReason value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.RemoveMemberOptions)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* id_;
+  int reason_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static RemoveMemberOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberRemovedAssignment : public ::google::protobuf::Message {
+ public:
+  MemberRemovedAssignment();
+  virtual ~MemberRemovedAssignment();
+
+  MemberRemovedAssignment(const MemberRemovedAssignment& from);
+
+  inline MemberRemovedAssignment& operator=(const MemberRemovedAssignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberRemovedAssignment& default_instance();
+
+  void Swap(MemberRemovedAssignment* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberRemovedAssignment* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberRemovedAssignment& from);
+  void MergeFrom(const MemberRemovedAssignment& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_id();
+  inline void set_allocated_id(::bgs::protocol::club::v1::MemberId* id);
+
+  // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 2;
+  inline ::bgs::protocol::club::v1::ClubRemovedReason reason() const;
+  inline void set_reason(::bgs::protocol::club::v1::ClubRemovedReason value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberRemovedAssignment)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* id_;
+  int reason_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberRemovedAssignment* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberVoiceOptions : public ::google::protobuf::Message {
+ public:
+  MemberVoiceOptions();
+  virtual ~MemberVoiceOptions();
+
+  MemberVoiceOptions(const MemberVoiceOptions& from);
+
+  inline MemberVoiceOptions& operator=(const MemberVoiceOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberVoiceOptions& default_instance();
+
+  void Swap(MemberVoiceOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberVoiceOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberVoiceOptions& from);
+  void MergeFrom(const MemberVoiceOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 stream_id = 1;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional bool joined = 2;
+  inline bool has_joined() const;
+  inline void clear_joined();
+  static const int kJoinedFieldNumber = 2;
+  inline bool joined() const;
+  inline void set_joined(bool value);
+
+  // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 3;
+  inline bool has_microphone() const;
+  inline void clear_microphone();
+  static const int kMicrophoneFieldNumber = 3;
+  inline ::bgs::protocol::club::v1::VoiceMicrophoneState microphone() const;
+  inline void set_microphone(::bgs::protocol::club::v1::VoiceMicrophoneState value);
+
+  // optional bool active = 4;
+  inline bool has_active() const;
+  inline void clear_active();
+  static const int kActiveFieldNumber = 4;
+  inline bool active() const;
+  inline void set_active(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberVoiceOptions)
+ private:
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_joined();
+  inline void clear_has_joined();
+  inline void set_has_microphone();
+  inline void clear_has_microphone();
+  inline void set_has_active();
+  inline void clear_has_active();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 stream_id_;
+  int microphone_;
+  bool joined_;
+  bool active_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberVoiceOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberVoiceState : public ::google::protobuf::Message {
+ public:
+  MemberVoiceState();
+  virtual ~MemberVoiceState();
+
+  MemberVoiceState(const MemberVoiceState& from);
+
+  inline MemberVoiceState& operator=(const MemberVoiceState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberVoiceState& default_instance();
+
+  void Swap(MemberVoiceState* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberVoiceState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberVoiceState& from);
+  void MergeFrom(const MemberVoiceState& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::std::string& id() const;
+  inline void set_id(const ::std::string& value);
+  inline void set_id(const char* value);
+  inline void set_id(const char* value, size_t size);
+  inline ::std::string* mutable_id();
+  inline ::std::string* release_id();
+  inline void set_allocated_id(::std::string* id);
+
+  // optional uint64 stream_id = 2;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional bool joined = 3;
+  inline bool has_joined() const;
+  inline void clear_joined();
+  static const int kJoinedFieldNumber = 3;
+  inline bool joined() const;
+  inline void set_joined(bool value);
+
+  // optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 4;
+  inline bool has_microphone() const;
+  inline void clear_microphone();
+  static const int kMicrophoneFieldNumber = 4;
+  inline ::bgs::protocol::club::v1::VoiceMicrophoneState microphone() const;
+  inline void set_microphone(::bgs::protocol::club::v1::VoiceMicrophoneState value);
+
+  // optional bool active = 5;
+  inline bool has_active() const;
+  inline void clear_active();
+  static const int kActiveFieldNumber = 5;
+  inline bool active() const;
+  inline void set_active(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberVoiceState)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_joined();
+  inline void clear_has_joined();
+  inline void set_has_microphone();
+  inline void clear_has_microphone();
+  inline void set_has_active();
+  inline void clear_has_active();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* id_;
+  ::google::protobuf::uint64 stream_id_;
+  int microphone_;
+  bool joined_;
+  bool active_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberVoiceState* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateMemberOptions : public ::google::protobuf::Message {
+ public:
+  CreateMemberOptions();
+  virtual ~CreateMemberOptions();
+
+  CreateMemberOptions(const CreateMemberOptions& from);
+
+  inline CreateMemberOptions& operator=(const CreateMemberOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateMemberOptions& default_instance();
+
+  void Swap(CreateMemberOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateMemberOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateMemberOptions& from);
+  void MergeFrom(const CreateMemberOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_id();
+  inline void set_allocated_id(::bgs::protocol::club::v1::MemberId* id);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateMemberOptions)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateMemberOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberDescription : public ::google::protobuf::Message {
+ public:
+  MemberDescription();
+  virtual ~MemberDescription();
+
+  MemberDescription(const MemberDescription& from);
+
+  inline MemberDescription& operator=(const MemberDescription& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberDescription& default_instance();
+
+  void Swap(MemberDescription* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberDescription* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberDescription& from);
+  void MergeFrom(const MemberDescription& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_id();
+  inline void set_allocated_id(::bgs::protocol::club::v1::MemberId* id);
+
+  // optional string battle_tag = 2;
+  inline bool has_battle_tag() const;
+  inline void clear_battle_tag();
+  static const int kBattleTagFieldNumber = 2;
+  inline const ::std::string& battle_tag() const;
+  inline void set_battle_tag(const ::std::string& value);
+  inline void set_battle_tag(const char* value);
+  inline void set_battle_tag(const char* value, size_t size);
+  inline ::std::string* mutable_battle_tag();
+  inline ::std::string* release_battle_tag();
+  inline void set_allocated_battle_tag(::std::string* battle_tag);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberDescription)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* id_;
+  ::std::string* battle_tag_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberDescription* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RoleAssignment : public ::google::protobuf::Message {
+ public:
+  RoleAssignment();
+  virtual ~RoleAssignment();
+
+  RoleAssignment(const RoleAssignment& from);
+
+  inline RoleAssignment& operator=(const RoleAssignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RoleAssignment& default_instance();
+
+  void Swap(RoleAssignment* other);
+
+  // implements Message ----------------------------------------------
+
+  RoleAssignment* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RoleAssignment& from);
+  void MergeFrom(const RoleAssignment& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // repeated uint32 role = 2 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 2;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.RoleAssignment)
+ private:
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static RoleAssignment* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberAttributeAssignment : public ::google::protobuf::Message {
+ public:
+  MemberAttributeAssignment();
+  virtual ~MemberAttributeAssignment();
+
+  MemberAttributeAssignment(const MemberAttributeAssignment& from);
+
+  inline MemberAttributeAssignment& operator=(const MemberAttributeAssignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberAttributeAssignment& default_instance();
+
+  void Swap(MemberAttributeAssignment* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberAttributeAssignment* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberAttributeAssignment& from);
+  void MergeFrom(const MemberAttributeAssignment& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberAttributeAssignment)
+ private:
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberAttributeAssignment* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SubscriberStateOptions : public ::google::protobuf::Message {
+ public:
+  SubscriberStateOptions();
+  virtual ~SubscriberStateOptions();
+
+  SubscriberStateOptions(const SubscriberStateOptions& from);
+
+  inline SubscriberStateOptions& operator=(const SubscriberStateOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubscriberStateOptions& default_instance();
+
+  void Swap(SubscriberStateOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscriberStateOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscriberStateOptions& from);
+  void MergeFrom(const SubscriberStateOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberVoiceOptions voice = 1;
+  inline bool has_voice() const;
+  inline void clear_voice();
+  static const int kVoiceFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberVoiceOptions& voice() const;
+  inline ::bgs::protocol::club::v1::MemberVoiceOptions* mutable_voice();
+  inline ::bgs::protocol::club::v1::MemberVoiceOptions* release_voice();
+  inline void set_allocated_voice(::bgs::protocol::club::v1::MemberVoiceOptions* voice);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SubscriberStateOptions)
+ private:
+  inline void set_has_voice();
+  inline void clear_has_voice();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberVoiceOptions* voice_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscriberStateOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SubscriberStateAssignment : public ::google::protobuf::Message {
+ public:
+  SubscriberStateAssignment();
+  virtual ~SubscriberStateAssignment();
+
+  SubscriberStateAssignment(const SubscriberStateAssignment& from);
+
+  inline SubscriberStateAssignment& operator=(const SubscriberStateAssignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubscriberStateAssignment& default_instance();
+
+  void Swap(SubscriberStateAssignment* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscriberStateAssignment* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscriberStateAssignment& from);
+  void MergeFrom(const SubscriberStateAssignment& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // optional bool active = 2;
+  inline bool has_active() const;
+  inline void clear_active();
+  static const int kActiveFieldNumber = 2;
+  inline bool active() const;
+  inline void set_active(bool value);
+
+  // optional .bgs.protocol.club.v1.MemberVoiceState voice = 3;
+  inline bool has_voice() const;
+  inline void clear_voice();
+  static const int kVoiceFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberVoiceState& voice() const;
+  inline ::bgs::protocol::club::v1::MemberVoiceState* mutable_voice();
+  inline ::bgs::protocol::club::v1::MemberVoiceState* release_voice();
+  inline void set_allocated_voice(::bgs::protocol::club::v1::MemberVoiceState* voice);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SubscriberStateAssignment)
+ private:
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+  inline void set_has_active();
+  inline void clear_has_active();
+  inline void set_has_voice();
+  inline void clear_has_voice();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  ::bgs::protocol::club::v1::MemberVoiceState* voice_;
+  bool active_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscriberStateAssignment* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberStateOptions : public ::google::protobuf::Message {
+ public:
+  MemberStateOptions();
+  virtual ~MemberStateOptions();
+
+  MemberStateOptions(const MemberStateOptions& from);
+
+  inline MemberStateOptions& operator=(const MemberStateOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberStateOptions& default_instance();
+
+  void Swap(MemberStateOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberStateOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberStateOptions& from);
+  void MergeFrom(const MemberStateOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 2;
+  inline bool has_presence_level() const;
+  inline void clear_presence_level();
+  static const int kPresenceLevelFieldNumber = 2;
+  inline ::bgs::protocol::club::v1::PresenceLevel presence_level() const;
+  inline void set_presence_level(::bgs::protocol::club::v1::PresenceLevel value);
+
+  // optional bool moderator_mute = 3;
+  inline bool has_moderator_mute() const;
+  inline void clear_moderator_mute();
+  static const int kModeratorMuteFieldNumber = 3;
+  inline bool moderator_mute() const;
+  inline void set_moderator_mute(bool value);
+
+  // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 4;
+  inline bool has_whisper_level() const;
+  inline void clear_whisper_level();
+  static const int kWhisperLevelFieldNumber = 4;
+  inline ::bgs::protocol::club::v1::WhisperLevel whisper_level() const;
+  inline void set_whisper_level(::bgs::protocol::club::v1::WhisperLevel value);
+
+  // optional string note = 5;
+  inline bool has_note() const;
+  inline void clear_note();
+  static const int kNoteFieldNumber = 5;
+  inline const ::std::string& note() const;
+  inline void set_note(const ::std::string& value);
+  inline void set_note(const char* value);
+  inline void set_note(const char* value, size_t size);
+  inline ::std::string* mutable_note();
+  inline ::std::string* release_note();
+  inline void set_allocated_note(::std::string* note);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberStateOptions)
+ private:
+  inline void set_has_presence_level();
+  inline void clear_has_presence_level();
+  inline void set_has_moderator_mute();
+  inline void clear_has_moderator_mute();
+  inline void set_has_whisper_level();
+  inline void clear_has_whisper_level();
+  inline void set_has_note();
+  inline void clear_has_note();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  int presence_level_;
+  bool moderator_mute_;
+  ::std::string* note_;
+  int whisper_level_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberStateOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberStateAssignment : public ::google::protobuf::Message {
+ public:
+  MemberStateAssignment();
+  virtual ~MemberStateAssignment();
+
+  MemberStateAssignment(const MemberStateAssignment& from);
+
+  inline MemberStateAssignment& operator=(const MemberStateAssignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberStateAssignment& default_instance();
+
+  void Swap(MemberStateAssignment* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberStateAssignment* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberStateAssignment& from);
+  void MergeFrom(const MemberStateAssignment& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional .bgs.protocol.club.v1.PresenceLevel presence_level = 3;
+  inline bool has_presence_level() const;
+  inline void clear_presence_level();
+  static const int kPresenceLevelFieldNumber = 3;
+  inline ::bgs::protocol::club::v1::PresenceLevel presence_level() const;
+  inline void set_presence_level(::bgs::protocol::club::v1::PresenceLevel value);
+
+  // optional bool moderator_mute = 4;
+  inline bool has_moderator_mute() const;
+  inline void clear_moderator_mute();
+  static const int kModeratorMuteFieldNumber = 4;
+  inline bool moderator_mute() const;
+  inline void set_moderator_mute(bool value);
+
+  // optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 5;
+  inline bool has_whisper_level() const;
+  inline void clear_whisper_level();
+  static const int kWhisperLevelFieldNumber = 5;
+  inline ::bgs::protocol::club::v1::WhisperLevel whisper_level() const;
+  inline void set_whisper_level(::bgs::protocol::club::v1::WhisperLevel value);
+
+  // optional string note = 6;
+  inline bool has_note() const;
+  inline void clear_note();
+  static const int kNoteFieldNumber = 6;
+  inline const ::std::string& note() const;
+  inline void set_note(const ::std::string& value);
+  inline void set_note(const char* value);
+  inline void set_note(const char* value, size_t size);
+  inline ::std::string* mutable_note();
+  inline ::std::string* release_note();
+  inline void set_allocated_note(::std::string* note);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberStateAssignment)
+ private:
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+  inline void set_has_presence_level();
+  inline void clear_has_presence_level();
+  inline void set_has_moderator_mute();
+  inline void clear_has_moderator_mute();
+  inline void set_has_whisper_level();
+  inline void clear_has_whisper_level();
+  inline void set_has_note();
+  inline void clear_has_note();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  int presence_level_;
+  bool moderator_mute_;
+  ::std::string* note_;
+  int whisper_level_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmember_2eproto();
+  friend void protobuf_AssignDesc_club_5fmember_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmember_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberStateAssignment* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// MemberId
+
+// optional .bgs.protocol.account.v1.AccountId account_id = 1;
+inline bool MemberId::has_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberId::set_has_account_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberId::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberId::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& MemberId::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberId.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* MemberId::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberId.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* MemberId::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::account::v1::AccountId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void MemberId::set_allocated_account_id(::bgs::protocol::account::v1::AccountId* account_id) {
+  delete account_id_;
+  account_id_ = account_id;
+  if (account_id) {
+    set_has_account_id();
+  } else {
+    clear_has_account_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberId.account_id)
+}
+
+// optional uint64 unique_id = 2;
+inline bool MemberId::has_unique_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberId::set_has_unique_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberId::clear_has_unique_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberId::clear_unique_id() {
+  unique_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_unique_id();
+}
+inline ::google::protobuf::uint64 MemberId::unique_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberId.unique_id)
+  return unique_id_;
+}
+inline void MemberId::set_unique_id(::google::protobuf::uint64 value) {
+  set_has_unique_id();
+  unique_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberId.unique_id)
+}
+
+// -------------------------------------------------------------------
+
+// Member
+
+// optional .bgs.protocol.club.v1.MemberId id = 1;
+inline bool Member::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Member::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Member::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Member::clear_id() {
+  if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& Member::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.id)
+  return id_ != NULL ? *id_ : *default_instance_->id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* Member::mutable_id() {
+  set_has_id();
+  if (id_ == NULL) id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Member.id)
+  return id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* Member::release_id() {
+  clear_has_id();
+  ::bgs::protocol::club::v1::MemberId* temp = id_;
+  id_ = NULL;
+  return temp;
+}
+inline void Member::set_allocated_id(::bgs::protocol::club::v1::MemberId* id) {
+  delete id_;
+  id_ = id;
+  if (id) {
+    set_has_id();
+  } else {
+    clear_has_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Member.id)
+}
+
+// optional string battle_tag = 2;
+inline bool Member::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Member::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Member::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Member::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& Member::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.battle_tag)
+  return *battle_tag_;
+}
+inline void Member::set_battle_tag(const ::std::string& value) {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Member.battle_tag)
+}
+inline void Member::set_battle_tag(const char* value) {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.Member.battle_tag)
+}
+inline void Member::set_battle_tag(const char* value, size_t size) {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.Member.battle_tag)
+}
+inline ::std::string* Member::mutable_battle_tag() {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Member.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* Member::release_battle_tag() {
+  clear_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = battle_tag_;
+    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Member::set_allocated_battle_tag(::std::string* battle_tag) {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (battle_tag) {
+    set_has_battle_tag();
+    battle_tag_ = battle_tag;
+  } else {
+    clear_has_battle_tag();
+    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Member.battle_tag)
+}
+
+// repeated uint32 role = 3 [packed = true];
+inline int Member::role_size() const {
+  return role_.size();
+}
+inline void Member::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 Member::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.role)
+  return role_.Get(index);
+}
+inline void Member::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Member.role)
+}
+inline void Member::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.Member.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+Member::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.Member.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+Member::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.Member.role)
+  return &role_;
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 4;
+inline int Member::attribute_size() const {
+  return attribute_.size();
+}
+inline void Member::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& Member::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* Member::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Member.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* Member::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.Member.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+Member::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.Member.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+Member::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.Member.attribute)
+  return &attribute_;
+}
+
+// optional uint64 join_time = 5;
+inline bool Member::has_join_time() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Member::set_has_join_time() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Member::clear_has_join_time() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Member::clear_join_time() {
+  join_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_join_time();
+}
+inline ::google::protobuf::uint64 Member::join_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.join_time)
+  return join_time_;
+}
+inline void Member::set_join_time(::google::protobuf::uint64 value) {
+  set_has_join_time();
+  join_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Member.join_time)
+}
+
+// optional .bgs.protocol.club.v1.PresenceLevel presence_level = 6;
+inline bool Member::has_presence_level() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Member::set_has_presence_level() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Member::clear_has_presence_level() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Member::clear_presence_level() {
+  presence_level_ = 0;
+  clear_has_presence_level();
+}
+inline ::bgs::protocol::club::v1::PresenceLevel Member::presence_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.presence_level)
+  return static_cast< ::bgs::protocol::club::v1::PresenceLevel >(presence_level_);
+}
+inline void Member::set_presence_level(::bgs::protocol::club::v1::PresenceLevel value) {
+  assert(::bgs::protocol::club::v1::PresenceLevel_IsValid(value));
+  set_has_presence_level();
+  presence_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Member.presence_level)
+}
+
+// optional bool moderator_mute = 7;
+inline bool Member::has_moderator_mute() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void Member::set_has_moderator_mute() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void Member::clear_has_moderator_mute() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void Member::clear_moderator_mute() {
+  moderator_mute_ = false;
+  clear_has_moderator_mute();
+}
+inline bool Member::moderator_mute() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.moderator_mute)
+  return moderator_mute_;
+}
+inline void Member::set_moderator_mute(bool value) {
+  set_has_moderator_mute();
+  moderator_mute_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Member.moderator_mute)
+}
+
+// optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 8;
+inline bool Member::has_whisper_level() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void Member::set_has_whisper_level() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void Member::clear_has_whisper_level() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void Member::clear_whisper_level() {
+  whisper_level_ = 0;
+  clear_has_whisper_level();
+}
+inline ::bgs::protocol::club::v1::WhisperLevel Member::whisper_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.whisper_level)
+  return static_cast< ::bgs::protocol::club::v1::WhisperLevel >(whisper_level_);
+}
+inline void Member::set_whisper_level(::bgs::protocol::club::v1::WhisperLevel value) {
+  assert(::bgs::protocol::club::v1::WhisperLevel_IsValid(value));
+  set_has_whisper_level();
+  whisper_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Member.whisper_level)
+}
+
+// optional string note = 9;
+inline bool Member::has_note() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void Member::set_has_note() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void Member::clear_has_note() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void Member::clear_note() {
+  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_->clear();
+  }
+  clear_has_note();
+}
+inline const ::std::string& Member::note() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.note)
+  return *note_;
+}
+inline void Member::set_note(const ::std::string& value) {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  note_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Member.note)
+}
+inline void Member::set_note(const char* value) {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  note_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.Member.note)
+}
+inline void Member::set_note(const char* value, size_t size) {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  note_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.Member.note)
+}
+inline ::std::string* Member::mutable_note() {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Member.note)
+  return note_;
+}
+inline ::std::string* Member::release_note() {
+  clear_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = note_;
+    note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Member::set_allocated_note(::std::string* note) {
+  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete note_;
+  }
+  if (note) {
+    set_has_note();
+    note_ = note;
+  } else {
+    clear_has_note();
+    note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Member.note)
+}
+
+// optional bool active = 50;
+inline bool Member::has_active() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void Member::set_has_active() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void Member::clear_has_active() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void Member::clear_active() {
+  active_ = false;
+  clear_has_active();
+}
+inline bool Member::active() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.active)
+  return active_;
+}
+inline void Member::set_active(bool value) {
+  set_has_active();
+  active_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Member.active)
+}
+
+// optional .bgs.protocol.club.v1.MemberVoiceState voice = 51;
+inline bool Member::has_voice() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void Member::set_has_voice() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void Member::clear_has_voice() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void Member::clear_voice() {
+  if (voice_ != NULL) voice_->::bgs::protocol::club::v1::MemberVoiceState::Clear();
+  clear_has_voice();
+}
+inline const ::bgs::protocol::club::v1::MemberVoiceState& Member::voice() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Member.voice)
+  return voice_ != NULL ? *voice_ : *default_instance_->voice_;
+}
+inline ::bgs::protocol::club::v1::MemberVoiceState* Member::mutable_voice() {
+  set_has_voice();
+  if (voice_ == NULL) voice_ = new ::bgs::protocol::club::v1::MemberVoiceState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Member.voice)
+  return voice_;
+}
+inline ::bgs::protocol::club::v1::MemberVoiceState* Member::release_voice() {
+  clear_has_voice();
+  ::bgs::protocol::club::v1::MemberVoiceState* temp = voice_;
+  voice_ = NULL;
+  return temp;
+}
+inline void Member::set_allocated_voice(::bgs::protocol::club::v1::MemberVoiceState* voice) {
+  delete voice_;
+  voice_ = voice;
+  if (voice) {
+    set_has_voice();
+  } else {
+    clear_has_voice();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Member.voice)
+}
+
+// -------------------------------------------------------------------
+
+// MemberResult
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 1;
+inline bool MemberResult::has_member_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberResult::set_has_member_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberResult::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberResult::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberResult::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberResult.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberResult::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberResult.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberResult::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void MemberResult::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberResult.member_id)
+}
+
+// optional uint32 status = 2;
+inline bool MemberResult::has_status() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberResult::set_has_status() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberResult::clear_has_status() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberResult::clear_status() {
+  status_ = 0u;
+  clear_has_status();
+}
+inline ::google::protobuf::uint32 MemberResult::status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberResult.status)
+  return status_;
+}
+inline void MemberResult::set_status(::google::protobuf::uint32 value) {
+  set_has_status();
+  status_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberResult.status)
+}
+
+// -------------------------------------------------------------------
+
+// RemoveMemberOptions
+
+// optional .bgs.protocol.club.v1.MemberId id = 1;
+inline bool RemoveMemberOptions::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RemoveMemberOptions::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RemoveMemberOptions::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RemoveMemberOptions::clear_id() {
+  if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& RemoveMemberOptions::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RemoveMemberOptions.id)
+  return id_ != NULL ? *id_ : *default_instance_->id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RemoveMemberOptions::mutable_id() {
+  set_has_id();
+  if (id_ == NULL) id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.RemoveMemberOptions.id)
+  return id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RemoveMemberOptions::release_id() {
+  clear_has_id();
+  ::bgs::protocol::club::v1::MemberId* temp = id_;
+  id_ = NULL;
+  return temp;
+}
+inline void RemoveMemberOptions::set_allocated_id(::bgs::protocol::club::v1::MemberId* id) {
+  delete id_;
+  id_ = id;
+  if (id) {
+    set_has_id();
+  } else {
+    clear_has_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.RemoveMemberOptions.id)
+}
+
+// optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+inline bool RemoveMemberOptions::has_reason() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RemoveMemberOptions::set_has_reason() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RemoveMemberOptions::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RemoveMemberOptions::clear_reason() {
+  reason_ = 0;
+  clear_has_reason();
+}
+inline ::bgs::protocol::club::v1::ClubRemovedReason RemoveMemberOptions::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RemoveMemberOptions.reason)
+  return static_cast< ::bgs::protocol::club::v1::ClubRemovedReason >(reason_);
+}
+inline void RemoveMemberOptions::set_reason(::bgs::protocol::club::v1::ClubRemovedReason value) {
+  assert(::bgs::protocol::club::v1::ClubRemovedReason_IsValid(value));
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.RemoveMemberOptions.reason)
+}
+
+// -------------------------------------------------------------------
+
+// MemberRemovedAssignment
+
+// optional .bgs.protocol.club.v1.MemberId id = 1;
+inline bool MemberRemovedAssignment::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberRemovedAssignment::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberRemovedAssignment::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberRemovedAssignment::clear_id() {
+  if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberRemovedAssignment::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRemovedAssignment.id)
+  return id_ != NULL ? *id_ : *default_instance_->id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRemovedAssignment::mutable_id() {
+  set_has_id();
+  if (id_ == NULL) id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberRemovedAssignment.id)
+  return id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRemovedAssignment::release_id() {
+  clear_has_id();
+  ::bgs::protocol::club::v1::MemberId* temp = id_;
+  id_ = NULL;
+  return temp;
+}
+inline void MemberRemovedAssignment::set_allocated_id(::bgs::protocol::club::v1::MemberId* id) {
+  delete id_;
+  id_ = id;
+  if (id) {
+    set_has_id();
+  } else {
+    clear_has_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberRemovedAssignment.id)
+}
+
+// optional .bgs.protocol.club.v1.ClubRemovedReason reason = 2;
+inline bool MemberRemovedAssignment::has_reason() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberRemovedAssignment::set_has_reason() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberRemovedAssignment::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberRemovedAssignment::clear_reason() {
+  reason_ = 0;
+  clear_has_reason();
+}
+inline ::bgs::protocol::club::v1::ClubRemovedReason MemberRemovedAssignment::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRemovedAssignment.reason)
+  return static_cast< ::bgs::protocol::club::v1::ClubRemovedReason >(reason_);
+}
+inline void MemberRemovedAssignment::set_reason(::bgs::protocol::club::v1::ClubRemovedReason value) {
+  assert(::bgs::protocol::club::v1::ClubRemovedReason_IsValid(value));
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberRemovedAssignment.reason)
+}
+
+// -------------------------------------------------------------------
+
+// MemberVoiceOptions
+
+// optional uint64 stream_id = 1;
+inline bool MemberVoiceOptions::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberVoiceOptions::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberVoiceOptions::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberVoiceOptions::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 MemberVoiceOptions::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberVoiceOptions.stream_id)
+  return stream_id_;
+}
+inline void MemberVoiceOptions::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberVoiceOptions.stream_id)
+}
+
+// optional bool joined = 2;
+inline bool MemberVoiceOptions::has_joined() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberVoiceOptions::set_has_joined() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberVoiceOptions::clear_has_joined() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberVoiceOptions::clear_joined() {
+  joined_ = false;
+  clear_has_joined();
+}
+inline bool MemberVoiceOptions::joined() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberVoiceOptions.joined)
+  return joined_;
+}
+inline void MemberVoiceOptions::set_joined(bool value) {
+  set_has_joined();
+  joined_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberVoiceOptions.joined)
+}
+
+// optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 3;
+inline bool MemberVoiceOptions::has_microphone() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberVoiceOptions::set_has_microphone() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberVoiceOptions::clear_has_microphone() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberVoiceOptions::clear_microphone() {
+  microphone_ = 0;
+  clear_has_microphone();
+}
+inline ::bgs::protocol::club::v1::VoiceMicrophoneState MemberVoiceOptions::microphone() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberVoiceOptions.microphone)
+  return static_cast< ::bgs::protocol::club::v1::VoiceMicrophoneState >(microphone_);
+}
+inline void MemberVoiceOptions::set_microphone(::bgs::protocol::club::v1::VoiceMicrophoneState value) {
+  assert(::bgs::protocol::club::v1::VoiceMicrophoneState_IsValid(value));
+  set_has_microphone();
+  microphone_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberVoiceOptions.microphone)
+}
+
+// optional bool active = 4;
+inline bool MemberVoiceOptions::has_active() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void MemberVoiceOptions::set_has_active() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void MemberVoiceOptions::clear_has_active() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void MemberVoiceOptions::clear_active() {
+  active_ = false;
+  clear_has_active();
+}
+inline bool MemberVoiceOptions::active() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberVoiceOptions.active)
+  return active_;
+}
+inline void MemberVoiceOptions::set_active(bool value) {
+  set_has_active();
+  active_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberVoiceOptions.active)
+}
+
+// -------------------------------------------------------------------
+
+// MemberVoiceState
+
+// optional string id = 1;
+inline bool MemberVoiceState::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberVoiceState::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberVoiceState::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberVoiceState::clear_id() {
+  if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_->clear();
+  }
+  clear_has_id();
+}
+inline const ::std::string& MemberVoiceState::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberVoiceState.id)
+  return *id_;
+}
+inline void MemberVoiceState::set_id(const ::std::string& value) {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberVoiceState.id)
+}
+inline void MemberVoiceState::set_id(const char* value) {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.MemberVoiceState.id)
+}
+inline void MemberVoiceState::set_id(const char* value, size_t size) {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.MemberVoiceState.id)
+}
+inline ::std::string* MemberVoiceState::mutable_id() {
+  set_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberVoiceState.id)
+  return id_;
+}
+inline ::std::string* MemberVoiceState::release_id() {
+  clear_has_id();
+  if (id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = id_;
+    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void MemberVoiceState::set_allocated_id(::std::string* id) {
+  if (id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete id_;
+  }
+  if (id) {
+    set_has_id();
+    id_ = id;
+  } else {
+    clear_has_id();
+    id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberVoiceState.id)
+}
+
+// optional uint64 stream_id = 2;
+inline bool MemberVoiceState::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberVoiceState::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberVoiceState::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberVoiceState::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 MemberVoiceState::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberVoiceState.stream_id)
+  return stream_id_;
+}
+inline void MemberVoiceState::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberVoiceState.stream_id)
+}
+
+// optional bool joined = 3;
+inline bool MemberVoiceState::has_joined() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberVoiceState::set_has_joined() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberVoiceState::clear_has_joined() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberVoiceState::clear_joined() {
+  joined_ = false;
+  clear_has_joined();
+}
+inline bool MemberVoiceState::joined() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberVoiceState.joined)
+  return joined_;
+}
+inline void MemberVoiceState::set_joined(bool value) {
+  set_has_joined();
+  joined_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberVoiceState.joined)
+}
+
+// optional .bgs.protocol.club.v1.VoiceMicrophoneState microphone = 4;
+inline bool MemberVoiceState::has_microphone() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void MemberVoiceState::set_has_microphone() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void MemberVoiceState::clear_has_microphone() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void MemberVoiceState::clear_microphone() {
+  microphone_ = 0;
+  clear_has_microphone();
+}
+inline ::bgs::protocol::club::v1::VoiceMicrophoneState MemberVoiceState::microphone() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberVoiceState.microphone)
+  return static_cast< ::bgs::protocol::club::v1::VoiceMicrophoneState >(microphone_);
+}
+inline void MemberVoiceState::set_microphone(::bgs::protocol::club::v1::VoiceMicrophoneState value) {
+  assert(::bgs::protocol::club::v1::VoiceMicrophoneState_IsValid(value));
+  set_has_microphone();
+  microphone_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberVoiceState.microphone)
+}
+
+// optional bool active = 5;
+inline bool MemberVoiceState::has_active() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void MemberVoiceState::set_has_active() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void MemberVoiceState::clear_has_active() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void MemberVoiceState::clear_active() {
+  active_ = false;
+  clear_has_active();
+}
+inline bool MemberVoiceState::active() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberVoiceState.active)
+  return active_;
+}
+inline void MemberVoiceState::set_active(bool value) {
+  set_has_active();
+  active_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberVoiceState.active)
+}
+
+// -------------------------------------------------------------------
+
+// CreateMemberOptions
+
+// optional .bgs.protocol.club.v1.MemberId id = 1;
+inline bool CreateMemberOptions::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateMemberOptions::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateMemberOptions::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateMemberOptions::clear_id() {
+  if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& CreateMemberOptions::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateMemberOptions.id)
+  return id_ != NULL ? *id_ : *default_instance_->id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateMemberOptions::mutable_id() {
+  set_has_id();
+  if (id_ == NULL) id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateMemberOptions.id)
+  return id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateMemberOptions::release_id() {
+  clear_has_id();
+  ::bgs::protocol::club::v1::MemberId* temp = id_;
+  id_ = NULL;
+  return temp;
+}
+inline void CreateMemberOptions::set_allocated_id(::bgs::protocol::club::v1::MemberId* id) {
+  delete id_;
+  id_ = id;
+  if (id) {
+    set_has_id();
+  } else {
+    clear_has_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateMemberOptions.id)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 2;
+inline int CreateMemberOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void CreateMemberOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& CreateMemberOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateMemberOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* CreateMemberOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateMemberOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* CreateMemberOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.CreateMemberOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+CreateMemberOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.CreateMemberOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+CreateMemberOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.CreateMemberOptions.attribute)
+  return &attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// MemberDescription
+
+// optional .bgs.protocol.club.v1.MemberId id = 1;
+inline bool MemberDescription::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberDescription::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberDescription::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberDescription::clear_id() {
+  if (id_ != NULL) id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberDescription::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberDescription.id)
+  return id_ != NULL ? *id_ : *default_instance_->id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberDescription::mutable_id() {
+  set_has_id();
+  if (id_ == NULL) id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberDescription.id)
+  return id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberDescription::release_id() {
+  clear_has_id();
+  ::bgs::protocol::club::v1::MemberId* temp = id_;
+  id_ = NULL;
+  return temp;
+}
+inline void MemberDescription::set_allocated_id(::bgs::protocol::club::v1::MemberId* id) {
+  delete id_;
+  id_ = id;
+  if (id) {
+    set_has_id();
+  } else {
+    clear_has_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberDescription.id)
+}
+
+// optional string battle_tag = 2;
+inline bool MemberDescription::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberDescription::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberDescription::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberDescription::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& MemberDescription::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberDescription.battle_tag)
+  return *battle_tag_;
+}
+inline void MemberDescription::set_battle_tag(const ::std::string& value) {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberDescription.battle_tag)
+}
+inline void MemberDescription::set_battle_tag(const char* value) {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.MemberDescription.battle_tag)
+}
+inline void MemberDescription::set_battle_tag(const char* value, size_t size) {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.MemberDescription.battle_tag)
+}
+inline ::std::string* MemberDescription::mutable_battle_tag() {
+  set_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberDescription.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* MemberDescription::release_battle_tag() {
+  clear_has_battle_tag();
+  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = battle_tag_;
+    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void MemberDescription::set_allocated_battle_tag(::std::string* battle_tag) {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (battle_tag) {
+    set_has_battle_tag();
+    battle_tag_ = battle_tag;
+  } else {
+    clear_has_battle_tag();
+    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberDescription.battle_tag)
+}
+
+// -------------------------------------------------------------------
+
+// RoleAssignment
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 1;
+inline bool RoleAssignment::has_member_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RoleAssignment::set_has_member_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RoleAssignment::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RoleAssignment::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& RoleAssignment::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RoleAssignment.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RoleAssignment::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.RoleAssignment.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RoleAssignment::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void RoleAssignment::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.RoleAssignment.member_id)
+}
+
+// repeated uint32 role = 2 [packed = true];
+inline int RoleAssignment::role_size() const {
+  return role_.size();
+}
+inline void RoleAssignment::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 RoleAssignment::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RoleAssignment.role)
+  return role_.Get(index);
+}
+inline void RoleAssignment::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.RoleAssignment.role)
+}
+inline void RoleAssignment::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.RoleAssignment.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+RoleAssignment::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.RoleAssignment.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+RoleAssignment::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.RoleAssignment.role)
+  return &role_;
+}
+
+// -------------------------------------------------------------------
+
+// MemberAttributeAssignment
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 1;
+inline bool MemberAttributeAssignment::has_member_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberAttributeAssignment::set_has_member_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberAttributeAssignment::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberAttributeAssignment::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberAttributeAssignment::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberAttributeAssignment.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberAttributeAssignment::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberAttributeAssignment.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberAttributeAssignment::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void MemberAttributeAssignment::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberAttributeAssignment.member_id)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 2;
+inline int MemberAttributeAssignment::attribute_size() const {
+  return attribute_.size();
+}
+inline void MemberAttributeAssignment::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& MemberAttributeAssignment::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberAttributeAssignment.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* MemberAttributeAssignment::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberAttributeAssignment.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* MemberAttributeAssignment::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.MemberAttributeAssignment.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+MemberAttributeAssignment::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.MemberAttributeAssignment.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+MemberAttributeAssignment::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.MemberAttributeAssignment.attribute)
+  return &attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// SubscriberStateOptions
+
+// optional .bgs.protocol.club.v1.MemberVoiceOptions voice = 1;
+inline bool SubscriberStateOptions::has_voice() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscriberStateOptions::set_has_voice() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscriberStateOptions::clear_has_voice() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscriberStateOptions::clear_voice() {
+  if (voice_ != NULL) voice_->::bgs::protocol::club::v1::MemberVoiceOptions::Clear();
+  clear_has_voice();
+}
+inline const ::bgs::protocol::club::v1::MemberVoiceOptions& SubscriberStateOptions::voice() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscriberStateOptions.voice)
+  return voice_ != NULL ? *voice_ : *default_instance_->voice_;
+}
+inline ::bgs::protocol::club::v1::MemberVoiceOptions* SubscriberStateOptions::mutable_voice() {
+  set_has_voice();
+  if (voice_ == NULL) voice_ = new ::bgs::protocol::club::v1::MemberVoiceOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscriberStateOptions.voice)
+  return voice_;
+}
+inline ::bgs::protocol::club::v1::MemberVoiceOptions* SubscriberStateOptions::release_voice() {
+  clear_has_voice();
+  ::bgs::protocol::club::v1::MemberVoiceOptions* temp = voice_;
+  voice_ = NULL;
+  return temp;
+}
+inline void SubscriberStateOptions::set_allocated_voice(::bgs::protocol::club::v1::MemberVoiceOptions* voice) {
+  delete voice_;
+  voice_ = voice;
+  if (voice) {
+    set_has_voice();
+  } else {
+    clear_has_voice();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscriberStateOptions.voice)
+}
+
+// -------------------------------------------------------------------
+
+// SubscriberStateAssignment
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 1;
+inline bool SubscriberStateAssignment::has_member_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscriberStateAssignment::set_has_member_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscriberStateAssignment::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscriberStateAssignment::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SubscriberStateAssignment::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscriberStateAssignment.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscriberStateAssignment::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscriberStateAssignment.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscriberStateAssignment::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void SubscriberStateAssignment::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscriberStateAssignment.member_id)
+}
+
+// optional bool active = 2;
+inline bool SubscriberStateAssignment::has_active() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscriberStateAssignment::set_has_active() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscriberStateAssignment::clear_has_active() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscriberStateAssignment::clear_active() {
+  active_ = false;
+  clear_has_active();
+}
+inline bool SubscriberStateAssignment::active() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscriberStateAssignment.active)
+  return active_;
+}
+inline void SubscriberStateAssignment::set_active(bool value) {
+  set_has_active();
+  active_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SubscriberStateAssignment.active)
+}
+
+// optional .bgs.protocol.club.v1.MemberVoiceState voice = 3;
+inline bool SubscriberStateAssignment::has_voice() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SubscriberStateAssignment::set_has_voice() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SubscriberStateAssignment::clear_has_voice() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SubscriberStateAssignment::clear_voice() {
+  if (voice_ != NULL) voice_->::bgs::protocol::club::v1::MemberVoiceState::Clear();
+  clear_has_voice();
+}
+inline const ::bgs::protocol::club::v1::MemberVoiceState& SubscriberStateAssignment::voice() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscriberStateAssignment.voice)
+  return voice_ != NULL ? *voice_ : *default_instance_->voice_;
+}
+inline ::bgs::protocol::club::v1::MemberVoiceState* SubscriberStateAssignment::mutable_voice() {
+  set_has_voice();
+  if (voice_ == NULL) voice_ = new ::bgs::protocol::club::v1::MemberVoiceState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscriberStateAssignment.voice)
+  return voice_;
+}
+inline ::bgs::protocol::club::v1::MemberVoiceState* SubscriberStateAssignment::release_voice() {
+  clear_has_voice();
+  ::bgs::protocol::club::v1::MemberVoiceState* temp = voice_;
+  voice_ = NULL;
+  return temp;
+}
+inline void SubscriberStateAssignment::set_allocated_voice(::bgs::protocol::club::v1::MemberVoiceState* voice) {
+  delete voice_;
+  voice_ = voice;
+  if (voice) {
+    set_has_voice();
+  } else {
+    clear_has_voice();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscriberStateAssignment.voice)
+}
+
+// -------------------------------------------------------------------
+
+// MemberStateOptions
+
+// repeated .bgs.protocol.v2.Attribute attribute = 1;
+inline int MemberStateOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void MemberStateOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& MemberStateOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* MemberStateOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberStateOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* MemberStateOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.MemberStateOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+MemberStateOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.MemberStateOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+MemberStateOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.MemberStateOptions.attribute)
+  return &attribute_;
+}
+
+// optional .bgs.protocol.club.v1.PresenceLevel presence_level = 2;
+inline bool MemberStateOptions::has_presence_level() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberStateOptions::set_has_presence_level() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberStateOptions::clear_has_presence_level() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberStateOptions::clear_presence_level() {
+  presence_level_ = 0;
+  clear_has_presence_level();
+}
+inline ::bgs::protocol::club::v1::PresenceLevel MemberStateOptions::presence_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateOptions.presence_level)
+  return static_cast< ::bgs::protocol::club::v1::PresenceLevel >(presence_level_);
+}
+inline void MemberStateOptions::set_presence_level(::bgs::protocol::club::v1::PresenceLevel value) {
+  assert(::bgs::protocol::club::v1::PresenceLevel_IsValid(value));
+  set_has_presence_level();
+  presence_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberStateOptions.presence_level)
+}
+
+// optional bool moderator_mute = 3;
+inline bool MemberStateOptions::has_moderator_mute() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberStateOptions::set_has_moderator_mute() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberStateOptions::clear_has_moderator_mute() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberStateOptions::clear_moderator_mute() {
+  moderator_mute_ = false;
+  clear_has_moderator_mute();
+}
+inline bool MemberStateOptions::moderator_mute() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateOptions.moderator_mute)
+  return moderator_mute_;
+}
+inline void MemberStateOptions::set_moderator_mute(bool value) {
+  set_has_moderator_mute();
+  moderator_mute_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberStateOptions.moderator_mute)
+}
+
+// optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 4;
+inline bool MemberStateOptions::has_whisper_level() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void MemberStateOptions::set_has_whisper_level() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void MemberStateOptions::clear_has_whisper_level() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void MemberStateOptions::clear_whisper_level() {
+  whisper_level_ = 0;
+  clear_has_whisper_level();
+}
+inline ::bgs::protocol::club::v1::WhisperLevel MemberStateOptions::whisper_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateOptions.whisper_level)
+  return static_cast< ::bgs::protocol::club::v1::WhisperLevel >(whisper_level_);
+}
+inline void MemberStateOptions::set_whisper_level(::bgs::protocol::club::v1::WhisperLevel value) {
+  assert(::bgs::protocol::club::v1::WhisperLevel_IsValid(value));
+  set_has_whisper_level();
+  whisper_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberStateOptions.whisper_level)
+}
+
+// optional string note = 5;
+inline bool MemberStateOptions::has_note() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void MemberStateOptions::set_has_note() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void MemberStateOptions::clear_has_note() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void MemberStateOptions::clear_note() {
+  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_->clear();
+  }
+  clear_has_note();
+}
+inline const ::std::string& MemberStateOptions::note() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateOptions.note)
+  return *note_;
+}
+inline void MemberStateOptions::set_note(const ::std::string& value) {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  note_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberStateOptions.note)
+}
+inline void MemberStateOptions::set_note(const char* value) {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  note_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.MemberStateOptions.note)
+}
+inline void MemberStateOptions::set_note(const char* value, size_t size) {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  note_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.MemberStateOptions.note)
+}
+inline ::std::string* MemberStateOptions::mutable_note() {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberStateOptions.note)
+  return note_;
+}
+inline ::std::string* MemberStateOptions::release_note() {
+  clear_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = note_;
+    note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void MemberStateOptions::set_allocated_note(::std::string* note) {
+  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete note_;
+  }
+  if (note) {
+    set_has_note();
+    note_ = note;
+  } else {
+    clear_has_note();
+    note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberStateOptions.note)
+}
+
+// -------------------------------------------------------------------
+
+// MemberStateAssignment
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 1;
+inline bool MemberStateAssignment::has_member_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberStateAssignment::set_has_member_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberStateAssignment::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberStateAssignment::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberStateAssignment::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateAssignment.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberStateAssignment::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberStateAssignment.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberStateAssignment::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void MemberStateAssignment::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberStateAssignment.member_id)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 2;
+inline int MemberStateAssignment::attribute_size() const {
+  return attribute_.size();
+}
+inline void MemberStateAssignment::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& MemberStateAssignment::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateAssignment.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* MemberStateAssignment::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberStateAssignment.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* MemberStateAssignment::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.MemberStateAssignment.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+MemberStateAssignment::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.MemberStateAssignment.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+MemberStateAssignment::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.MemberStateAssignment.attribute)
+  return &attribute_;
+}
+
+// optional .bgs.protocol.club.v1.PresenceLevel presence_level = 3;
+inline bool MemberStateAssignment::has_presence_level() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberStateAssignment::set_has_presence_level() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberStateAssignment::clear_has_presence_level() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberStateAssignment::clear_presence_level() {
+  presence_level_ = 0;
+  clear_has_presence_level();
+}
+inline ::bgs::protocol::club::v1::PresenceLevel MemberStateAssignment::presence_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateAssignment.presence_level)
+  return static_cast< ::bgs::protocol::club::v1::PresenceLevel >(presence_level_);
+}
+inline void MemberStateAssignment::set_presence_level(::bgs::protocol::club::v1::PresenceLevel value) {
+  assert(::bgs::protocol::club::v1::PresenceLevel_IsValid(value));
+  set_has_presence_level();
+  presence_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberStateAssignment.presence_level)
+}
+
+// optional bool moderator_mute = 4;
+inline bool MemberStateAssignment::has_moderator_mute() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void MemberStateAssignment::set_has_moderator_mute() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void MemberStateAssignment::clear_has_moderator_mute() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void MemberStateAssignment::clear_moderator_mute() {
+  moderator_mute_ = false;
+  clear_has_moderator_mute();
+}
+inline bool MemberStateAssignment::moderator_mute() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateAssignment.moderator_mute)
+  return moderator_mute_;
+}
+inline void MemberStateAssignment::set_moderator_mute(bool value) {
+  set_has_moderator_mute();
+  moderator_mute_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberStateAssignment.moderator_mute)
+}
+
+// optional .bgs.protocol.club.v1.WhisperLevel whisper_level = 5;
+inline bool MemberStateAssignment::has_whisper_level() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void MemberStateAssignment::set_has_whisper_level() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void MemberStateAssignment::clear_has_whisper_level() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void MemberStateAssignment::clear_whisper_level() {
+  whisper_level_ = 0;
+  clear_has_whisper_level();
+}
+inline ::bgs::protocol::club::v1::WhisperLevel MemberStateAssignment::whisper_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateAssignment.whisper_level)
+  return static_cast< ::bgs::protocol::club::v1::WhisperLevel >(whisper_level_);
+}
+inline void MemberStateAssignment::set_whisper_level(::bgs::protocol::club::v1::WhisperLevel value) {
+  assert(::bgs::protocol::club::v1::WhisperLevel_IsValid(value));
+  set_has_whisper_level();
+  whisper_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberStateAssignment.whisper_level)
+}
+
+// optional string note = 6;
+inline bool MemberStateAssignment::has_note() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void MemberStateAssignment::set_has_note() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void MemberStateAssignment::clear_has_note() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void MemberStateAssignment::clear_note() {
+  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_->clear();
+  }
+  clear_has_note();
+}
+inline const ::std::string& MemberStateAssignment::note() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateAssignment.note)
+  return *note_;
+}
+inline void MemberStateAssignment::set_note(const ::std::string& value) {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  note_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberStateAssignment.note)
+}
+inline void MemberStateAssignment::set_note(const char* value) {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  note_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.MemberStateAssignment.note)
+}
+inline void MemberStateAssignment::set_note(const char* value, size_t size) {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  note_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.MemberStateAssignment.note)
+}
+inline ::std::string* MemberStateAssignment::mutable_note() {
+  set_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    note_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberStateAssignment.note)
+  return note_;
+}
+inline ::std::string* MemberStateAssignment::release_note() {
+  clear_has_note();
+  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = note_;
+    note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void MemberStateAssignment::set_allocated_note(::std::string* note) {
+  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete note_;
+  }
+  if (note) {
+    set_has_note();
+    note_ = note;
+  } else {
+    clear_has_note();
+    note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberStateAssignment.note)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5fmember_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_membership_listener.pb.cc b/src/server/proto/Client/club_membership_listener.pb.cc
new file mode 100644
index 00000000000..cc0462aa3e9
--- /dev/null
+++ b/src/server/proto/Client/club_membership_listener.pb.cc
@@ -0,0 +1,3344 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_membership_listener.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_membership_listener.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "Errors.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+namespace membership {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ClubAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubRemovedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ReceivedInvitationAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ReceivedInvitationAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ReceivedInvitationRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ReceivedInvitationRemovedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SharedSettingsChangedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SharedSettingsChangedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamMentionAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamMentionAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamMentionRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamMentionRemovedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamMentionAdvanceViewTimeNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamMentionAdvanceViewTimeNotification_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ClubMembershipListener_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto() {
+  protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_membership_listener.proto");
+  GOOGLE_CHECK(file != NULL);
+  ClubAddedNotification_descriptor_ = file->message_type(0);
+  static const int ClubAddedNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubAddedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubAddedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubAddedNotification, membership_),
+  };
+  ClubAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubAddedNotification_descriptor_,
+      ClubAddedNotification::default_instance_,
+      ClubAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubAddedNotification));
+  ClubRemovedNotification_descriptor_ = file->message_type(1);
+  static const int ClubRemovedNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRemovedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRemovedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRemovedNotification, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRemovedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRemovedNotification, reason_),
+  };
+  ClubRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubRemovedNotification_descriptor_,
+      ClubRemovedNotification::default_instance_,
+      ClubRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubRemovedNotification));
+  ReceivedInvitationAddedNotification_descriptor_ = file->message_type(2);
+  static const int ReceivedInvitationAddedNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationAddedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationAddedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationAddedNotification, invitation_),
+  };
+  ReceivedInvitationAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ReceivedInvitationAddedNotification_descriptor_,
+      ReceivedInvitationAddedNotification::default_instance_,
+      ReceivedInvitationAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ReceivedInvitationAddedNotification));
+  ReceivedInvitationRemovedNotification_descriptor_ = file->message_type(3);
+  static const int ReceivedInvitationRemovedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationRemovedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationRemovedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationRemovedNotification, invitation_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationRemovedNotification, reason_),
+  };
+  ReceivedInvitationRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ReceivedInvitationRemovedNotification_descriptor_,
+      ReceivedInvitationRemovedNotification::default_instance_,
+      ReceivedInvitationRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitationRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ReceivedInvitationRemovedNotification));
+  SharedSettingsChangedNotification_descriptor_ = file->message_type(4);
+  static const int SharedSettingsChangedNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SharedSettingsChangedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SharedSettingsChangedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SharedSettingsChangedNotification, assignment_),
+  };
+  SharedSettingsChangedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SharedSettingsChangedNotification_descriptor_,
+      SharedSettingsChangedNotification::default_instance_,
+      SharedSettingsChangedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SharedSettingsChangedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SharedSettingsChangedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SharedSettingsChangedNotification));
+  StreamMentionAddedNotification_descriptor_ = file->message_type(5);
+  static const int StreamMentionAddedNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAddedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAddedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAddedNotification, mention_),
+  };
+  StreamMentionAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamMentionAddedNotification_descriptor_,
+      StreamMentionAddedNotification::default_instance_,
+      StreamMentionAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamMentionAddedNotification));
+  StreamMentionRemovedNotification_descriptor_ = file->message_type(6);
+  static const int StreamMentionRemovedNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionRemovedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionRemovedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionRemovedNotification, mention_id_),
+  };
+  StreamMentionRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamMentionRemovedNotification_descriptor_,
+      StreamMentionRemovedNotification::default_instance_,
+      StreamMentionRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamMentionRemovedNotification));
+  StreamMentionAdvanceViewTimeNotification_descriptor_ = file->message_type(7);
+  static const int StreamMentionAdvanceViewTimeNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAdvanceViewTimeNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAdvanceViewTimeNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAdvanceViewTimeNotification, view_time_),
+  };
+  StreamMentionAdvanceViewTimeNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamMentionAdvanceViewTimeNotification_descriptor_,
+      StreamMentionAdvanceViewTimeNotification::default_instance_,
+      StreamMentionAdvanceViewTimeNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAdvanceViewTimeNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionAdvanceViewTimeNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamMentionAdvanceViewTimeNotification));
+  ClubMembershipListener_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5fmembership_5flistener_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubAddedNotification_descriptor_, &ClubAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubRemovedNotification_descriptor_, &ClubRemovedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ReceivedInvitationAddedNotification_descriptor_, &ReceivedInvitationAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ReceivedInvitationRemovedNotification_descriptor_, &ReceivedInvitationRemovedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SharedSettingsChangedNotification_descriptor_, &SharedSettingsChangedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamMentionAddedNotification_descriptor_, &StreamMentionAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamMentionRemovedNotification_descriptor_, &StreamMentionRemovedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamMentionAdvanceViewTimeNotification_descriptor_, &StreamMentionAdvanceViewTimeNotification::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto() {
+  delete ClubAddedNotification::default_instance_;
+  delete ClubAddedNotification_reflection_;
+  delete ClubRemovedNotification::default_instance_;
+  delete ClubRemovedNotification_reflection_;
+  delete ReceivedInvitationAddedNotification::default_instance_;
+  delete ReceivedInvitationAddedNotification_reflection_;
+  delete ReceivedInvitationRemovedNotification::default_instance_;
+  delete ReceivedInvitationRemovedNotification_reflection_;
+  delete SharedSettingsChangedNotification::default_instance_;
+  delete SharedSettingsChangedNotification_reflection_;
+  delete StreamMentionAddedNotification::default_instance_;
+  delete StreamMentionAddedNotification_reflection_;
+  delete StreamMentionRemovedNotification::default_instance_;
+  delete StreamMentionRemovedNotification_reflection_;
+  delete StreamMentionAdvanceViewTimeNotification::default_instance_;
+  delete StreamMentionAdvanceViewTimeNotification_reflection_;
+}
+
+void protobuf_AddDesc_club_5fmembership_5flistener_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\036club_membership_listener.proto\022\037bgs.pr"
+    "otocol.club.v1.membership\032\020club_types.pr"
+    "oto\"\311\001\n\025ClubAddedNotification\0220\n\010agent_i"
+    "d\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId\022"
+    "9\n\rsubscriber_id\030\002 \001(\0132\".bgs.protocol.ac"
+    "count.v1.AccountId\022C\n\nmembership\030\003 \001(\0132/"
+    ".bgs.protocol.club.v1.ClubMembershipDesc"
+    "ription\"\203\002\n\027ClubRemovedNotification\0220\n\010a"
+    "gent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Mem"
+    "berId\0229\n\rsubscriber_id\030\002 \001(\0132\".bgs.proto"
+    "col.account.v1.AccountId\0221\n\tmember_id\030\003 "
+    "\001(\0132\036.bgs.protocol.club.v1.MemberId\022\017\n\007c"
+    "lub_id\030\004 \001(\004\0227\n\006reason\030\005 \001(\0162\'.bgs.proto"
+    "col.club.v1.ClubRemovedReason\"\314\001\n#Receiv"
+    "edInvitationAddedNotification\0220\n\010agent_i"
+    "d\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId\022"
+    "9\n\rsubscriber_id\030\002 \001(\0132\".bgs.protocol.ac"
+    "count.v1.AccountId\0228\n\ninvitation\030\003 \001(\0132$"
+    ".bgs.protocol.club.v1.ClubInvitation\"\342\001\n"
+    "%ReceivedInvitationRemovedNotification\0220"
+    "\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1."
+    "MemberId\0229\n\rsubscriber_id\030\002 \001(\0132\".bgs.pr"
+    "otocol.account.v1.AccountId\022\025\n\rinvitatio"
+    "n_id\030\003 \001(\006\0225\n\006reason\030\004 \001(\0162%.bgs.protoco"
+    "l.InvitationRemovedReason\"\334\001\n!SharedSett"
+    "ingsChangedNotification\0224\n\010agent_id\030\001 \001("
+    "\0132\".bgs.protocol.account.v1.AccountId\0229\n"
+    "\rsubscriber_id\030\002 \001(\0132\".bgs.protocol.acco"
+    "unt.v1.AccountId\022F\n\nassignment\030\004 \001(\01322.b"
+    "gs.protocol.club.v1.ClubSharedSettingsAs"
+    "signment\"\303\001\n\036StreamMentionAddedNotificat"
+    "ion\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.clu"
+    "b.v1.MemberId\0229\n\rsubscriber_id\030\002 \001(\0132\".b"
+    "gs.protocol.account.v1.AccountId\0224\n\007ment"
+    "ion\030\003 \001(\0132#.bgs.protocol.club.v1.StreamM"
+    "ention\"\303\001\n StreamMentionRemovedNotificat"
+    "ion\0224\n\010agent_id\030\001 \001(\0132\".bgs.protocol.acc"
+    "ount.v1.AccountId\0229\n\rsubscriber_id\030\002 \001(\013"
+    "2\".bgs.protocol.account.v1.AccountId\022.\n\n"
+    "mention_id\030\003 \001(\0132\032.bgs.protocol.TimeSeri"
+    "esId\"\256\001\n(StreamMentionAdvanceViewTimeNot"
+    "ification\0224\n\010agent_id\030\001 \001(\0132\".bgs.protoc"
+    "ol.account.v1.AccountId\0229\n\rsubscriber_id"
+    "\030\002 \001(\0132\".bgs.protocol.account.v1.Account"
+    "Id\022\021\n\tview_time\030\003 \001(\0042\316\010\n\026ClubMembership"
+    "Listener\022h\n\013OnClubAdded\0226.bgs.protocol.c"
+    "lub.v1.membership.ClubAddedNotification\032"
+    "\031.bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010\001\022l\n\rOn"
+    "ClubRemoved\0228.bgs.protocol.club.v1.membe"
+    "rship.ClubRemovedNotification\032\031.bgs.prot"
+    "ocol.NO_RESPONSE\"\006\202\371+\002\010\002\022\204\001\n\031OnReceivedI"
+    "nvitationAdded\022D.bgs.protocol.club.v1.me"
+    "mbership.ReceivedInvitationAddedNotifica"
+    "tion\032\031.bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010\003\022"
+    "\210\001\n\033OnReceivedInvitationRemoved\022F.bgs.pr"
+    "otocol.club.v1.membership.ReceivedInvita"
+    "tionRemovedNotification\032\031.bgs.protocol.N"
+    "O_RESPONSE\"\006\202\371+\002\010\004\022\200\001\n\027OnSharedSettingsC"
+    "hanged\022B.bgs.protocol.club.v1.membership"
+    ".SharedSettingsChangedNotification\032\031.bgs"
+    ".protocol.NO_RESPONSE\"\006\202\371+\002\010\005\022z\n\024OnStrea"
+    "mMentionAdded\022\?.bgs.protocol.club.v1.mem"
+    "bership.StreamMentionAddedNotification\032\031"
+    ".bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010\006\022~\n\026OnS"
+    "treamMentionRemoved\022A.bgs.protocol.club."
+    "v1.membership.StreamMentionRemovedNotifi"
+    "cation\032\031.bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010"
+    "\007\022\216\001\n\036OnStreamMentionAdvanceViewTime\022I.b"
+    "gs.protocol.club.v1.membership.StreamMen"
+    "tionAdvanceViewTimeNotification\032\031.bgs.pr"
+    "otocol.NO_RESPONSE\"\006\202\371+\002\010\010\032:\202\371+.\n,bnet.p"
+    "rotocol.club.v1.ClubMembershipListener\212\371"
+    "+\004\010\001\030\001B\005H\001\200\001\000", 2893);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_membership_listener.proto", &protobuf_RegisterTypes);
+  ClubAddedNotification::default_instance_ = new ClubAddedNotification();
+  ClubRemovedNotification::default_instance_ = new ClubRemovedNotification();
+  ReceivedInvitationAddedNotification::default_instance_ = new ReceivedInvitationAddedNotification();
+  ReceivedInvitationRemovedNotification::default_instance_ = new ReceivedInvitationRemovedNotification();
+  SharedSettingsChangedNotification::default_instance_ = new SharedSettingsChangedNotification();
+  StreamMentionAddedNotification::default_instance_ = new StreamMentionAddedNotification();
+  StreamMentionRemovedNotification::default_instance_ = new StreamMentionRemovedNotification();
+  StreamMentionAdvanceViewTimeNotification::default_instance_ = new StreamMentionAdvanceViewTimeNotification();
+  ClubAddedNotification::default_instance_->InitAsDefaultInstance();
+  ClubRemovedNotification::default_instance_->InitAsDefaultInstance();
+  ReceivedInvitationAddedNotification::default_instance_->InitAsDefaultInstance();
+  ReceivedInvitationRemovedNotification::default_instance_->InitAsDefaultInstance();
+  SharedSettingsChangedNotification::default_instance_->InitAsDefaultInstance();
+  StreamMentionAddedNotification::default_instance_->InitAsDefaultInstance();
+  StreamMentionRemovedNotification::default_instance_->InitAsDefaultInstance();
+  StreamMentionAdvanceViewTimeNotification::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5fmembership_5flistener_2eproto {
+  StaticDescriptorInitializer_club_5fmembership_5flistener_2eproto() {
+    protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  }
+} static_descriptor_initializer_club_5fmembership_5flistener_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubAddedNotification::kAgentIdFieldNumber;
+const int ClubAddedNotification::kSubscriberIdFieldNumber;
+const int ClubAddedNotification::kMembershipFieldNumber;
+#endif  // !_MSC_VER
+
+ClubAddedNotification::ClubAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.ClubAddedNotification)
+}
+
+void ClubAddedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  membership_ = const_cast< ::bgs::protocol::club::v1::ClubMembershipDescription*>(&::bgs::protocol::club::v1::ClubMembershipDescription::default_instance());
+}
+
+ClubAddedNotification::ClubAddedNotification(const ClubAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.ClubAddedNotification)
+}
+
+void ClubAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  membership_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubAddedNotification::~ClubAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.ClubAddedNotification)
+  SharedDtor();
+}
+
+void ClubAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete membership_;
+  }
+}
+
+void ClubAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubAddedNotification_descriptor_;
+}
+
+const ClubAddedNotification& ClubAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  return *default_instance_;
+}
+
+ClubAddedNotification* ClubAddedNotification::default_instance_ = NULL;
+
+ClubAddedNotification* ClubAddedNotification::New() const {
+  return new ClubAddedNotification;
+}
+
+void ClubAddedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_membership()) {
+      if (membership_ != NULL) membership_->::bgs::protocol::club::v1::ClubMembershipDescription::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.ClubAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_membership;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubMembershipDescription membership = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_membership:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_membership()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.ClubAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.ClubAddedNotification)
+  return false;
+#undef DO_
+}
+
+void ClubAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.ClubAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubMembershipDescription membership = 3;
+  if (has_membership()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->membership(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.ClubAddedNotification)
+}
+
+::google::protobuf::uint8* ClubAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.ClubAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubMembershipDescription membership = 3;
+  if (has_membership()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->membership(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.ClubAddedNotification)
+  return target;
+}
+
+int ClubAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubMembershipDescription membership = 3;
+    if (has_membership()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->membership());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubAddedNotification::MergeFrom(const ClubAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_membership()) {
+      mutable_membership()->::bgs::protocol::club::v1::ClubMembershipDescription::MergeFrom(from.membership());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubAddedNotification::CopyFrom(const ClubAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubAddedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (has_membership()) {
+    if (!this->membership().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubAddedNotification::Swap(ClubAddedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(membership_, other->membership_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubAddedNotification_descriptor_;
+  metadata.reflection = ClubAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubRemovedNotification::kAgentIdFieldNumber;
+const int ClubRemovedNotification::kSubscriberIdFieldNumber;
+const int ClubRemovedNotification::kMemberIdFieldNumber;
+const int ClubRemovedNotification::kClubIdFieldNumber;
+const int ClubRemovedNotification::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+ClubRemovedNotification::ClubRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+}
+
+void ClubRemovedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+ClubRemovedNotification::ClubRemovedNotification(const ClubRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+}
+
+void ClubRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  member_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  reason_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubRemovedNotification::~ClubRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+  SharedDtor();
+}
+
+void ClubRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete member_id_;
+  }
+}
+
+void ClubRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubRemovedNotification_descriptor_;
+}
+
+const ClubRemovedNotification& ClubRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  return *default_instance_;
+}
+
+ClubRemovedNotification* ClubRemovedNotification::default_instance_ = NULL;
+
+ClubRemovedNotification* ClubRemovedNotification::New() const {
+  return new ClubRemovedNotification;
+}
+
+void ClubRemovedNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClubRemovedNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(club_id_, reason_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_member_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_reason;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_reason:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::ClubRemovedReason_IsValid(value)) {
+            set_reason(static_cast< ::bgs::protocol::club::v1::ClubRemovedReason >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(5, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void ClubRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->member_id(), output);
+  }
+
+  // optional uint64 club_id = 4;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 5;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+}
+
+::google::protobuf::uint8* ClubRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->member_id(), target);
+  }
+
+  // optional uint64 club_id = 4;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 5;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      5, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+  return target;
+}
+
+int ClubRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+    // optional uint64 club_id = 4;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 5;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->reason());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubRemovedNotification::MergeFrom(const ClubRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubRemovedNotification::CopyFrom(const ClubRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubRemovedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubRemovedNotification::Swap(ClubRemovedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(member_id_, other->member_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubRemovedNotification_descriptor_;
+  metadata.reflection = ClubRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ReceivedInvitationAddedNotification::kAgentIdFieldNumber;
+const int ReceivedInvitationAddedNotification::kSubscriberIdFieldNumber;
+const int ReceivedInvitationAddedNotification::kInvitationFieldNumber;
+#endif  // !_MSC_VER
+
+ReceivedInvitationAddedNotification::ReceivedInvitationAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+}
+
+void ReceivedInvitationAddedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  invitation_ = const_cast< ::bgs::protocol::club::v1::ClubInvitation*>(&::bgs::protocol::club::v1::ClubInvitation::default_instance());
+}
+
+ReceivedInvitationAddedNotification::ReceivedInvitationAddedNotification(const ReceivedInvitationAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+}
+
+void ReceivedInvitationAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  invitation_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ReceivedInvitationAddedNotification::~ReceivedInvitationAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+  SharedDtor();
+}
+
+void ReceivedInvitationAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete invitation_;
+  }
+}
+
+void ReceivedInvitationAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ReceivedInvitationAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ReceivedInvitationAddedNotification_descriptor_;
+}
+
+const ReceivedInvitationAddedNotification& ReceivedInvitationAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  return *default_instance_;
+}
+
+ReceivedInvitationAddedNotification* ReceivedInvitationAddedNotification::default_instance_ = NULL;
+
+ReceivedInvitationAddedNotification* ReceivedInvitationAddedNotification::New() const {
+  return new ReceivedInvitationAddedNotification;
+}
+
+void ReceivedInvitationAddedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_invitation()) {
+      if (invitation_ != NULL) invitation_->::bgs::protocol::club::v1::ClubInvitation::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ReceivedInvitationAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_invitation;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubInvitation invitation = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_invitation:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_invitation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+  return false;
+#undef DO_
+}
+
+void ReceivedInvitationAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubInvitation invitation = 3;
+  if (has_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->invitation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+}
+
+::google::protobuf::uint8* ReceivedInvitationAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubInvitation invitation = 3;
+  if (has_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->invitation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+  return target;
+}
+
+int ReceivedInvitationAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubInvitation invitation = 3;
+    if (has_invitation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->invitation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ReceivedInvitationAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ReceivedInvitationAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ReceivedInvitationAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ReceivedInvitationAddedNotification::MergeFrom(const ReceivedInvitationAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_invitation()) {
+      mutable_invitation()->::bgs::protocol::club::v1::ClubInvitation::MergeFrom(from.invitation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ReceivedInvitationAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ReceivedInvitationAddedNotification::CopyFrom(const ReceivedInvitationAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReceivedInvitationAddedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (has_invitation()) {
+    if (!this->invitation().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ReceivedInvitationAddedNotification::Swap(ReceivedInvitationAddedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(invitation_, other->invitation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ReceivedInvitationAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ReceivedInvitationAddedNotification_descriptor_;
+  metadata.reflection = ReceivedInvitationAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ReceivedInvitationRemovedNotification::kAgentIdFieldNumber;
+const int ReceivedInvitationRemovedNotification::kSubscriberIdFieldNumber;
+const int ReceivedInvitationRemovedNotification::kInvitationIdFieldNumber;
+const int ReceivedInvitationRemovedNotification::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+ReceivedInvitationRemovedNotification::ReceivedInvitationRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+}
+
+void ReceivedInvitationRemovedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+ReceivedInvitationRemovedNotification::ReceivedInvitationRemovedNotification(const ReceivedInvitationRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+}
+
+void ReceivedInvitationRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  reason_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ReceivedInvitationRemovedNotification::~ReceivedInvitationRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+  SharedDtor();
+}
+
+void ReceivedInvitationRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void ReceivedInvitationRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ReceivedInvitationRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ReceivedInvitationRemovedNotification_descriptor_;
+}
+
+const ReceivedInvitationRemovedNotification& ReceivedInvitationRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  return *default_instance_;
+}
+
+ReceivedInvitationRemovedNotification* ReceivedInvitationRemovedNotification::default_instance_ = NULL;
+
+ReceivedInvitationRemovedNotification* ReceivedInvitationRemovedNotification::New() const {
+  return new ReceivedInvitationRemovedNotification;
+}
+
+void ReceivedInvitationRemovedNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ReceivedInvitationRemovedNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(invitation_id_, reason_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ReceivedInvitationRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_invitation_id;
+        break;
+      }
+
+      // optional fixed64 invitation_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_reason;
+        break;
+      }
+
+      // optional .bgs.protocol.InvitationRemovedReason reason = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_reason:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::InvitationRemovedReason_IsValid(value)) {
+            set_reason(static_cast< ::bgs::protocol::InvitationRemovedReason >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(4, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void ReceivedInvitationRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
+  }
+
+  // optional .bgs.protocol.InvitationRemovedReason reason = 4;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+}
+
+::google::protobuf::uint8* ReceivedInvitationRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
+  }
+
+  // optional .bgs.protocol.InvitationRemovedReason reason = 4;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      4, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+  return target;
+}
+
+int ReceivedInvitationRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional fixed64 invitation_id = 3;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+    // optional .bgs.protocol.InvitationRemovedReason reason = 4;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->reason());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ReceivedInvitationRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ReceivedInvitationRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ReceivedInvitationRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ReceivedInvitationRemovedNotification::MergeFrom(const ReceivedInvitationRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ReceivedInvitationRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ReceivedInvitationRemovedNotification::CopyFrom(const ReceivedInvitationRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReceivedInvitationRemovedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ReceivedInvitationRemovedNotification::Swap(ReceivedInvitationRemovedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ReceivedInvitationRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ReceivedInvitationRemovedNotification_descriptor_;
+  metadata.reflection = ReceivedInvitationRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SharedSettingsChangedNotification::kAgentIdFieldNumber;
+const int SharedSettingsChangedNotification::kSubscriberIdFieldNumber;
+const int SharedSettingsChangedNotification::kAssignmentFieldNumber;
+#endif  // !_MSC_VER
+
+SharedSettingsChangedNotification::SharedSettingsChangedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+}
+
+void SharedSettingsChangedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  assignment_ = const_cast< ::bgs::protocol::club::v1::ClubSharedSettingsAssignment*>(&::bgs::protocol::club::v1::ClubSharedSettingsAssignment::default_instance());
+}
+
+SharedSettingsChangedNotification::SharedSettingsChangedNotification(const SharedSettingsChangedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+}
+
+void SharedSettingsChangedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  assignment_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SharedSettingsChangedNotification::~SharedSettingsChangedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+  SharedDtor();
+}
+
+void SharedSettingsChangedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete assignment_;
+  }
+}
+
+void SharedSettingsChangedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SharedSettingsChangedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SharedSettingsChangedNotification_descriptor_;
+}
+
+const SharedSettingsChangedNotification& SharedSettingsChangedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  return *default_instance_;
+}
+
+SharedSettingsChangedNotification* SharedSettingsChangedNotification::default_instance_ = NULL;
+
+SharedSettingsChangedNotification* SharedSettingsChangedNotification::New() const {
+  return new SharedSettingsChangedNotification;
+}
+
+void SharedSettingsChangedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_assignment()) {
+      if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::ClubSharedSettingsAssignment::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SharedSettingsChangedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_assignment;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSharedSettingsAssignment assignment = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_assignment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_assignment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+  return false;
+#undef DO_
+}
+
+void SharedSettingsChangedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSharedSettingsAssignment assignment = 4;
+  if (has_assignment()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->assignment(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+}
+
+::google::protobuf::uint8* SharedSettingsChangedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSharedSettingsAssignment assignment = 4;
+  if (has_assignment()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->assignment(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+  return target;
+}
+
+int SharedSettingsChangedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSharedSettingsAssignment assignment = 4;
+    if (has_assignment()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->assignment());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SharedSettingsChangedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SharedSettingsChangedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SharedSettingsChangedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SharedSettingsChangedNotification::MergeFrom(const SharedSettingsChangedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_assignment()) {
+      mutable_assignment()->::bgs::protocol::club::v1::ClubSharedSettingsAssignment::MergeFrom(from.assignment());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SharedSettingsChangedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SharedSettingsChangedNotification::CopyFrom(const SharedSettingsChangedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SharedSettingsChangedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SharedSettingsChangedNotification::Swap(SharedSettingsChangedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(assignment_, other->assignment_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SharedSettingsChangedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SharedSettingsChangedNotification_descriptor_;
+  metadata.reflection = SharedSettingsChangedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamMentionAddedNotification::kAgentIdFieldNumber;
+const int StreamMentionAddedNotification::kSubscriberIdFieldNumber;
+const int StreamMentionAddedNotification::kMentionFieldNumber;
+#endif  // !_MSC_VER
+
+StreamMentionAddedNotification::StreamMentionAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+}
+
+void StreamMentionAddedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  mention_ = const_cast< ::bgs::protocol::club::v1::StreamMention*>(&::bgs::protocol::club::v1::StreamMention::default_instance());
+}
+
+StreamMentionAddedNotification::StreamMentionAddedNotification(const StreamMentionAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+}
+
+void StreamMentionAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  mention_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamMentionAddedNotification::~StreamMentionAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+  SharedDtor();
+}
+
+void StreamMentionAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete mention_;
+  }
+}
+
+void StreamMentionAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamMentionAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamMentionAddedNotification_descriptor_;
+}
+
+const StreamMentionAddedNotification& StreamMentionAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  return *default_instance_;
+}
+
+StreamMentionAddedNotification* StreamMentionAddedNotification::default_instance_ = NULL;
+
+StreamMentionAddedNotification* StreamMentionAddedNotification::New() const {
+  return new StreamMentionAddedNotification;
+}
+
+void StreamMentionAddedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_mention()) {
+      if (mention_ != NULL) mention_->::bgs::protocol::club::v1::StreamMention::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamMentionAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_mention;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamMention mention = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_mention:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_mention()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+  return false;
+#undef DO_
+}
+
+void StreamMentionAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamMention mention = 3;
+  if (has_mention()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->mention(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+}
+
+::google::protobuf::uint8* StreamMentionAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamMention mention = 3;
+  if (has_mention()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->mention(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+  return target;
+}
+
+int StreamMentionAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamMention mention = 3;
+    if (has_mention()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->mention());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamMentionAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamMentionAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamMentionAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamMentionAddedNotification::MergeFrom(const StreamMentionAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_mention()) {
+      mutable_mention()->::bgs::protocol::club::v1::StreamMention::MergeFrom(from.mention());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamMentionAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamMentionAddedNotification::CopyFrom(const StreamMentionAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamMentionAddedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (has_mention()) {
+    if (!this->mention().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamMentionAddedNotification::Swap(StreamMentionAddedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(mention_, other->mention_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamMentionAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamMentionAddedNotification_descriptor_;
+  metadata.reflection = StreamMentionAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamMentionRemovedNotification::kAgentIdFieldNumber;
+const int StreamMentionRemovedNotification::kSubscriberIdFieldNumber;
+const int StreamMentionRemovedNotification::kMentionIdFieldNumber;
+#endif  // !_MSC_VER
+
+StreamMentionRemovedNotification::StreamMentionRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+}
+
+void StreamMentionRemovedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  mention_id_ = const_cast< ::bgs::protocol::TimeSeriesId*>(&::bgs::protocol::TimeSeriesId::default_instance());
+}
+
+StreamMentionRemovedNotification::StreamMentionRemovedNotification(const StreamMentionRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+}
+
+void StreamMentionRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  mention_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamMentionRemovedNotification::~StreamMentionRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+  SharedDtor();
+}
+
+void StreamMentionRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete mention_id_;
+  }
+}
+
+void StreamMentionRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamMentionRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamMentionRemovedNotification_descriptor_;
+}
+
+const StreamMentionRemovedNotification& StreamMentionRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  return *default_instance_;
+}
+
+StreamMentionRemovedNotification* StreamMentionRemovedNotification::default_instance_ = NULL;
+
+StreamMentionRemovedNotification* StreamMentionRemovedNotification::New() const {
+  return new StreamMentionRemovedNotification;
+}
+
+void StreamMentionRemovedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_mention_id()) {
+      if (mention_id_ != NULL) mention_id_->::bgs::protocol::TimeSeriesId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamMentionRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_mention_id;
+        break;
+      }
+
+      // optional .bgs.protocol.TimeSeriesId mention_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_mention_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_mention_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void StreamMentionRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional .bgs.protocol.TimeSeriesId mention_id = 3;
+  if (has_mention_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->mention_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+}
+
+::google::protobuf::uint8* StreamMentionRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional .bgs.protocol.TimeSeriesId mention_id = 3;
+  if (has_mention_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->mention_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+  return target;
+}
+
+int StreamMentionRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional .bgs.protocol.TimeSeriesId mention_id = 3;
+    if (has_mention_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->mention_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamMentionRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamMentionRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamMentionRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamMentionRemovedNotification::MergeFrom(const StreamMentionRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_mention_id()) {
+      mutable_mention_id()->::bgs::protocol::TimeSeriesId::MergeFrom(from.mention_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamMentionRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamMentionRemovedNotification::CopyFrom(const StreamMentionRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamMentionRemovedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamMentionRemovedNotification::Swap(StreamMentionRemovedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(mention_id_, other->mention_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamMentionRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamMentionRemovedNotification_descriptor_;
+  metadata.reflection = StreamMentionRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamMentionAdvanceViewTimeNotification::kAgentIdFieldNumber;
+const int StreamMentionAdvanceViewTimeNotification::kSubscriberIdFieldNumber;
+const int StreamMentionAdvanceViewTimeNotification::kViewTimeFieldNumber;
+#endif  // !_MSC_VER
+
+StreamMentionAdvanceViewTimeNotification::StreamMentionAdvanceViewTimeNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+}
+
+void StreamMentionAdvanceViewTimeNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+StreamMentionAdvanceViewTimeNotification::StreamMentionAdvanceViewTimeNotification(const StreamMentionAdvanceViewTimeNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+}
+
+void StreamMentionAdvanceViewTimeNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  view_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamMentionAdvanceViewTimeNotification::~StreamMentionAdvanceViewTimeNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+  SharedDtor();
+}
+
+void StreamMentionAdvanceViewTimeNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void StreamMentionAdvanceViewTimeNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamMentionAdvanceViewTimeNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamMentionAdvanceViewTimeNotification_descriptor_;
+}
+
+const StreamMentionAdvanceViewTimeNotification& StreamMentionAdvanceViewTimeNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  return *default_instance_;
+}
+
+StreamMentionAdvanceViewTimeNotification* StreamMentionAdvanceViewTimeNotification::default_instance_ = NULL;
+
+StreamMentionAdvanceViewTimeNotification* StreamMentionAdvanceViewTimeNotification::New() const {
+  return new StreamMentionAdvanceViewTimeNotification;
+}
+
+void StreamMentionAdvanceViewTimeNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    view_time_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamMentionAdvanceViewTimeNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_view_time;
+        break;
+      }
+
+      // optional uint64 view_time = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_view_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &view_time_)));
+          set_has_view_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+  return false;
+#undef DO_
+}
+
+void StreamMentionAdvanceViewTimeNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 view_time = 3;
+  if (has_view_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->view_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+}
+
+::google::protobuf::uint8* StreamMentionAdvanceViewTimeNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 view_time = 3;
+  if (has_view_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->view_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+  return target;
+}
+
+int StreamMentionAdvanceViewTimeNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 view_time = 3;
+    if (has_view_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->view_time());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamMentionAdvanceViewTimeNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamMentionAdvanceViewTimeNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamMentionAdvanceViewTimeNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamMentionAdvanceViewTimeNotification::MergeFrom(const StreamMentionAdvanceViewTimeNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_view_time()) {
+      set_view_time(from.view_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamMentionAdvanceViewTimeNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamMentionAdvanceViewTimeNotification::CopyFrom(const StreamMentionAdvanceViewTimeNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamMentionAdvanceViewTimeNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamMentionAdvanceViewTimeNotification::Swap(StreamMentionAdvanceViewTimeNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(view_time_, other->view_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamMentionAdvanceViewTimeNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamMentionAdvanceViewTimeNotification_descriptor_;
+  metadata.reflection = StreamMentionAdvanceViewTimeNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+ClubMembershipListener::ClubMembershipListener(bool use_original_hash) : service_hash_(use_original_hash ? OriginalHash::value : NameHash::value) {
+}
+
+ClubMembershipListener::~ClubMembershipListener() {
+}
+
+google::protobuf::ServiceDescriptor const* ClubMembershipListener::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubMembershipListener_descriptor_;
+}
+
+void ClubMembershipListener::OnClubAdded(::bgs::protocol::club::v1::membership::ClubAddedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipListener.OnClubAdded(bgs.protocol.club.v1.membership.ClubAddedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request);
+}
+
+void ClubMembershipListener::OnClubRemoved(::bgs::protocol::club::v1::membership::ClubRemovedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipListener.OnClubRemoved(bgs.protocol.club.v1.membership.ClubRemovedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request);
+}
+
+void ClubMembershipListener::OnReceivedInvitationAdded(::bgs::protocol::club::v1::membership::ReceivedInvitationAddedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipListener.OnReceivedInvitationAdded(bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request);
+}
+
+void ClubMembershipListener::OnReceivedInvitationRemoved(::bgs::protocol::club::v1::membership::ReceivedInvitationRemovedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipListener.OnReceivedInvitationRemoved(bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request);
+}
+
+void ClubMembershipListener::OnSharedSettingsChanged(::bgs::protocol::club::v1::membership::SharedSettingsChangedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipListener.OnSharedSettingsChanged(bgs.protocol.club.v1.membership.SharedSettingsChangedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 5, request);
+}
+
+void ClubMembershipListener::OnStreamMentionAdded(::bgs::protocol::club::v1::membership::StreamMentionAddedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipListener.OnStreamMentionAdded(bgs.protocol.club.v1.membership.StreamMentionAddedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 6, request);
+}
+
+void ClubMembershipListener::OnStreamMentionRemoved(::bgs::protocol::club::v1::membership::StreamMentionRemovedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipListener.OnStreamMentionRemoved(bgs.protocol.club.v1.membership.StreamMentionRemovedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 7, request);
+}
+
+void ClubMembershipListener::OnStreamMentionAdvanceViewTime(::bgs::protocol::club::v1::membership::StreamMentionAdvanceViewTimeNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipListener.OnStreamMentionAdvanceViewTime(bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 8, request);
+}
+
+void ClubMembershipListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::club::v1::membership::ClubAddedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipListener.OnClubAdded server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnClubAdded(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipListener.OnClubAdded(bgs.protocol.club.v1.membership.ClubAddedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::club::v1::membership::ClubRemovedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipListener.OnClubRemoved server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnClubRemoved(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipListener.OnClubRemoved(bgs.protocol.club.v1.membership.ClubRemovedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::club::v1::membership::ReceivedInvitationAddedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipListener.OnReceivedInvitationAdded server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnReceivedInvitationAdded(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipListener.OnReceivedInvitationAdded(bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::club::v1::membership::ReceivedInvitationRemovedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipListener.OnReceivedInvitationRemoved server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnReceivedInvitationRemoved(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipListener.OnReceivedInvitationRemoved(bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::club::v1::membership::SharedSettingsChangedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipListener.OnSharedSettingsChanged server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnSharedSettingsChanged(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipListener.OnSharedSettingsChanged(bgs.protocol.club.v1.membership.SharedSettingsChangedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 5, token, status);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::club::v1::membership::StreamMentionAddedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipListener.OnStreamMentionAdded server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnStreamMentionAdded(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipListener.OnStreamMentionAdded(bgs.protocol.club.v1.membership.StreamMentionAddedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 6, token, status);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::club::v1::membership::StreamMentionRemovedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipListener.OnStreamMentionRemoved server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnStreamMentionRemoved(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipListener.OnStreamMentionRemoved(bgs.protocol.club.v1.membership.StreamMentionRemovedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 7, token, status);
+      break;
+    }
+    case 8: {
+      ::bgs::protocol::club::v1::membership::StreamMentionAdvanceViewTimeNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipListener.OnStreamMentionAdvanceViewTime server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnStreamMentionAdvanceViewTime(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipListener.OnStreamMentionAdvanceViewTime(bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 8, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ClubMembershipListener::HandleOnClubAdded(::bgs::protocol::club::v1::membership::ClubAddedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipListener.OnClubAdded({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipListener::HandleOnClubRemoved(::bgs::protocol::club::v1::membership::ClubRemovedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipListener.OnClubRemoved({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipListener::HandleOnReceivedInvitationAdded(::bgs::protocol::club::v1::membership::ReceivedInvitationAddedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipListener.OnReceivedInvitationAdded({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipListener::HandleOnReceivedInvitationRemoved(::bgs::protocol::club::v1::membership::ReceivedInvitationRemovedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipListener.OnReceivedInvitationRemoved({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipListener::HandleOnSharedSettingsChanged(::bgs::protocol::club::v1::membership::SharedSettingsChangedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipListener.OnSharedSettingsChanged({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipListener::HandleOnStreamMentionAdded(::bgs::protocol::club::v1::membership::StreamMentionAddedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipListener.OnStreamMentionAdded({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipListener::HandleOnStreamMentionRemoved(::bgs::protocol::club::v1::membership::StreamMentionRemovedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipListener.OnStreamMentionRemoved({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipListener::HandleOnStreamMentionAdvanceViewTime(::bgs::protocol::club::v1::membership::StreamMentionAdvanceViewTimeNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipListener.OnStreamMentionAdvanceViewTime({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace membership
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_membership_listener.pb.h b/src/server/proto/Client/club_membership_listener.pb.h
new file mode 100644
index 00000000000..65278a54e26
--- /dev/null
+++ b/src/server/proto/Client/club_membership_listener.pb.h
@@ -0,0 +1,2043 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_membership_listener.proto
+
+#ifndef PROTOBUF_club_5fmembership_5flistener_2eproto__INCLUDED
+#define PROTOBUF_club_5fmembership_5flistener_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "club_types.pb.h"
+#include "ServiceBase.h"
+#include "MessageBuffer.h"
+#include <functional>
+#include <type_traits>
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+namespace membership {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto();
+void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto();
+
+class ClubAddedNotification;
+class ClubRemovedNotification;
+class ReceivedInvitationAddedNotification;
+class ReceivedInvitationRemovedNotification;
+class SharedSettingsChangedNotification;
+class StreamMentionAddedNotification;
+class StreamMentionRemovedNotification;
+class StreamMentionAdvanceViewTimeNotification;
+
+// ===================================================================
+
+class TC_PROTO_API ClubAddedNotification : public ::google::protobuf::Message {
+ public:
+  ClubAddedNotification();
+  virtual ~ClubAddedNotification();
+
+  ClubAddedNotification(const ClubAddedNotification& from);
+
+  inline ClubAddedNotification& operator=(const ClubAddedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubAddedNotification& default_instance();
+
+  void Swap(ClubAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubAddedNotification& from);
+  void MergeFrom(const ClubAddedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // optional .bgs.protocol.club.v1.ClubMembershipDescription membership = 3;
+  inline bool has_membership() const;
+  inline void clear_membership();
+  static const int kMembershipFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::ClubMembershipDescription& membership() const;
+  inline ::bgs::protocol::club::v1::ClubMembershipDescription* mutable_membership();
+  inline ::bgs::protocol::club::v1::ClubMembershipDescription* release_membership();
+  inline void set_allocated_membership(::bgs::protocol::club::v1::ClubMembershipDescription* membership);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.ClubAddedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_membership();
+  inline void clear_has_membership();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::bgs::protocol::club::v1::ClubMembershipDescription* membership_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubRemovedNotification : public ::google::protobuf::Message {
+ public:
+  ClubRemovedNotification();
+  virtual ~ClubRemovedNotification();
+
+  ClubRemovedNotification(const ClubRemovedNotification& from);
+
+  inline ClubRemovedNotification& operator=(const ClubRemovedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubRemovedNotification& default_instance();
+
+  void Swap(ClubRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubRemovedNotification& from);
+  void MergeFrom(const ClubRemovedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // optional uint64 club_id = 4;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.ClubRemovedReason reason = 5;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 5;
+  inline ::bgs::protocol::club::v1::ClubRemovedReason reason() const;
+  inline void set_reason(::bgs::protocol::club::v1::ClubRemovedReason value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.ClubRemovedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  ::google::protobuf::uint64 club_id_;
+  int reason_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubRemovedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ReceivedInvitationAddedNotification : public ::google::protobuf::Message {
+ public:
+  ReceivedInvitationAddedNotification();
+  virtual ~ReceivedInvitationAddedNotification();
+
+  ReceivedInvitationAddedNotification(const ReceivedInvitationAddedNotification& from);
+
+  inline ReceivedInvitationAddedNotification& operator=(const ReceivedInvitationAddedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ReceivedInvitationAddedNotification& default_instance();
+
+  void Swap(ReceivedInvitationAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  ReceivedInvitationAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ReceivedInvitationAddedNotification& from);
+  void MergeFrom(const ReceivedInvitationAddedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // optional .bgs.protocol.club.v1.ClubInvitation invitation = 3;
+  inline bool has_invitation() const;
+  inline void clear_invitation();
+  static const int kInvitationFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::ClubInvitation& invitation() const;
+  inline ::bgs::protocol::club::v1::ClubInvitation* mutable_invitation();
+  inline ::bgs::protocol::club::v1::ClubInvitation* release_invitation();
+  inline void set_allocated_invitation(::bgs::protocol::club::v1::ClubInvitation* invitation);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_invitation();
+  inline void clear_has_invitation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::bgs::protocol::club::v1::ClubInvitation* invitation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static ReceivedInvitationAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ReceivedInvitationRemovedNotification : public ::google::protobuf::Message {
+ public:
+  ReceivedInvitationRemovedNotification();
+  virtual ~ReceivedInvitationRemovedNotification();
+
+  ReceivedInvitationRemovedNotification(const ReceivedInvitationRemovedNotification& from);
+
+  inline ReceivedInvitationRemovedNotification& operator=(const ReceivedInvitationRemovedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ReceivedInvitationRemovedNotification& default_instance();
+
+  void Swap(ReceivedInvitationRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  ReceivedInvitationRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ReceivedInvitationRemovedNotification& from);
+  void MergeFrom(const ReceivedInvitationRemovedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // optional fixed64 invitation_id = 3;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.InvitationRemovedReason reason = 4;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 4;
+  inline ::bgs::protocol::InvitationRemovedReason reason() const;
+  inline void set_reason(::bgs::protocol::InvitationRemovedReason value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  int reason_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static ReceivedInvitationRemovedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SharedSettingsChangedNotification : public ::google::protobuf::Message {
+ public:
+  SharedSettingsChangedNotification();
+  virtual ~SharedSettingsChangedNotification();
+
+  SharedSettingsChangedNotification(const SharedSettingsChangedNotification& from);
+
+  inline SharedSettingsChangedNotification& operator=(const SharedSettingsChangedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SharedSettingsChangedNotification& default_instance();
+
+  void Swap(SharedSettingsChangedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SharedSettingsChangedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SharedSettingsChangedNotification& from);
+  void MergeFrom(const SharedSettingsChangedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // optional .bgs.protocol.club.v1.ClubSharedSettingsAssignment assignment = 4;
+  inline bool has_assignment() const;
+  inline void clear_assignment();
+  static const int kAssignmentFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::ClubSharedSettingsAssignment& assignment() const;
+  inline ::bgs::protocol::club::v1::ClubSharedSettingsAssignment* mutable_assignment();
+  inline ::bgs::protocol::club::v1::ClubSharedSettingsAssignment* release_assignment();
+  inline void set_allocated_assignment(::bgs::protocol::club::v1::ClubSharedSettingsAssignment* assignment);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_assignment();
+  inline void clear_has_assignment();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::bgs::protocol::club::v1::ClubSharedSettingsAssignment* assignment_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static SharedSettingsChangedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamMentionAddedNotification : public ::google::protobuf::Message {
+ public:
+  StreamMentionAddedNotification();
+  virtual ~StreamMentionAddedNotification();
+
+  StreamMentionAddedNotification(const StreamMentionAddedNotification& from);
+
+  inline StreamMentionAddedNotification& operator=(const StreamMentionAddedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamMentionAddedNotification& default_instance();
+
+  void Swap(StreamMentionAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamMentionAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamMentionAddedNotification& from);
+  void MergeFrom(const StreamMentionAddedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // optional .bgs.protocol.club.v1.StreamMention mention = 3;
+  inline bool has_mention() const;
+  inline void clear_mention();
+  static const int kMentionFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::StreamMention& mention() const;
+  inline ::bgs::protocol::club::v1::StreamMention* mutable_mention();
+  inline ::bgs::protocol::club::v1::StreamMention* release_mention();
+  inline void set_allocated_mention(::bgs::protocol::club::v1::StreamMention* mention);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.StreamMentionAddedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_mention();
+  inline void clear_has_mention();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::bgs::protocol::club::v1::StreamMention* mention_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamMentionAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamMentionRemovedNotification : public ::google::protobuf::Message {
+ public:
+  StreamMentionRemovedNotification();
+  virtual ~StreamMentionRemovedNotification();
+
+  StreamMentionRemovedNotification(const StreamMentionRemovedNotification& from);
+
+  inline StreamMentionRemovedNotification& operator=(const StreamMentionRemovedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamMentionRemovedNotification& default_instance();
+
+  void Swap(StreamMentionRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamMentionRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamMentionRemovedNotification& from);
+  void MergeFrom(const StreamMentionRemovedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // optional .bgs.protocol.TimeSeriesId mention_id = 3;
+  inline bool has_mention_id() const;
+  inline void clear_mention_id();
+  static const int kMentionIdFieldNumber = 3;
+  inline const ::bgs::protocol::TimeSeriesId& mention_id() const;
+  inline ::bgs::protocol::TimeSeriesId* mutable_mention_id();
+  inline ::bgs::protocol::TimeSeriesId* release_mention_id();
+  inline void set_allocated_mention_id(::bgs::protocol::TimeSeriesId* mention_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_mention_id();
+  inline void clear_has_mention_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::bgs::protocol::TimeSeriesId* mention_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamMentionRemovedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamMentionAdvanceViewTimeNotification : public ::google::protobuf::Message {
+ public:
+  StreamMentionAdvanceViewTimeNotification();
+  virtual ~StreamMentionAdvanceViewTimeNotification();
+
+  StreamMentionAdvanceViewTimeNotification(const StreamMentionAdvanceViewTimeNotification& from);
+
+  inline StreamMentionAdvanceViewTimeNotification& operator=(const StreamMentionAdvanceViewTimeNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamMentionAdvanceViewTimeNotification& default_instance();
+
+  void Swap(StreamMentionAdvanceViewTimeNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamMentionAdvanceViewTimeNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamMentionAdvanceViewTimeNotification& from);
+  void MergeFrom(const StreamMentionAdvanceViewTimeNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // optional uint64 view_time = 3;
+  inline bool has_view_time() const;
+  inline void clear_view_time();
+  static const int kViewTimeFieldNumber = 3;
+  inline ::google::protobuf::uint64 view_time() const;
+  inline void set_view_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_view_time();
+  inline void clear_has_view_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::google::protobuf::uint64 view_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamMentionAdvanceViewTimeNotification* default_instance_;
+};
+// ===================================================================
+
+class TC_PROTO_API ClubMembershipListener : public ServiceBase
+{
+ public:
+
+  explicit ClubMembershipListener(bool use_original_hash);
+  virtual ~ClubMembershipListener();
+
+  typedef std::integral_constant<uint32, 0x2B34597Bu> OriginalHash;
+  typedef std::integral_constant<uint32, 0x615039Eu> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void OnClubAdded(::bgs::protocol::club::v1::membership::ClubAddedNotification const* request);
+  void OnClubRemoved(::bgs::protocol::club::v1::membership::ClubRemovedNotification const* request);
+  void OnReceivedInvitationAdded(::bgs::protocol::club::v1::membership::ReceivedInvitationAddedNotification const* request);
+  void OnReceivedInvitationRemoved(::bgs::protocol::club::v1::membership::ReceivedInvitationRemovedNotification const* request);
+  void OnSharedSettingsChanged(::bgs::protocol::club::v1::membership::SharedSettingsChangedNotification const* request);
+  void OnStreamMentionAdded(::bgs::protocol::club::v1::membership::StreamMentionAddedNotification const* request);
+  void OnStreamMentionRemoved(::bgs::protocol::club::v1::membership::StreamMentionRemovedNotification const* request);
+  void OnStreamMentionAdvanceViewTime(::bgs::protocol::club::v1::membership::StreamMentionAdvanceViewTimeNotification const* request);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleOnClubAdded(::bgs::protocol::club::v1::membership::ClubAddedNotification const* request);
+  virtual uint32 HandleOnClubRemoved(::bgs::protocol::club::v1::membership::ClubRemovedNotification const* request);
+  virtual uint32 HandleOnReceivedInvitationAdded(::bgs::protocol::club::v1::membership::ReceivedInvitationAddedNotification const* request);
+  virtual uint32 HandleOnReceivedInvitationRemoved(::bgs::protocol::club::v1::membership::ReceivedInvitationRemovedNotification const* request);
+  virtual uint32 HandleOnSharedSettingsChanged(::bgs::protocol::club::v1::membership::SharedSettingsChangedNotification const* request);
+  virtual uint32 HandleOnStreamMentionAdded(::bgs::protocol::club::v1::membership::StreamMentionAddedNotification const* request);
+  virtual uint32 HandleOnStreamMentionRemoved(::bgs::protocol::club::v1::membership::StreamMentionRemovedNotification const* request);
+  virtual uint32 HandleOnStreamMentionAdvanceViewTime(::bgs::protocol::club::v1::membership::StreamMentionAdvanceViewTimeNotification const* request);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ClubMembershipListener);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ClubAddedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool ClubAddedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubAddedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubAddedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubAddedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& ClubAddedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ClubAddedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubAddedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ClubAddedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubAddedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void ClubAddedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ClubAddedNotification.agent_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+inline bool ClubAddedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubAddedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubAddedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubAddedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& ClubAddedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ClubAddedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* ClubAddedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ClubAddedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* ClubAddedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void ClubAddedNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ClubAddedNotification.subscriber_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubMembershipDescription membership = 3;
+inline bool ClubAddedNotification::has_membership() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubAddedNotification::set_has_membership() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubAddedNotification::clear_has_membership() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubAddedNotification::clear_membership() {
+  if (membership_ != NULL) membership_->::bgs::protocol::club::v1::ClubMembershipDescription::Clear();
+  clear_has_membership();
+}
+inline const ::bgs::protocol::club::v1::ClubMembershipDescription& ClubAddedNotification::membership() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ClubAddedNotification.membership)
+  return membership_ != NULL ? *membership_ : *default_instance_->membership_;
+}
+inline ::bgs::protocol::club::v1::ClubMembershipDescription* ClubAddedNotification::mutable_membership() {
+  set_has_membership();
+  if (membership_ == NULL) membership_ = new ::bgs::protocol::club::v1::ClubMembershipDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ClubAddedNotification.membership)
+  return membership_;
+}
+inline ::bgs::protocol::club::v1::ClubMembershipDescription* ClubAddedNotification::release_membership() {
+  clear_has_membership();
+  ::bgs::protocol::club::v1::ClubMembershipDescription* temp = membership_;
+  membership_ = NULL;
+  return temp;
+}
+inline void ClubAddedNotification::set_allocated_membership(::bgs::protocol::club::v1::ClubMembershipDescription* membership) {
+  delete membership_;
+  membership_ = membership;
+  if (membership) {
+    set_has_membership();
+  } else {
+    clear_has_membership();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ClubAddedNotification.membership)
+}
+
+// -------------------------------------------------------------------
+
+// ClubRemovedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool ClubRemovedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubRemovedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubRemovedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubRemovedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& ClubRemovedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ClubRemovedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubRemovedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ClubRemovedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubRemovedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void ClubRemovedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ClubRemovedNotification.agent_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+inline bool ClubRemovedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubRemovedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubRemovedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubRemovedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& ClubRemovedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ClubRemovedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* ClubRemovedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ClubRemovedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* ClubRemovedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void ClubRemovedNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ClubRemovedNotification.subscriber_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 3;
+inline bool ClubRemovedNotification::has_member_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubRemovedNotification::set_has_member_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubRemovedNotification::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubRemovedNotification::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& ClubRemovedNotification::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ClubRemovedNotification.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubRemovedNotification::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ClubRemovedNotification.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubRemovedNotification::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void ClubRemovedNotification::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ClubRemovedNotification.member_id)
+}
+
+// optional uint64 club_id = 4;
+inline bool ClubRemovedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubRemovedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubRemovedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubRemovedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 ClubRemovedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ClubRemovedNotification.club_id)
+  return club_id_;
+}
+inline void ClubRemovedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.membership.ClubRemovedNotification.club_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubRemovedReason reason = 5;
+inline bool ClubRemovedNotification::has_reason() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubRemovedNotification::set_has_reason() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubRemovedNotification::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubRemovedNotification::clear_reason() {
+  reason_ = 0;
+  clear_has_reason();
+}
+inline ::bgs::protocol::club::v1::ClubRemovedReason ClubRemovedNotification::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ClubRemovedNotification.reason)
+  return static_cast< ::bgs::protocol::club::v1::ClubRemovedReason >(reason_);
+}
+inline void ClubRemovedNotification::set_reason(::bgs::protocol::club::v1::ClubRemovedReason value) {
+  assert(::bgs::protocol::club::v1::ClubRemovedReason_IsValid(value));
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.membership.ClubRemovedNotification.reason)
+}
+
+// -------------------------------------------------------------------
+
+// ReceivedInvitationAddedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool ReceivedInvitationAddedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ReceivedInvitationAddedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ReceivedInvitationAddedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ReceivedInvitationAddedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& ReceivedInvitationAddedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ReceivedInvitationAddedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ReceivedInvitationAddedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void ReceivedInvitationAddedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification.agent_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+inline bool ReceivedInvitationAddedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ReceivedInvitationAddedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ReceivedInvitationAddedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ReceivedInvitationAddedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& ReceivedInvitationAddedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* ReceivedInvitationAddedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* ReceivedInvitationAddedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void ReceivedInvitationAddedNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification.subscriber_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubInvitation invitation = 3;
+inline bool ReceivedInvitationAddedNotification::has_invitation() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ReceivedInvitationAddedNotification::set_has_invitation() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ReceivedInvitationAddedNotification::clear_has_invitation() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ReceivedInvitationAddedNotification::clear_invitation() {
+  if (invitation_ != NULL) invitation_->::bgs::protocol::club::v1::ClubInvitation::Clear();
+  clear_has_invitation();
+}
+inline const ::bgs::protocol::club::v1::ClubInvitation& ReceivedInvitationAddedNotification::invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification.invitation)
+  return invitation_ != NULL ? *invitation_ : *default_instance_->invitation_;
+}
+inline ::bgs::protocol::club::v1::ClubInvitation* ReceivedInvitationAddedNotification::mutable_invitation() {
+  set_has_invitation();
+  if (invitation_ == NULL) invitation_ = new ::bgs::protocol::club::v1::ClubInvitation;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification.invitation)
+  return invitation_;
+}
+inline ::bgs::protocol::club::v1::ClubInvitation* ReceivedInvitationAddedNotification::release_invitation() {
+  clear_has_invitation();
+  ::bgs::protocol::club::v1::ClubInvitation* temp = invitation_;
+  invitation_ = NULL;
+  return temp;
+}
+inline void ReceivedInvitationAddedNotification::set_allocated_invitation(::bgs::protocol::club::v1::ClubInvitation* invitation) {
+  delete invitation_;
+  invitation_ = invitation;
+  if (invitation) {
+    set_has_invitation();
+  } else {
+    clear_has_invitation();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ReceivedInvitationAddedNotification.invitation)
+}
+
+// -------------------------------------------------------------------
+
+// ReceivedInvitationRemovedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool ReceivedInvitationRemovedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ReceivedInvitationRemovedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ReceivedInvitationRemovedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ReceivedInvitationRemovedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& ReceivedInvitationRemovedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ReceivedInvitationRemovedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ReceivedInvitationRemovedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void ReceivedInvitationRemovedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.agent_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+inline bool ReceivedInvitationRemovedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ReceivedInvitationRemovedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ReceivedInvitationRemovedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ReceivedInvitationRemovedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& ReceivedInvitationRemovedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* ReceivedInvitationRemovedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* ReceivedInvitationRemovedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void ReceivedInvitationRemovedNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.subscriber_id)
+}
+
+// optional fixed64 invitation_id = 3;
+inline bool ReceivedInvitationRemovedNotification::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ReceivedInvitationRemovedNotification::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ReceivedInvitationRemovedNotification::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ReceivedInvitationRemovedNotification::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 ReceivedInvitationRemovedNotification::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.invitation_id)
+  return invitation_id_;
+}
+inline void ReceivedInvitationRemovedNotification::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.invitation_id)
+}
+
+// optional .bgs.protocol.InvitationRemovedReason reason = 4;
+inline bool ReceivedInvitationRemovedNotification::has_reason() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ReceivedInvitationRemovedNotification::set_has_reason() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ReceivedInvitationRemovedNotification::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ReceivedInvitationRemovedNotification::clear_reason() {
+  reason_ = 0;
+  clear_has_reason();
+}
+inline ::bgs::protocol::InvitationRemovedReason ReceivedInvitationRemovedNotification::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.reason)
+  return static_cast< ::bgs::protocol::InvitationRemovedReason >(reason_);
+}
+inline void ReceivedInvitationRemovedNotification::set_reason(::bgs::protocol::InvitationRemovedReason value) {
+  assert(::bgs::protocol::InvitationRemovedReason_IsValid(value));
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.membership.ReceivedInvitationRemovedNotification.reason)
+}
+
+// -------------------------------------------------------------------
+
+// SharedSettingsChangedNotification
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool SharedSettingsChangedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SharedSettingsChangedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SharedSettingsChangedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SharedSettingsChangedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& SharedSettingsChangedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SharedSettingsChangedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SharedSettingsChangedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SharedSettingsChangedNotification::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification.agent_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+inline bool SharedSettingsChangedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SharedSettingsChangedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SharedSettingsChangedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SharedSettingsChangedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& SharedSettingsChangedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SharedSettingsChangedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SharedSettingsChangedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void SharedSettingsChangedNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification.subscriber_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubSharedSettingsAssignment assignment = 4;
+inline bool SharedSettingsChangedNotification::has_assignment() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SharedSettingsChangedNotification::set_has_assignment() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SharedSettingsChangedNotification::clear_has_assignment() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SharedSettingsChangedNotification::clear_assignment() {
+  if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::ClubSharedSettingsAssignment::Clear();
+  clear_has_assignment();
+}
+inline const ::bgs::protocol::club::v1::ClubSharedSettingsAssignment& SharedSettingsChangedNotification::assignment() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification.assignment)
+  return assignment_ != NULL ? *assignment_ : *default_instance_->assignment_;
+}
+inline ::bgs::protocol::club::v1::ClubSharedSettingsAssignment* SharedSettingsChangedNotification::mutable_assignment() {
+  set_has_assignment();
+  if (assignment_ == NULL) assignment_ = new ::bgs::protocol::club::v1::ClubSharedSettingsAssignment;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification.assignment)
+  return assignment_;
+}
+inline ::bgs::protocol::club::v1::ClubSharedSettingsAssignment* SharedSettingsChangedNotification::release_assignment() {
+  clear_has_assignment();
+  ::bgs::protocol::club::v1::ClubSharedSettingsAssignment* temp = assignment_;
+  assignment_ = NULL;
+  return temp;
+}
+inline void SharedSettingsChangedNotification::set_allocated_assignment(::bgs::protocol::club::v1::ClubSharedSettingsAssignment* assignment) {
+  delete assignment_;
+  assignment_ = assignment;
+  if (assignment) {
+    set_has_assignment();
+  } else {
+    clear_has_assignment();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.SharedSettingsChangedNotification.assignment)
+}
+
+// -------------------------------------------------------------------
+
+// StreamMentionAddedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StreamMentionAddedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamMentionAddedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamMentionAddedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamMentionAddedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamMentionAddedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.StreamMentionAddedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMentionAddedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.StreamMentionAddedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMentionAddedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamMentionAddedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.StreamMentionAddedNotification.agent_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+inline bool StreamMentionAddedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamMentionAddedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamMentionAddedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamMentionAddedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& StreamMentionAddedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.StreamMentionAddedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionAddedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.StreamMentionAddedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionAddedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamMentionAddedNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.StreamMentionAddedNotification.subscriber_id)
+}
+
+// optional .bgs.protocol.club.v1.StreamMention mention = 3;
+inline bool StreamMentionAddedNotification::has_mention() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamMentionAddedNotification::set_has_mention() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamMentionAddedNotification::clear_has_mention() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamMentionAddedNotification::clear_mention() {
+  if (mention_ != NULL) mention_->::bgs::protocol::club::v1::StreamMention::Clear();
+  clear_has_mention();
+}
+inline const ::bgs::protocol::club::v1::StreamMention& StreamMentionAddedNotification::mention() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.StreamMentionAddedNotification.mention)
+  return mention_ != NULL ? *mention_ : *default_instance_->mention_;
+}
+inline ::bgs::protocol::club::v1::StreamMention* StreamMentionAddedNotification::mutable_mention() {
+  set_has_mention();
+  if (mention_ == NULL) mention_ = new ::bgs::protocol::club::v1::StreamMention;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.StreamMentionAddedNotification.mention)
+  return mention_;
+}
+inline ::bgs::protocol::club::v1::StreamMention* StreamMentionAddedNotification::release_mention() {
+  clear_has_mention();
+  ::bgs::protocol::club::v1::StreamMention* temp = mention_;
+  mention_ = NULL;
+  return temp;
+}
+inline void StreamMentionAddedNotification::set_allocated_mention(::bgs::protocol::club::v1::StreamMention* mention) {
+  delete mention_;
+  mention_ = mention;
+  if (mention) {
+    set_has_mention();
+  } else {
+    clear_has_mention();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.StreamMentionAddedNotification.mention)
+}
+
+// -------------------------------------------------------------------
+
+// StreamMentionRemovedNotification
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool StreamMentionRemovedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamMentionRemovedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamMentionRemovedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamMentionRemovedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& StreamMentionRemovedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionRemovedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionRemovedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamMentionRemovedNotification::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification.agent_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+inline bool StreamMentionRemovedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamMentionRemovedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamMentionRemovedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamMentionRemovedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& StreamMentionRemovedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionRemovedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionRemovedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamMentionRemovedNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification.subscriber_id)
+}
+
+// optional .bgs.protocol.TimeSeriesId mention_id = 3;
+inline bool StreamMentionRemovedNotification::has_mention_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamMentionRemovedNotification::set_has_mention_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamMentionRemovedNotification::clear_has_mention_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamMentionRemovedNotification::clear_mention_id() {
+  if (mention_id_ != NULL) mention_id_->::bgs::protocol::TimeSeriesId::Clear();
+  clear_has_mention_id();
+}
+inline const ::bgs::protocol::TimeSeriesId& StreamMentionRemovedNotification::mention_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification.mention_id)
+  return mention_id_ != NULL ? *mention_id_ : *default_instance_->mention_id_;
+}
+inline ::bgs::protocol::TimeSeriesId* StreamMentionRemovedNotification::mutable_mention_id() {
+  set_has_mention_id();
+  if (mention_id_ == NULL) mention_id_ = new ::bgs::protocol::TimeSeriesId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification.mention_id)
+  return mention_id_;
+}
+inline ::bgs::protocol::TimeSeriesId* StreamMentionRemovedNotification::release_mention_id() {
+  clear_has_mention_id();
+  ::bgs::protocol::TimeSeriesId* temp = mention_id_;
+  mention_id_ = NULL;
+  return temp;
+}
+inline void StreamMentionRemovedNotification::set_allocated_mention_id(::bgs::protocol::TimeSeriesId* mention_id) {
+  delete mention_id_;
+  mention_id_ = mention_id;
+  if (mention_id) {
+    set_has_mention_id();
+  } else {
+    clear_has_mention_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.StreamMentionRemovedNotification.mention_id)
+}
+
+// -------------------------------------------------------------------
+
+// StreamMentionAdvanceViewTimeNotification
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool StreamMentionAdvanceViewTimeNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamMentionAdvanceViewTimeNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamMentionAdvanceViewTimeNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamMentionAdvanceViewTimeNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& StreamMentionAdvanceViewTimeNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionAdvanceViewTimeNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionAdvanceViewTimeNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamMentionAdvanceViewTimeNotification::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification.agent_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 2;
+inline bool StreamMentionAdvanceViewTimeNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamMentionAdvanceViewTimeNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamMentionAdvanceViewTimeNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamMentionAdvanceViewTimeNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& StreamMentionAdvanceViewTimeNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionAdvanceViewTimeNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StreamMentionAdvanceViewTimeNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamMentionAdvanceViewTimeNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification.subscriber_id)
+}
+
+// optional uint64 view_time = 3;
+inline bool StreamMentionAdvanceViewTimeNotification::has_view_time() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamMentionAdvanceViewTimeNotification::set_has_view_time() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamMentionAdvanceViewTimeNotification::clear_has_view_time() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamMentionAdvanceViewTimeNotification::clear_view_time() {
+  view_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_view_time();
+}
+inline ::google::protobuf::uint64 StreamMentionAdvanceViewTimeNotification::view_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification.view_time)
+  return view_time_;
+}
+inline void StreamMentionAdvanceViewTimeNotification::set_view_time(::google::protobuf::uint64 value) {
+  set_has_view_time();
+  view_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.membership.StreamMentionAdvanceViewTimeNotification.view_time)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace membership
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5fmembership_5flistener_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_membership_service.pb.cc b/src/server/proto/Client/club_membership_service.pb.cc
new file mode 100644
index 00000000000..945c22514dc
--- /dev/null
+++ b/src/server/proto/Client/club_membership_service.pb.cc
@@ -0,0 +1,3175 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_membership_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_membership_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "Errors.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+namespace membership {
+
+namespace {
+
+const ::google::protobuf::Descriptor* SubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscribeResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnsubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStateResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStateResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateClubSharedSettingsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateClubSharedSettingsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamMentionsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamMentionsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamMentionsResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamMentionsResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RemoveStreamMentionsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RemoveStreamMentionsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AdvanceStreamMentionViewTimeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AdvanceStreamMentionViewTimeRequest_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ClubMembershipService_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto() {
+  protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_membership_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  SubscribeRequest_descriptor_ = file->message_type(0);
+  static const int SubscribeRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, agent_id_),
+  };
+  SubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeRequest_descriptor_,
+      SubscribeRequest::default_instance_,
+      SubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeRequest));
+  SubscribeResponse_descriptor_ = file->message_type(1);
+  static const int SubscribeResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, state_),
+  };
+  SubscribeResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeResponse_descriptor_,
+      SubscribeResponse::default_instance_,
+      SubscribeResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeResponse));
+  UnsubscribeRequest_descriptor_ = file->message_type(2);
+  static const int UnsubscribeRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, agent_id_),
+  };
+  UnsubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsubscribeRequest_descriptor_,
+      UnsubscribeRequest::default_instance_,
+      UnsubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsubscribeRequest));
+  GetStateRequest_descriptor_ = file->message_type(3);
+  static const int GetStateRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStateRequest, agent_id_),
+  };
+  GetStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStateRequest_descriptor_,
+      GetStateRequest::default_instance_,
+      GetStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStateRequest));
+  GetStateResponse_descriptor_ = file->message_type(4);
+  static const int GetStateResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStateResponse, state_),
+  };
+  GetStateResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStateResponse_descriptor_,
+      GetStateResponse::default_instance_,
+      GetStateResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStateResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStateResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStateResponse));
+  UpdateClubSharedSettingsRequest_descriptor_ = file->message_type(5);
+  static const int UpdateClubSharedSettingsRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubSharedSettingsRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubSharedSettingsRequest, options_),
+  };
+  UpdateClubSharedSettingsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateClubSharedSettingsRequest_descriptor_,
+      UpdateClubSharedSettingsRequest::default_instance_,
+      UpdateClubSharedSettingsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubSharedSettingsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubSharedSettingsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateClubSharedSettingsRequest));
+  GetStreamMentionsRequest_descriptor_ = file->message_type(6);
+  static const int GetStreamMentionsRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamMentionsRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamMentionsRequest, options_),
+  };
+  GetStreamMentionsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamMentionsRequest_descriptor_,
+      GetStreamMentionsRequest::default_instance_,
+      GetStreamMentionsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamMentionsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamMentionsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamMentionsRequest));
+  GetStreamMentionsResponse_descriptor_ = file->message_type(7);
+  static const int GetStreamMentionsResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamMentionsResponse, mention_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamMentionsResponse, continuation_),
+  };
+  GetStreamMentionsResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamMentionsResponse_descriptor_,
+      GetStreamMentionsResponse::default_instance_,
+      GetStreamMentionsResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamMentionsResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamMentionsResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamMentionsResponse));
+  RemoveStreamMentionsRequest_descriptor_ = file->message_type(8);
+  static const int RemoveStreamMentionsRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveStreamMentionsRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveStreamMentionsRequest, mention_id_),
+  };
+  RemoveStreamMentionsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RemoveStreamMentionsRequest_descriptor_,
+      RemoveStreamMentionsRequest::default_instance_,
+      RemoveStreamMentionsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveStreamMentionsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveStreamMentionsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RemoveStreamMentionsRequest));
+  AdvanceStreamMentionViewTimeRequest_descriptor_ = file->message_type(9);
+  static const int AdvanceStreamMentionViewTimeRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamMentionViewTimeRequest, agent_id_),
+  };
+  AdvanceStreamMentionViewTimeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AdvanceStreamMentionViewTimeRequest_descriptor_,
+      AdvanceStreamMentionViewTimeRequest::default_instance_,
+      AdvanceStreamMentionViewTimeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamMentionViewTimeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamMentionViewTimeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AdvanceStreamMentionViewTimeRequest));
+  ClubMembershipService_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5fmembership_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeRequest_descriptor_, &SubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeResponse_descriptor_, &SubscribeResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsubscribeRequest_descriptor_, &UnsubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStateRequest_descriptor_, &GetStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStateResponse_descriptor_, &GetStateResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateClubSharedSettingsRequest_descriptor_, &UpdateClubSharedSettingsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamMentionsRequest_descriptor_, &GetStreamMentionsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamMentionsResponse_descriptor_, &GetStreamMentionsResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RemoveStreamMentionsRequest_descriptor_, &RemoveStreamMentionsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AdvanceStreamMentionViewTimeRequest_descriptor_, &AdvanceStreamMentionViewTimeRequest::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto() {
+  delete SubscribeRequest::default_instance_;
+  delete SubscribeRequest_reflection_;
+  delete SubscribeResponse::default_instance_;
+  delete SubscribeResponse_reflection_;
+  delete UnsubscribeRequest::default_instance_;
+  delete UnsubscribeRequest_reflection_;
+  delete GetStateRequest::default_instance_;
+  delete GetStateRequest_reflection_;
+  delete GetStateResponse::default_instance_;
+  delete GetStateResponse_reflection_;
+  delete UpdateClubSharedSettingsRequest::default_instance_;
+  delete UpdateClubSharedSettingsRequest_reflection_;
+  delete GetStreamMentionsRequest::default_instance_;
+  delete GetStreamMentionsRequest_reflection_;
+  delete GetStreamMentionsResponse::default_instance_;
+  delete GetStreamMentionsResponse_reflection_;
+  delete RemoveStreamMentionsRequest::default_instance_;
+  delete RemoveStreamMentionsRequest_reflection_;
+  delete AdvanceStreamMentionViewTimeRequest::default_instance_;
+  delete AdvanceStreamMentionViewTimeRequest_reflection_;
+}
+
+void protobuf_AddDesc_club_5fmembership_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5ftypes_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fstream_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\035club_membership_service.proto\022\037bgs.pro"
+    "tocol.club.v1.membership\032\020club_types.pro"
+    "to\032\021club_stream.proto\"H\n\020SubscribeReques"
+    "t\0224\n\010agent_id\030\001 \001(\0132\".bgs.protocol.accou"
+    "nt.v1.AccountId\"M\n\021SubscribeResponse\0228\n\005"
+    "state\030\001 \001(\0132).bgs.protocol.club.v1.ClubM"
+    "embershipState\"J\n\022UnsubscribeRequest\0224\n\010"
+    "agent_id\030\001 \001(\0132\".bgs.protocol.account.v1"
+    ".AccountId\"G\n\017GetStateRequest\0224\n\010agent_i"
+    "d\030\001 \001(\0132\".bgs.protocol.account.v1.Accoun"
+    "tId\"L\n\020GetStateResponse\0228\n\005state\030\001 \001(\0132)"
+    ".bgs.protocol.club.v1.ClubMembershipStat"
+    "e\"\231\001\n\037UpdateClubSharedSettingsRequest\0224\n"
+    "\010agent_id\030\001 \001(\0132\".bgs.protocol.account.v"
+    "1.AccountId\022@\n\007options\030\002 \001(\0132/.bgs.proto"
+    "col.club.v1.ClubSharedSettingsOptions\"\200\001"
+    "\n\030GetStreamMentionsRequest\0224\n\010agent_id\030\001"
+    " \001(\0132\".bgs.protocol.account.v1.AccountId"
+    "\022.\n\007options\030\002 \001(\0132\035.bgs.protocol.GetEven"
+    "tOptions\"g\n\031GetStreamMentionsResponse\0224\n"
+    "\007mention\030\001 \003(\0132#.bgs.protocol.club.v1.St"
+    "reamMention\022\024\n\014continuation\030\002 \001(\004\"\203\001\n\033Re"
+    "moveStreamMentionsRequest\0224\n\010agent_id\030\001 "
+    "\001(\0132\".bgs.protocol.account.v1.AccountId\022"
+    ".\n\nmention_id\030\002 \003(\0132\032.bgs.protocol.TimeS"
+    "eriesId\"[\n#AdvanceStreamMentionViewTimeR"
+    "equest\0224\n\010agent_id\030\001 \001(\0132\".bgs.protocol."
+    "account.v1.AccountId2\304\007\n\025ClubMembershipS"
+    "ervice\022z\n\tSubscribe\0221.bgs.protocol.club."
+    "v1.membership.SubscribeRequest\0322.bgs.pro"
+    "tocol.club.v1.membership.SubscribeRespon"
+    "se\"\006\202\371+\002\010\001\022`\n\013Unsubscribe\0223.bgs.protocol"
+    ".club.v1.membership.UnsubscribeRequest\032\024"
+    ".bgs.protocol.NoData\"\006\202\371+\002\010\002\022w\n\010GetState"
+    "\0220.bgs.protocol.club.v1.membership.GetSt"
+    "ateRequest\0321.bgs.protocol.club.v1.member"
+    "ship.GetStateResponse\"\006\202\371+\002\010\003\022z\n\030UpdateC"
+    "lubSharedSettings\022@.bgs.protocol.club.v1"
+    ".membership.UpdateClubSharedSettingsRequ"
+    "est\032\024.bgs.protocol.NoData\"\006\202\371+\002\010\004\022\222\001\n\021Ge"
+    "tStreamMentions\0229.bgs.protocol.club.v1.m"
+    "embership.GetStreamMentionsRequest\032:.bgs"
+    ".protocol.club.v1.membership.GetStreamMe"
+    "ntionsResponse\"\006\202\371+\002\010\005\022r\n\024RemoveStreamMe"
+    "ntions\022<.bgs.protocol.club.v1.membership"
+    ".RemoveStreamMentionsRequest\032\024.bgs.proto"
+    "col.NoData\"\006\202\371+\002\010\006\022\202\001\n\034AdvanceStreamMent"
+    "ionViewTime\022D.bgs.protocol.club.v1.membe"
+    "rship.AdvanceStreamMentionViewTimeReques"
+    "t\032\024.bgs.protocol.NoData\"\006\202\371+\002\010\007\032J\202\371+>\n+b"
+    "net.protocol.club.v1.ClubMembershipServi"
+    "ce*\017club_membership\212\371+\004\020\001\030\001B\005H\001\200\001\000", 2074);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_membership_service.proto", &protobuf_RegisterTypes);
+  SubscribeRequest::default_instance_ = new SubscribeRequest();
+  SubscribeResponse::default_instance_ = new SubscribeResponse();
+  UnsubscribeRequest::default_instance_ = new UnsubscribeRequest();
+  GetStateRequest::default_instance_ = new GetStateRequest();
+  GetStateResponse::default_instance_ = new GetStateResponse();
+  UpdateClubSharedSettingsRequest::default_instance_ = new UpdateClubSharedSettingsRequest();
+  GetStreamMentionsRequest::default_instance_ = new GetStreamMentionsRequest();
+  GetStreamMentionsResponse::default_instance_ = new GetStreamMentionsResponse();
+  RemoveStreamMentionsRequest::default_instance_ = new RemoveStreamMentionsRequest();
+  AdvanceStreamMentionViewTimeRequest::default_instance_ = new AdvanceStreamMentionViewTimeRequest();
+  SubscribeRequest::default_instance_->InitAsDefaultInstance();
+  SubscribeResponse::default_instance_->InitAsDefaultInstance();
+  UnsubscribeRequest::default_instance_->InitAsDefaultInstance();
+  GetStateRequest::default_instance_->InitAsDefaultInstance();
+  GetStateResponse::default_instance_->InitAsDefaultInstance();
+  UpdateClubSharedSettingsRequest::default_instance_->InitAsDefaultInstance();
+  GetStreamMentionsRequest::default_instance_->InitAsDefaultInstance();
+  GetStreamMentionsResponse::default_instance_->InitAsDefaultInstance();
+  RemoveStreamMentionsRequest::default_instance_->InitAsDefaultInstance();
+  AdvanceStreamMentionViewTimeRequest::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5fmembership_5fservice_2eproto {
+  StaticDescriptorInitializer_club_5fmembership_5fservice_2eproto() {
+    protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  }
+} static_descriptor_initializer_club_5fmembership_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeRequest::kAgentIdFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeRequest::SubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.SubscribeRequest)
+}
+
+void SubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+SubscribeRequest::SubscribeRequest(const SubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.SubscribeRequest)
+}
+
+void SubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeRequest::~SubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.SubscribeRequest)
+  SharedDtor();
+}
+
+void SubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeRequest_descriptor_;
+}
+
+const SubscribeRequest& SubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscribeRequest* SubscribeRequest::default_instance_ = NULL;
+
+SubscribeRequest* SubscribeRequest::New() const {
+  return new SubscribeRequest;
+}
+
+void SubscribeRequest::Clear() {
+  if (has_agent_id()) {
+    if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.SubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.SubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.SubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void SubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.SubscribeRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.SubscribeRequest)
+}
+
+::google::protobuf::uint8* SubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.SubscribeRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.SubscribeRequest)
+  return target;
+}
+
+int SubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeRequest::MergeFrom(const SubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeRequest::CopyFrom(const SubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscribeRequest::Swap(SubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeRequest_descriptor_;
+  metadata.reflection = SubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeResponse::kStateFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeResponse::SubscribeResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.SubscribeResponse)
+}
+
+void SubscribeResponse::InitAsDefaultInstance() {
+  state_ = const_cast< ::bgs::protocol::club::v1::ClubMembershipState*>(&::bgs::protocol::club::v1::ClubMembershipState::default_instance());
+}
+
+SubscribeResponse::SubscribeResponse(const SubscribeResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.SubscribeResponse)
+}
+
+void SubscribeResponse::SharedCtor() {
+  _cached_size_ = 0;
+  state_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeResponse::~SubscribeResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.SubscribeResponse)
+  SharedDtor();
+}
+
+void SubscribeResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete state_;
+  }
+}
+
+void SubscribeResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeResponse_descriptor_;
+}
+
+const SubscribeResponse& SubscribeResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscribeResponse* SubscribeResponse::default_instance_ = NULL;
+
+SubscribeResponse* SubscribeResponse::New() const {
+  return new SubscribeResponse;
+}
+
+void SubscribeResponse::Clear() {
+  if (has_state()) {
+    if (state_ != NULL) state_->::bgs::protocol::club::v1::ClubMembershipState::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.SubscribeResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.SubscribeResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.SubscribeResponse)
+  return false;
+#undef DO_
+}
+
+void SubscribeResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.SubscribeResponse)
+  // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->state(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.SubscribeResponse)
+}
+
+::google::protobuf::uint8* SubscribeResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.SubscribeResponse)
+  // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+  if (has_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->state(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.SubscribeResponse)
+  return target;
+}
+
+int SubscribeResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->state());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeResponse::MergeFrom(const SubscribeResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_state()) {
+      mutable_state()->::bgs::protocol::club::v1::ClubMembershipState::MergeFrom(from.state());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeResponse::CopyFrom(const SubscribeResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeResponse::IsInitialized() const {
+
+  if (has_state()) {
+    if (!this->state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscribeResponse::Swap(SubscribeResponse* other) {
+  if (other != this) {
+    std::swap(state_, other->state_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeResponse_descriptor_;
+  metadata.reflection = SubscribeResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsubscribeRequest::kAgentIdFieldNumber;
+#endif  // !_MSC_VER
+
+UnsubscribeRequest::UnsubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+UnsubscribeRequest::UnsubscribeRequest(const UnsubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsubscribeRequest::~UnsubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+  SharedDtor();
+}
+
+void UnsubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void UnsubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsubscribeRequest_descriptor_;
+}
+
+const UnsubscribeRequest& UnsubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UnsubscribeRequest* UnsubscribeRequest::default_instance_ = NULL;
+
+UnsubscribeRequest* UnsubscribeRequest::New() const {
+  return new UnsubscribeRequest;
+}
+
+void UnsubscribeRequest::Clear() {
+  if (has_agent_id()) {
+    if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void UnsubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+}
+
+::google::protobuf::uint8* UnsubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+  return target;
+}
+
+int UnsubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsubscribeRequest::MergeFrom(const UnsubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsubscribeRequest::CopyFrom(const UnsubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsubscribeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnsubscribeRequest::Swap(UnsubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsubscribeRequest_descriptor_;
+  metadata.reflection = UnsubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStateRequest::kAgentIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetStateRequest::GetStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.GetStateRequest)
+}
+
+void GetStateRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+GetStateRequest::GetStateRequest(const GetStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.GetStateRequest)
+}
+
+void GetStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStateRequest::~GetStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.GetStateRequest)
+  SharedDtor();
+}
+
+void GetStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStateRequest_descriptor_;
+}
+
+const GetStateRequest& GetStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetStateRequest* GetStateRequest::default_instance_ = NULL;
+
+GetStateRequest* GetStateRequest::New() const {
+  return new GetStateRequest;
+}
+
+void GetStateRequest::Clear() {
+  if (has_agent_id()) {
+    if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.GetStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.GetStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.GetStateRequest)
+  return false;
+#undef DO_
+}
+
+void GetStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.GetStateRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.GetStateRequest)
+}
+
+::google::protobuf::uint8* GetStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.GetStateRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.GetStateRequest)
+  return target;
+}
+
+int GetStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStateRequest::MergeFrom(const GetStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStateRequest::CopyFrom(const GetStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStateRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetStateRequest::Swap(GetStateRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStateRequest_descriptor_;
+  metadata.reflection = GetStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStateResponse::kStateFieldNumber;
+#endif  // !_MSC_VER
+
+GetStateResponse::GetStateResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.GetStateResponse)
+}
+
+void GetStateResponse::InitAsDefaultInstance() {
+  state_ = const_cast< ::bgs::protocol::club::v1::ClubMembershipState*>(&::bgs::protocol::club::v1::ClubMembershipState::default_instance());
+}
+
+GetStateResponse::GetStateResponse(const GetStateResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.GetStateResponse)
+}
+
+void GetStateResponse::SharedCtor() {
+  _cached_size_ = 0;
+  state_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStateResponse::~GetStateResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.GetStateResponse)
+  SharedDtor();
+}
+
+void GetStateResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete state_;
+  }
+}
+
+void GetStateResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStateResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStateResponse_descriptor_;
+}
+
+const GetStateResponse& GetStateResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetStateResponse* GetStateResponse::default_instance_ = NULL;
+
+GetStateResponse* GetStateResponse::New() const {
+  return new GetStateResponse;
+}
+
+void GetStateResponse::Clear() {
+  if (has_state()) {
+    if (state_ != NULL) state_->::bgs::protocol::club::v1::ClubMembershipState::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStateResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.GetStateResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.GetStateResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.GetStateResponse)
+  return false;
+#undef DO_
+}
+
+void GetStateResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.GetStateResponse)
+  // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->state(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.GetStateResponse)
+}
+
+::google::protobuf::uint8* GetStateResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.GetStateResponse)
+  // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+  if (has_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->state(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.GetStateResponse)
+  return target;
+}
+
+int GetStateResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->state());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStateResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStateResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStateResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStateResponse::MergeFrom(const GetStateResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_state()) {
+      mutable_state()->::bgs::protocol::club::v1::ClubMembershipState::MergeFrom(from.state());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStateResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStateResponse::CopyFrom(const GetStateResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStateResponse::IsInitialized() const {
+
+  if (has_state()) {
+    if (!this->state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetStateResponse::Swap(GetStateResponse* other) {
+  if (other != this) {
+    std::swap(state_, other->state_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStateResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStateResponse_descriptor_;
+  metadata.reflection = GetStateResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateClubSharedSettingsRequest::kAgentIdFieldNumber;
+const int UpdateClubSharedSettingsRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateClubSharedSettingsRequest::UpdateClubSharedSettingsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+}
+
+void UpdateClubSharedSettingsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::ClubSharedSettingsOptions*>(&::bgs::protocol::club::v1::ClubSharedSettingsOptions::default_instance());
+}
+
+UpdateClubSharedSettingsRequest::UpdateClubSharedSettingsRequest(const UpdateClubSharedSettingsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+}
+
+void UpdateClubSharedSettingsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateClubSharedSettingsRequest::~UpdateClubSharedSettingsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+  SharedDtor();
+}
+
+void UpdateClubSharedSettingsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void UpdateClubSharedSettingsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateClubSharedSettingsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateClubSharedSettingsRequest_descriptor_;
+}
+
+const UpdateClubSharedSettingsRequest& UpdateClubSharedSettingsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UpdateClubSharedSettingsRequest* UpdateClubSharedSettingsRequest::default_instance_ = NULL;
+
+UpdateClubSharedSettingsRequest* UpdateClubSharedSettingsRequest::New() const {
+  return new UpdateClubSharedSettingsRequest;
+}
+
+void UpdateClubSharedSettingsRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::ClubSharedSettingsOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateClubSharedSettingsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSharedSettingsOptions options = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateClubSharedSettingsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSharedSettingsOptions options = 2;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+}
+
+::google::protobuf::uint8* UpdateClubSharedSettingsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSharedSettingsOptions options = 2;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+  return target;
+}
+
+int UpdateClubSharedSettingsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSharedSettingsOptions options = 2;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateClubSharedSettingsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateClubSharedSettingsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateClubSharedSettingsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateClubSharedSettingsRequest::MergeFrom(const UpdateClubSharedSettingsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::ClubSharedSettingsOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateClubSharedSettingsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateClubSharedSettingsRequest::CopyFrom(const UpdateClubSharedSettingsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateClubSharedSettingsRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateClubSharedSettingsRequest::Swap(UpdateClubSharedSettingsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateClubSharedSettingsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateClubSharedSettingsRequest_descriptor_;
+  metadata.reflection = UpdateClubSharedSettingsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamMentionsRequest::kAgentIdFieldNumber;
+const int GetStreamMentionsRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamMentionsRequest::GetStreamMentionsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+}
+
+void GetStreamMentionsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  options_ = const_cast< ::bgs::protocol::GetEventOptions*>(&::bgs::protocol::GetEventOptions::default_instance());
+}
+
+GetStreamMentionsRequest::GetStreamMentionsRequest(const GetStreamMentionsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+}
+
+void GetStreamMentionsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamMentionsRequest::~GetStreamMentionsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+  SharedDtor();
+}
+
+void GetStreamMentionsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void GetStreamMentionsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamMentionsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamMentionsRequest_descriptor_;
+}
+
+const GetStreamMentionsRequest& GetStreamMentionsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetStreamMentionsRequest* GetStreamMentionsRequest::default_instance_ = NULL;
+
+GetStreamMentionsRequest* GetStreamMentionsRequest::New() const {
+  return new GetStreamMentionsRequest;
+}
+
+void GetStreamMentionsRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::GetEventOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamMentionsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.GetEventOptions options = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+  return false;
+#undef DO_
+}
+
+void GetStreamMentionsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.GetEventOptions options = 2;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+}
+
+::google::protobuf::uint8* GetStreamMentionsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.GetEventOptions options = 2;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+  return target;
+}
+
+int GetStreamMentionsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.GetEventOptions options = 2;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamMentionsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamMentionsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamMentionsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamMentionsRequest::MergeFrom(const GetStreamMentionsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::GetEventOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamMentionsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamMentionsRequest::CopyFrom(const GetStreamMentionsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamMentionsRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetStreamMentionsRequest::Swap(GetStreamMentionsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamMentionsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamMentionsRequest_descriptor_;
+  metadata.reflection = GetStreamMentionsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamMentionsResponse::kMentionFieldNumber;
+const int GetStreamMentionsResponse::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamMentionsResponse::GetStreamMentionsResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+}
+
+void GetStreamMentionsResponse::InitAsDefaultInstance() {
+}
+
+GetStreamMentionsResponse::GetStreamMentionsResponse(const GetStreamMentionsResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+}
+
+void GetStreamMentionsResponse::SharedCtor() {
+  _cached_size_ = 0;
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamMentionsResponse::~GetStreamMentionsResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+  SharedDtor();
+}
+
+void GetStreamMentionsResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetStreamMentionsResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamMentionsResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamMentionsResponse_descriptor_;
+}
+
+const GetStreamMentionsResponse& GetStreamMentionsResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetStreamMentionsResponse* GetStreamMentionsResponse::default_instance_ = NULL;
+
+GetStreamMentionsResponse* GetStreamMentionsResponse::New() const {
+  return new GetStreamMentionsResponse;
+}
+
+void GetStreamMentionsResponse::Clear() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  mention_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamMentionsResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.StreamMention mention = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_mention:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_mention()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_mention;
+        if (input->ExpectTag(16)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+  return false;
+#undef DO_
+}
+
+void GetStreamMentionsResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+  // repeated .bgs.protocol.club.v1.StreamMention mention = 1;
+  for (int i = 0; i < this->mention_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->mention(i), output);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+}
+
+::google::protobuf::uint8* GetStreamMentionsResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+  // repeated .bgs.protocol.club.v1.StreamMention mention = 1;
+  for (int i = 0; i < this->mention_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->mention(i), target);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+  return target;
+}
+
+int GetStreamMentionsResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint64 continuation = 2;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.StreamMention mention = 1;
+  total_size += 1 * this->mention_size();
+  for (int i = 0; i < this->mention_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->mention(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamMentionsResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamMentionsResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamMentionsResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamMentionsResponse::MergeFrom(const GetStreamMentionsResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mention_.MergeFrom(from.mention_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamMentionsResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamMentionsResponse::CopyFrom(const GetStreamMentionsResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamMentionsResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->mention())) return false;
+  return true;
+}
+
+void GetStreamMentionsResponse::Swap(GetStreamMentionsResponse* other) {
+  if (other != this) {
+    mention_.Swap(&other->mention_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamMentionsResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamMentionsResponse_descriptor_;
+  metadata.reflection = GetStreamMentionsResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RemoveStreamMentionsRequest::kAgentIdFieldNumber;
+const int RemoveStreamMentionsRequest::kMentionIdFieldNumber;
+#endif  // !_MSC_VER
+
+RemoveStreamMentionsRequest::RemoveStreamMentionsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+}
+
+void RemoveStreamMentionsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+RemoveStreamMentionsRequest::RemoveStreamMentionsRequest(const RemoveStreamMentionsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+}
+
+void RemoveStreamMentionsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RemoveStreamMentionsRequest::~RemoveStreamMentionsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+  SharedDtor();
+}
+
+void RemoveStreamMentionsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void RemoveStreamMentionsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RemoveStreamMentionsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RemoveStreamMentionsRequest_descriptor_;
+}
+
+const RemoveStreamMentionsRequest& RemoveStreamMentionsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+RemoveStreamMentionsRequest* RemoveStreamMentionsRequest::default_instance_ = NULL;
+
+RemoveStreamMentionsRequest* RemoveStreamMentionsRequest::New() const {
+  return new RemoveStreamMentionsRequest;
+}
+
+void RemoveStreamMentionsRequest::Clear() {
+  if (has_agent_id()) {
+    if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  }
+  mention_id_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RemoveStreamMentionsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_mention_id;
+        break;
+      }
+
+      // repeated .bgs.protocol.TimeSeriesId mention_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_mention_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_mention_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_mention_id;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+  return false;
+#undef DO_
+}
+
+void RemoveStreamMentionsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // repeated .bgs.protocol.TimeSeriesId mention_id = 2;
+  for (int i = 0; i < this->mention_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->mention_id(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+}
+
+::google::protobuf::uint8* RemoveStreamMentionsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // repeated .bgs.protocol.TimeSeriesId mention_id = 2;
+  for (int i = 0; i < this->mention_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->mention_id(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+  return target;
+}
+
+int RemoveStreamMentionsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  // repeated .bgs.protocol.TimeSeriesId mention_id = 2;
+  total_size += 1 * this->mention_id_size();
+  for (int i = 0; i < this->mention_id_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->mention_id(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RemoveStreamMentionsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RemoveStreamMentionsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RemoveStreamMentionsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RemoveStreamMentionsRequest::MergeFrom(const RemoveStreamMentionsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mention_id_.MergeFrom(from.mention_id_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RemoveStreamMentionsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RemoveStreamMentionsRequest::CopyFrom(const RemoveStreamMentionsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RemoveStreamMentionsRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RemoveStreamMentionsRequest::Swap(RemoveStreamMentionsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    mention_id_.Swap(&other->mention_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RemoveStreamMentionsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RemoveStreamMentionsRequest_descriptor_;
+  metadata.reflection = RemoveStreamMentionsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AdvanceStreamMentionViewTimeRequest::kAgentIdFieldNumber;
+#endif  // !_MSC_VER
+
+AdvanceStreamMentionViewTimeRequest::AdvanceStreamMentionViewTimeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+}
+
+void AdvanceStreamMentionViewTimeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+AdvanceStreamMentionViewTimeRequest::AdvanceStreamMentionViewTimeRequest(const AdvanceStreamMentionViewTimeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+}
+
+void AdvanceStreamMentionViewTimeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AdvanceStreamMentionViewTimeRequest::~AdvanceStreamMentionViewTimeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+  SharedDtor();
+}
+
+void AdvanceStreamMentionViewTimeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void AdvanceStreamMentionViewTimeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AdvanceStreamMentionViewTimeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AdvanceStreamMentionViewTimeRequest_descriptor_;
+}
+
+const AdvanceStreamMentionViewTimeRequest& AdvanceStreamMentionViewTimeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AdvanceStreamMentionViewTimeRequest* AdvanceStreamMentionViewTimeRequest::default_instance_ = NULL;
+
+AdvanceStreamMentionViewTimeRequest* AdvanceStreamMentionViewTimeRequest::New() const {
+  return new AdvanceStreamMentionViewTimeRequest;
+}
+
+void AdvanceStreamMentionViewTimeRequest::Clear() {
+  if (has_agent_id()) {
+    if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AdvanceStreamMentionViewTimeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+  return false;
+#undef DO_
+}
+
+void AdvanceStreamMentionViewTimeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+}
+
+::google::protobuf::uint8* AdvanceStreamMentionViewTimeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+  return target;
+}
+
+int AdvanceStreamMentionViewTimeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AdvanceStreamMentionViewTimeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AdvanceStreamMentionViewTimeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AdvanceStreamMentionViewTimeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AdvanceStreamMentionViewTimeRequest::MergeFrom(const AdvanceStreamMentionViewTimeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AdvanceStreamMentionViewTimeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AdvanceStreamMentionViewTimeRequest::CopyFrom(const AdvanceStreamMentionViewTimeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AdvanceStreamMentionViewTimeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AdvanceStreamMentionViewTimeRequest::Swap(AdvanceStreamMentionViewTimeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AdvanceStreamMentionViewTimeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AdvanceStreamMentionViewTimeRequest_descriptor_;
+  metadata.reflection = AdvanceStreamMentionViewTimeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+ClubMembershipService::ClubMembershipService(bool use_original_hash) : service_hash_(use_original_hash ? OriginalHash::value : NameHash::value) {
+}
+
+ClubMembershipService::~ClubMembershipService() {
+}
+
+google::protobuf::ServiceDescriptor const* ClubMembershipService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubMembershipService_descriptor_;
+}
+
+void ClubMembershipService::Subscribe(::bgs::protocol::club::v1::membership::SubscribeRequest const* request, std::function<void(::bgs::protocol::club::v1::membership::SubscribeResponse const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipService.Subscribe(bgs.protocol.club.v1.membership.SubscribeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
+    ::bgs::protocol::club::v1::membership::SubscribeResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      responseCallback(&response);
+  };
+  SendRequest(service_hash_, 1, request, std::move(callback));
+}
+
+void ClubMembershipService::Unsubscribe(::bgs::protocol::club::v1::membership::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipService.Unsubscribe(bgs.protocol.club.v1.membership.UnsubscribeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      responseCallback(&response);
+  };
+  SendRequest(service_hash_, 2, request, std::move(callback));
+}
+
+void ClubMembershipService::GetState(::bgs::protocol::club::v1::membership::GetStateRequest const* request, std::function<void(::bgs::protocol::club::v1::membership::GetStateResponse const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipService.GetState(bgs.protocol.club.v1.membership.GetStateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
+    ::bgs::protocol::club::v1::membership::GetStateResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      responseCallback(&response);
+  };
+  SendRequest(service_hash_, 3, request, std::move(callback));
+}
+
+void ClubMembershipService::UpdateClubSharedSettings(::bgs::protocol::club::v1::membership::UpdateClubSharedSettingsRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipService.UpdateClubSharedSettings(bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      responseCallback(&response);
+  };
+  SendRequest(service_hash_, 4, request, std::move(callback));
+}
+
+void ClubMembershipService::GetStreamMentions(::bgs::protocol::club::v1::membership::GetStreamMentionsRequest const* request, std::function<void(::bgs::protocol::club::v1::membership::GetStreamMentionsResponse const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipService.GetStreamMentions(bgs.protocol.club.v1.membership.GetStreamMentionsRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
+    ::bgs::protocol::club::v1::membership::GetStreamMentionsResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      responseCallback(&response);
+  };
+  SendRequest(service_hash_, 5, request, std::move(callback));
+}
+
+void ClubMembershipService::RemoveStreamMentions(::bgs::protocol::club::v1::membership::RemoveStreamMentionsRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipService.RemoveStreamMentions(bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      responseCallback(&response);
+  };
+  SendRequest(service_hash_, 6, request, std::move(callback));
+}
+
+void ClubMembershipService::AdvanceStreamMentionViewTime(::bgs::protocol::club::v1::membership::AdvanceStreamMentionViewTimeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ClubMembershipService.AdvanceStreamMentionViewTime(bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      responseCallback(&response);
+  };
+  SendRequest(service_hash_, 7, request, std::move(callback));
+}
+
+void ClubMembershipService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::club::v1::membership::SubscribeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipService.Subscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.Subscribe(bgs.protocol.club.v1.membership.SubscribeRequest{ %s }).",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
+      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
+      {
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::club::v1::membership::SubscribeResponse::descriptor());
+        ClubMembershipService* self = static_cast<ClubMembershipService*>(service);
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.Subscribe() returned bgs.protocol.club.v1.membership.SubscribeResponse{ %s } status %u.",
+          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
+        if (!status)
+          self->SendResponse(self->service_hash_, 1, token, response);
+        else
+          self->SendResponse(self->service_hash_, 1, token, status);
+      };
+      ::bgs::protocol::club::v1::membership::SubscribeResponse response;
+      uint32 status = HandleSubscribe(&request, &response, continuation);
+      if (continuation)
+        continuation(this, status, &response);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::club::v1::membership::UnsubscribeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipService.Unsubscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.Unsubscribe(bgs.protocol.club.v1.membership.UnsubscribeRequest{ %s }).",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
+      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
+      {
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
+        ClubMembershipService* self = static_cast<ClubMembershipService*>(service);
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.Unsubscribe() returned bgs.protocol.NoData{ %s } status %u.",
+          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
+        if (!status)
+          self->SendResponse(self->service_hash_, 2, token, response);
+        else
+          self->SendResponse(self->service_hash_, 2, token, status);
+      };
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUnsubscribe(&request, &response, continuation);
+      if (continuation)
+        continuation(this, status, &response);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::club::v1::membership::GetStateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipService.GetState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.GetState(bgs.protocol.club.v1.membership.GetStateRequest{ %s }).",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
+      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
+      {
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::club::v1::membership::GetStateResponse::descriptor());
+        ClubMembershipService* self = static_cast<ClubMembershipService*>(service);
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.GetState() returned bgs.protocol.club.v1.membership.GetStateResponse{ %s } status %u.",
+          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
+        if (!status)
+          self->SendResponse(self->service_hash_, 3, token, response);
+        else
+          self->SendResponse(self->service_hash_, 3, token, status);
+      };
+      ::bgs::protocol::club::v1::membership::GetStateResponse response;
+      uint32 status = HandleGetState(&request, &response, continuation);
+      if (continuation)
+        continuation(this, status, &response);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::club::v1::membership::UpdateClubSharedSettingsRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipService.UpdateClubSharedSettings server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.UpdateClubSharedSettings(bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest{ %s }).",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
+      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
+      {
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
+        ClubMembershipService* self = static_cast<ClubMembershipService*>(service);
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.UpdateClubSharedSettings() returned bgs.protocol.NoData{ %s } status %u.",
+          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
+        if (!status)
+          self->SendResponse(self->service_hash_, 4, token, response);
+        else
+          self->SendResponse(self->service_hash_, 4, token, status);
+      };
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUpdateClubSharedSettings(&request, &response, continuation);
+      if (continuation)
+        continuation(this, status, &response);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::club::v1::membership::GetStreamMentionsRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipService.GetStreamMentions server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.GetStreamMentions(bgs.protocol.club.v1.membership.GetStreamMentionsRequest{ %s }).",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
+      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
+      {
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::club::v1::membership::GetStreamMentionsResponse::descriptor());
+        ClubMembershipService* self = static_cast<ClubMembershipService*>(service);
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.GetStreamMentions() returned bgs.protocol.club.v1.membership.GetStreamMentionsResponse{ %s } status %u.",
+          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
+        if (!status)
+          self->SendResponse(self->service_hash_, 5, token, response);
+        else
+          self->SendResponse(self->service_hash_, 5, token, status);
+      };
+      ::bgs::protocol::club::v1::membership::GetStreamMentionsResponse response;
+      uint32 status = HandleGetStreamMentions(&request, &response, continuation);
+      if (continuation)
+        continuation(this, status, &response);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::club::v1::membership::RemoveStreamMentionsRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipService.RemoveStreamMentions server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.RemoveStreamMentions(bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest{ %s }).",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
+      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
+      {
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
+        ClubMembershipService* self = static_cast<ClubMembershipService*>(service);
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.RemoveStreamMentions() returned bgs.protocol.NoData{ %s } status %u.",
+          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
+        if (!status)
+          self->SendResponse(self->service_hash_, 6, token, response);
+        else
+          self->SendResponse(self->service_hash_, 6, token, status);
+      };
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleRemoveStreamMentions(&request, &response, continuation);
+      if (continuation)
+        continuation(this, status, &response);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::club::v1::membership::AdvanceStreamMentionViewTimeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ClubMembershipService.AdvanceStreamMentionViewTime server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.AdvanceStreamMentionViewTime(bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest{ %s }).",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
+      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
+      {
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
+        ClubMembershipService* self = static_cast<ClubMembershipService*>(service);
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method ClubMembershipService.AdvanceStreamMentionViewTime() returned bgs.protocol.NoData{ %s } status %u.",
+          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
+        if (!status)
+          self->SendResponse(self->service_hash_, 7, token, response);
+        else
+          self->SendResponse(self->service_hash_, 7, token, status);
+      };
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleAdvanceStreamMentionViewTime(&request, &response, continuation);
+      if (continuation)
+        continuation(this, status, &response);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ClubMembershipService::HandleSubscribe(::bgs::protocol::club::v1::membership::SubscribeRequest const* request, ::bgs::protocol::club::v1::membership::SubscribeResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipService.Subscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipService::HandleUnsubscribe(::bgs::protocol::club::v1::membership::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipService.Unsubscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipService::HandleGetState(::bgs::protocol::club::v1::membership::GetStateRequest const* request, ::bgs::protocol::club::v1::membership::GetStateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipService.GetState({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipService::HandleUpdateClubSharedSettings(::bgs::protocol::club::v1::membership::UpdateClubSharedSettingsRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipService.UpdateClubSharedSettings({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipService::HandleGetStreamMentions(::bgs::protocol::club::v1::membership::GetStreamMentionsRequest const* request, ::bgs::protocol::club::v1::membership::GetStreamMentionsResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipService.GetStreamMentions({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipService::HandleRemoveStreamMentions(::bgs::protocol::club::v1::membership::RemoveStreamMentionsRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipService.RemoveStreamMentions({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ClubMembershipService::HandleAdvanceStreamMentionViewTime(::bgs::protocol::club::v1::membership::AdvanceStreamMentionViewTimeRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ClubMembershipService.AdvanceStreamMentionViewTime({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace membership
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_membership_service.pb.h b/src/server/proto/Client/club_membership_service.pb.h
new file mode 100644
index 00000000000..d6a3db8084a
--- /dev/null
+++ b/src/server/proto/Client/club_membership_service.pb.h
@@ -0,0 +1,1555 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_membership_service.proto
+
+#ifndef PROTOBUF_club_5fmembership_5fservice_2eproto__INCLUDED
+#define PROTOBUF_club_5fmembership_5fservice_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "club_types.pb.h"
+#include "club_stream.pb.h"
+#include "ServiceBase.h"
+#include "MessageBuffer.h"
+#include <functional>
+#include <type_traits>
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+namespace membership {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+class SubscribeRequest;
+class SubscribeResponse;
+class UnsubscribeRequest;
+class GetStateRequest;
+class GetStateResponse;
+class UpdateClubSharedSettingsRequest;
+class GetStreamMentionsRequest;
+class GetStreamMentionsResponse;
+class RemoveStreamMentionsRequest;
+class AdvanceStreamMentionViewTimeRequest;
+
+// ===================================================================
+
+class TC_PROTO_API SubscribeRequest : public ::google::protobuf::Message {
+ public:
+  SubscribeRequest();
+  virtual ~SubscribeRequest();
+
+  SubscribeRequest(const SubscribeRequest& from);
+
+  inline SubscribeRequest& operator=(const SubscribeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubscribeRequest& default_instance();
+
+  void Swap(SubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeRequest& from);
+  void MergeFrom(const SubscribeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.SubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SubscribeResponse : public ::google::protobuf::Message {
+ public:
+  SubscribeResponse();
+  virtual ~SubscribeResponse();
+
+  SubscribeResponse(const SubscribeResponse& from);
+
+  inline SubscribeResponse& operator=(const SubscribeResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubscribeResponse& default_instance();
+
+  void Swap(SubscribeResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeResponse& from);
+  void MergeFrom(const SubscribeResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubMembershipState& state() const;
+  inline ::bgs::protocol::club::v1::ClubMembershipState* mutable_state();
+  inline ::bgs::protocol::club::v1::ClubMembershipState* release_state();
+  inline void set_allocated_state(::bgs::protocol::club::v1::ClubMembershipState* state);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.SubscribeResponse)
+ private:
+  inline void set_has_state();
+  inline void clear_has_state();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubMembershipState* state_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UnsubscribeRequest : public ::google::protobuf::Message {
+ public:
+  UnsubscribeRequest();
+  virtual ~UnsubscribeRequest();
+
+  UnsubscribeRequest(const UnsubscribeRequest& from);
+
+  inline UnsubscribeRequest& operator=(const UnsubscribeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UnsubscribeRequest& default_instance();
+
+  void Swap(UnsubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsubscribeRequest& from);
+  void MergeFrom(const UnsubscribeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.UnsubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStateRequest : public ::google::protobuf::Message {
+ public:
+  GetStateRequest();
+  virtual ~GetStateRequest();
+
+  GetStateRequest(const GetStateRequest& from);
+
+  inline GetStateRequest& operator=(const GetStateRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStateRequest& default_instance();
+
+  void Swap(GetStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStateRequest& from);
+  void MergeFrom(const GetStateRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.GetStateRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStateResponse : public ::google::protobuf::Message {
+ public:
+  GetStateResponse();
+  virtual ~GetStateResponse();
+
+  GetStateResponse(const GetStateResponse& from);
+
+  inline GetStateResponse& operator=(const GetStateResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStateResponse& default_instance();
+
+  void Swap(GetStateResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStateResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStateResponse& from);
+  void MergeFrom(const GetStateResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubMembershipState& state() const;
+  inline ::bgs::protocol::club::v1::ClubMembershipState* mutable_state();
+  inline ::bgs::protocol::club::v1::ClubMembershipState* release_state();
+  inline void set_allocated_state(::bgs::protocol::club::v1::ClubMembershipState* state);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.GetStateResponse)
+ private:
+  inline void set_has_state();
+  inline void clear_has_state();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubMembershipState* state_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStateResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UpdateClubSharedSettingsRequest : public ::google::protobuf::Message {
+ public:
+  UpdateClubSharedSettingsRequest();
+  virtual ~UpdateClubSharedSettingsRequest();
+
+  UpdateClubSharedSettingsRequest(const UpdateClubSharedSettingsRequest& from);
+
+  inline UpdateClubSharedSettingsRequest& operator=(const UpdateClubSharedSettingsRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UpdateClubSharedSettingsRequest& default_instance();
+
+  void Swap(UpdateClubSharedSettingsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateClubSharedSettingsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateClubSharedSettingsRequest& from);
+  void MergeFrom(const UpdateClubSharedSettingsRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // optional .bgs.protocol.club.v1.ClubSharedSettingsOptions options = 2;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::ClubSharedSettingsOptions& options() const;
+  inline ::bgs::protocol::club::v1::ClubSharedSettingsOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::ClubSharedSettingsOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::ClubSharedSettingsOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  ::bgs::protocol::club::v1::ClubSharedSettingsOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateClubSharedSettingsRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamMentionsRequest : public ::google::protobuf::Message {
+ public:
+  GetStreamMentionsRequest();
+  virtual ~GetStreamMentionsRequest();
+
+  GetStreamMentionsRequest(const GetStreamMentionsRequest& from);
+
+  inline GetStreamMentionsRequest& operator=(const GetStreamMentionsRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamMentionsRequest& default_instance();
+
+  void Swap(GetStreamMentionsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamMentionsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamMentionsRequest& from);
+  void MergeFrom(const GetStreamMentionsRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // optional .bgs.protocol.GetEventOptions options = 2;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 2;
+  inline const ::bgs::protocol::GetEventOptions& options() const;
+  inline ::bgs::protocol::GetEventOptions* mutable_options();
+  inline ::bgs::protocol::GetEventOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::GetEventOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.GetStreamMentionsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  ::bgs::protocol::GetEventOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamMentionsRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamMentionsResponse : public ::google::protobuf::Message {
+ public:
+  GetStreamMentionsResponse();
+  virtual ~GetStreamMentionsResponse();
+
+  GetStreamMentionsResponse(const GetStreamMentionsResponse& from);
+
+  inline GetStreamMentionsResponse& operator=(const GetStreamMentionsResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamMentionsResponse& default_instance();
+
+  void Swap(GetStreamMentionsResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamMentionsResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamMentionsResponse& from);
+  void MergeFrom(const GetStreamMentionsResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.StreamMention mention = 1;
+  inline int mention_size() const;
+  inline void clear_mention();
+  static const int kMentionFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::StreamMention& mention(int index) const;
+  inline ::bgs::protocol::club::v1::StreamMention* mutable_mention(int index);
+  inline ::bgs::protocol::club::v1::StreamMention* add_mention();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMention >&
+      mention() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMention >*
+      mutable_mention();
+
+  // optional uint64 continuation = 2;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 2;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.GetStreamMentionsResponse)
+ private:
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMention > mention_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamMentionsResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RemoveStreamMentionsRequest : public ::google::protobuf::Message {
+ public:
+  RemoveStreamMentionsRequest();
+  virtual ~RemoveStreamMentionsRequest();
+
+  RemoveStreamMentionsRequest(const RemoveStreamMentionsRequest& from);
+
+  inline RemoveStreamMentionsRequest& operator=(const RemoveStreamMentionsRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RemoveStreamMentionsRequest& default_instance();
+
+  void Swap(RemoveStreamMentionsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  RemoveStreamMentionsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RemoveStreamMentionsRequest& from);
+  void MergeFrom(const RemoveStreamMentionsRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // repeated .bgs.protocol.TimeSeriesId mention_id = 2;
+  inline int mention_id_size() const;
+  inline void clear_mention_id();
+  static const int kMentionIdFieldNumber = 2;
+  inline const ::bgs::protocol::TimeSeriesId& mention_id(int index) const;
+  inline ::bgs::protocol::TimeSeriesId* mutable_mention_id(int index);
+  inline ::bgs::protocol::TimeSeriesId* add_mention_id();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::TimeSeriesId >&
+      mention_id() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::TimeSeriesId >*
+      mutable_mention_id();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::TimeSeriesId > mention_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static RemoveStreamMentionsRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AdvanceStreamMentionViewTimeRequest : public ::google::protobuf::Message {
+ public:
+  AdvanceStreamMentionViewTimeRequest();
+  virtual ~AdvanceStreamMentionViewTimeRequest();
+
+  AdvanceStreamMentionViewTimeRequest(const AdvanceStreamMentionViewTimeRequest& from);
+
+  inline AdvanceStreamMentionViewTimeRequest& operator=(const AdvanceStreamMentionViewTimeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AdvanceStreamMentionViewTimeRequest& default_instance();
+
+  void Swap(AdvanceStreamMentionViewTimeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AdvanceStreamMentionViewTimeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AdvanceStreamMentionViewTimeRequest& from);
+  void MergeFrom(const AdvanceStreamMentionViewTimeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& agent_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_agent_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* agent_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AdvanceStreamMentionViewTimeRequest* default_instance_;
+};
+// ===================================================================
+
+class TC_PROTO_API ClubMembershipService : public ServiceBase
+{
+ public:
+
+  explicit ClubMembershipService(bool use_original_hash);
+  virtual ~ClubMembershipService();
+
+  typedef std::integral_constant<uint32, 0x94B94786u> OriginalHash;
+  typedef std::integral_constant<uint32, 0xC1A60DF9u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void Subscribe(::bgs::protocol::club::v1::membership::SubscribeRequest const* request, std::function<void(::bgs::protocol::club::v1::membership::SubscribeResponse const*)> responseCallback);
+  void Unsubscribe(::bgs::protocol::club::v1::membership::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void GetState(::bgs::protocol::club::v1::membership::GetStateRequest const* request, std::function<void(::bgs::protocol::club::v1::membership::GetStateResponse const*)> responseCallback);
+  void UpdateClubSharedSettings(::bgs::protocol::club::v1::membership::UpdateClubSharedSettingsRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void GetStreamMentions(::bgs::protocol::club::v1::membership::GetStreamMentionsRequest const* request, std::function<void(::bgs::protocol::club::v1::membership::GetStreamMentionsResponse const*)> responseCallback);
+  void RemoveStreamMentions(::bgs::protocol::club::v1::membership::RemoveStreamMentionsRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void AdvanceStreamMentionViewTime(::bgs::protocol::club::v1::membership::AdvanceStreamMentionViewTimeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleSubscribe(::bgs::protocol::club::v1::membership::SubscribeRequest const* request, ::bgs::protocol::club::v1::membership::SubscribeResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleUnsubscribe(::bgs::protocol::club::v1::membership::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleGetState(::bgs::protocol::club::v1::membership::GetStateRequest const* request, ::bgs::protocol::club::v1::membership::GetStateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleUpdateClubSharedSettings(::bgs::protocol::club::v1::membership::UpdateClubSharedSettingsRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleGetStreamMentions(::bgs::protocol::club::v1::membership::GetStreamMentionsRequest const* request, ::bgs::protocol::club::v1::membership::GetStreamMentionsResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleRemoveStreamMentions(::bgs::protocol::club::v1::membership::RemoveStreamMentionsRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleAdvanceStreamMentionViewTime(::bgs::protocol::club::v1::membership::AdvanceStreamMentionViewTimeRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ClubMembershipService);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// SubscribeRequest
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool SubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& SubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.SubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.SubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SubscribeRequest::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.SubscribeRequest.agent_id)
+}
+
+// -------------------------------------------------------------------
+
+// SubscribeResponse
+
+// optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+inline bool SubscribeResponse::has_state() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeResponse::set_has_state() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeResponse::clear_has_state() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeResponse::clear_state() {
+  if (state_ != NULL) state_->::bgs::protocol::club::v1::ClubMembershipState::Clear();
+  clear_has_state();
+}
+inline const ::bgs::protocol::club::v1::ClubMembershipState& SubscribeResponse::state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.SubscribeResponse.state)
+  return state_ != NULL ? *state_ : *default_instance_->state_;
+}
+inline ::bgs::protocol::club::v1::ClubMembershipState* SubscribeResponse::mutable_state() {
+  set_has_state();
+  if (state_ == NULL) state_ = new ::bgs::protocol::club::v1::ClubMembershipState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.SubscribeResponse.state)
+  return state_;
+}
+inline ::bgs::protocol::club::v1::ClubMembershipState* SubscribeResponse::release_state() {
+  clear_has_state();
+  ::bgs::protocol::club::v1::ClubMembershipState* temp = state_;
+  state_ = NULL;
+  return temp;
+}
+inline void SubscribeResponse::set_allocated_state(::bgs::protocol::club::v1::ClubMembershipState* state) {
+  delete state_;
+  state_ = state;
+  if (state) {
+    set_has_state();
+  } else {
+    clear_has_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.SubscribeResponse.state)
+}
+
+// -------------------------------------------------------------------
+
+// UnsubscribeRequest
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool UnsubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& UnsubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.UnsubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* UnsubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.UnsubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* UnsubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeRequest::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.UnsubscribeRequest.agent_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetStateRequest
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool GetStateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetStateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetStateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetStateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& GetStateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.GetStateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* GetStateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.GetStateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* GetStateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetStateRequest::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.GetStateRequest.agent_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetStateResponse
+
+// optional .bgs.protocol.club.v1.ClubMembershipState state = 1;
+inline bool GetStateResponse::has_state() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetStateResponse::set_has_state() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetStateResponse::clear_has_state() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetStateResponse::clear_state() {
+  if (state_ != NULL) state_->::bgs::protocol::club::v1::ClubMembershipState::Clear();
+  clear_has_state();
+}
+inline const ::bgs::protocol::club::v1::ClubMembershipState& GetStateResponse::state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.GetStateResponse.state)
+  return state_ != NULL ? *state_ : *default_instance_->state_;
+}
+inline ::bgs::protocol::club::v1::ClubMembershipState* GetStateResponse::mutable_state() {
+  set_has_state();
+  if (state_ == NULL) state_ = new ::bgs::protocol::club::v1::ClubMembershipState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.GetStateResponse.state)
+  return state_;
+}
+inline ::bgs::protocol::club::v1::ClubMembershipState* GetStateResponse::release_state() {
+  clear_has_state();
+  ::bgs::protocol::club::v1::ClubMembershipState* temp = state_;
+  state_ = NULL;
+  return temp;
+}
+inline void GetStateResponse::set_allocated_state(::bgs::protocol::club::v1::ClubMembershipState* state) {
+  delete state_;
+  state_ = state;
+  if (state) {
+    set_has_state();
+  } else {
+    clear_has_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.GetStateResponse.state)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateClubSharedSettingsRequest
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool UpdateClubSharedSettingsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateClubSharedSettingsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateClubSharedSettingsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateClubSharedSettingsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& UpdateClubSharedSettingsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* UpdateClubSharedSettingsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* UpdateClubSharedSettingsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateClubSharedSettingsRequest::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubSharedSettingsOptions options = 2;
+inline bool UpdateClubSharedSettingsRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateClubSharedSettingsRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateClubSharedSettingsRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateClubSharedSettingsRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::ClubSharedSettingsOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::ClubSharedSettingsOptions& UpdateClubSharedSettingsRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::ClubSharedSettingsOptions* UpdateClubSharedSettingsRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::ClubSharedSettingsOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::ClubSharedSettingsOptions* UpdateClubSharedSettingsRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::ClubSharedSettingsOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void UpdateClubSharedSettingsRequest::set_allocated_options(::bgs::protocol::club::v1::ClubSharedSettingsOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.UpdateClubSharedSettingsRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamMentionsRequest
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool GetStreamMentionsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetStreamMentionsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetStreamMentionsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetStreamMentionsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& GetStreamMentionsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.GetStreamMentionsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* GetStreamMentionsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.GetStreamMentionsRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* GetStreamMentionsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetStreamMentionsRequest::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.GetStreamMentionsRequest.agent_id)
+}
+
+// optional .bgs.protocol.GetEventOptions options = 2;
+inline bool GetStreamMentionsRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetStreamMentionsRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetStreamMentionsRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetStreamMentionsRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::GetEventOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::GetEventOptions& GetStreamMentionsRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.GetStreamMentionsRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::GetEventOptions* GetStreamMentionsRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::GetEventOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.GetStreamMentionsRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::GetEventOptions* GetStreamMentionsRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::GetEventOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void GetStreamMentionsRequest::set_allocated_options(::bgs::protocol::GetEventOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.GetStreamMentionsRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamMentionsResponse
+
+// repeated .bgs.protocol.club.v1.StreamMention mention = 1;
+inline int GetStreamMentionsResponse::mention_size() const {
+  return mention_.size();
+}
+inline void GetStreamMentionsResponse::clear_mention() {
+  mention_.Clear();
+}
+inline const ::bgs::protocol::club::v1::StreamMention& GetStreamMentionsResponse::mention(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.GetStreamMentionsResponse.mention)
+  return mention_.Get(index);
+}
+inline ::bgs::protocol::club::v1::StreamMention* GetStreamMentionsResponse::mutable_mention(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.GetStreamMentionsResponse.mention)
+  return mention_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::StreamMention* GetStreamMentionsResponse::add_mention() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.membership.GetStreamMentionsResponse.mention)
+  return mention_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMention >&
+GetStreamMentionsResponse::mention() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.membership.GetStreamMentionsResponse.mention)
+  return mention_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMention >*
+GetStreamMentionsResponse::mutable_mention() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.membership.GetStreamMentionsResponse.mention)
+  return &mention_;
+}
+
+// optional uint64 continuation = 2;
+inline bool GetStreamMentionsResponse::has_continuation() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetStreamMentionsResponse::set_has_continuation() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetStreamMentionsResponse::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetStreamMentionsResponse::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetStreamMentionsResponse::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.GetStreamMentionsResponse.continuation)
+  return continuation_;
+}
+inline void GetStreamMentionsResponse::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.membership.GetStreamMentionsResponse.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// RemoveStreamMentionsRequest
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool RemoveStreamMentionsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RemoveStreamMentionsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RemoveStreamMentionsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RemoveStreamMentionsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& RemoveStreamMentionsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* RemoveStreamMentionsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* RemoveStreamMentionsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void RemoveStreamMentionsRequest::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest.agent_id)
+}
+
+// repeated .bgs.protocol.TimeSeriesId mention_id = 2;
+inline int RemoveStreamMentionsRequest::mention_id_size() const {
+  return mention_id_.size();
+}
+inline void RemoveStreamMentionsRequest::clear_mention_id() {
+  mention_id_.Clear();
+}
+inline const ::bgs::protocol::TimeSeriesId& RemoveStreamMentionsRequest::mention_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest.mention_id)
+  return mention_id_.Get(index);
+}
+inline ::bgs::protocol::TimeSeriesId* RemoveStreamMentionsRequest::mutable_mention_id(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest.mention_id)
+  return mention_id_.Mutable(index);
+}
+inline ::bgs::protocol::TimeSeriesId* RemoveStreamMentionsRequest::add_mention_id() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest.mention_id)
+  return mention_id_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::TimeSeriesId >&
+RemoveStreamMentionsRequest::mention_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest.mention_id)
+  return mention_id_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::TimeSeriesId >*
+RemoveStreamMentionsRequest::mutable_mention_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.membership.RemoveStreamMentionsRequest.mention_id)
+  return &mention_id_;
+}
+
+// -------------------------------------------------------------------
+
+// AdvanceStreamMentionViewTimeRequest
+
+// optional .bgs.protocol.account.v1.AccountId agent_id = 1;
+inline bool AdvanceStreamMentionViewTimeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AdvanceStreamMentionViewTimeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AdvanceStreamMentionViewTimeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AdvanceStreamMentionViewTimeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& AdvanceStreamMentionViewTimeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* AdvanceStreamMentionViewTimeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* AdvanceStreamMentionViewTimeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::account::v1::AccountId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AdvanceStreamMentionViewTimeRequest::set_allocated_agent_id(::bgs::protocol::account::v1::AccountId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.membership.AdvanceStreamMentionViewTimeRequest.agent_id)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace membership
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5fmembership_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_membership_types.pb.cc b/src/server/proto/Client/club_membership_types.pb.cc
new file mode 100644
index 00000000000..6bf2e595cd4
--- /dev/null
+++ b/src/server/proto/Client/club_membership_types.pb.cc
@@ -0,0 +1,1813 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_membership_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_membership_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ClubMembershipDescription_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubMembershipDescription_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubMembershipState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubMembershipState_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubPosition_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubPosition_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubSharedSettings_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubSharedSettings_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubSharedSettingsOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubSharedSettingsOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubSharedSettingsAssignment_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubSharedSettingsAssignment_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5fmembership_5ftypes_2eproto() {
+  protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_membership_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  ClubMembershipDescription_descriptor_ = file->message_type(0);
+  static const int ClubMembershipDescription_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipDescription, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipDescription, club_),
+  };
+  ClubMembershipDescription_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubMembershipDescription_descriptor_,
+      ClubMembershipDescription::default_instance_,
+      ClubMembershipDescription_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipDescription, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipDescription, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubMembershipDescription));
+  ClubMembershipState_descriptor_ = file->message_type(1);
+  static const int ClubMembershipState_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipState, description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipState, invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipState, setting_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipState, mention_view_),
+  };
+  ClubMembershipState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubMembershipState_descriptor_,
+      ClubMembershipState::default_instance_,
+      ClubMembershipState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMembershipState, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubMembershipState));
+  ClubPosition_descriptor_ = file->message_type(2);
+  static const int ClubPosition_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPosition, club_id_),
+  };
+  ClubPosition_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubPosition_descriptor_,
+      ClubPosition::default_instance_,
+      ClubPosition_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPosition, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPosition, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubPosition));
+  ClubSharedSettings_descriptor_ = file->message_type(3);
+  static const int ClubSharedSettings_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSharedSettings, club_position_),
+  };
+  ClubSharedSettings_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubSharedSettings_descriptor_,
+      ClubSharedSettings::default_instance_,
+      ClubSharedSettings_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSharedSettings, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSharedSettings, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubSharedSettings));
+  ClubSharedSettingsOptions_descriptor_ = file->message_type(4);
+  static const int ClubSharedSettingsOptions_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSharedSettingsOptions, club_position_),
+  };
+  ClubSharedSettingsOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubSharedSettingsOptions_descriptor_,
+      ClubSharedSettingsOptions::default_instance_,
+      ClubSharedSettingsOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSharedSettingsOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSharedSettingsOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubSharedSettingsOptions));
+  ClubSharedSettingsAssignment_descriptor_ = file->message_type(5);
+  static const int ClubSharedSettingsAssignment_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSharedSettingsAssignment, club_position_),
+  };
+  ClubSharedSettingsAssignment_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubSharedSettingsAssignment_descriptor_,
+      ClubSharedSettingsAssignment::default_instance_,
+      ClubSharedSettingsAssignment_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSharedSettingsAssignment, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSharedSettingsAssignment, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubSharedSettingsAssignment));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5fmembership_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubMembershipDescription_descriptor_, &ClubMembershipDescription::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubMembershipState_descriptor_, &ClubMembershipState::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubPosition_descriptor_, &ClubPosition::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubSharedSettings_descriptor_, &ClubSharedSettings::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubSharedSettingsOptions_descriptor_, &ClubSharedSettingsOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubSharedSettingsAssignment_descriptor_, &ClubSharedSettingsAssignment::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5fmembership_5ftypes_2eproto() {
+  delete ClubMembershipDescription::default_instance_;
+  delete ClubMembershipDescription_reflection_;
+  delete ClubMembershipState::default_instance_;
+  delete ClubMembershipState_reflection_;
+  delete ClubPosition::default_instance_;
+  delete ClubPosition_reflection_;
+  delete ClubSharedSettings::default_instance_;
+  delete ClubSharedSettings_reflection_;
+  delete ClubSharedSettingsOptions::default_instance_;
+  delete ClubSharedSettingsOptions_reflection_;
+  delete ClubSharedSettingsAssignment::default_instance_;
+  delete ClubSharedSettingsAssignment_reflection_;
+}
+
+void protobuf_AddDesc_club_5fmembership_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fcore_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fmember_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5finvitation_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\033club_membership_types.proto\022\024bgs.proto"
+    "col.club.v1\032\017club_core.proto\032\021club_membe"
+    "r.proto\032\025club_invitation.proto\032\026event_vi"
+    "ew_types.proto\"\203\001\n\031ClubMembershipDescrip"
+    "tion\0221\n\tmember_id\030\001 \001(\0132\036.bgs.protocol.c"
+    "lub.v1.MemberId\0223\n\004club\030\002 \001(\0132%.bgs.prot"
+    "ocol.club.v1.ClubDescription\"\200\002\n\023ClubMem"
+    "bershipState\022D\n\013description\030\001 \003(\0132/.bgs."
+    "protocol.club.v1.ClubMembershipDescripti"
+    "on\0228\n\ninvitation\030\002 \003(\0132$.bgs.protocol.cl"
+    "ub.v1.ClubInvitation\0229\n\007setting\030\003 \001(\0132(."
+    "bgs.protocol.club.v1.ClubSharedSettings\022"
+    ".\n\014mention_view\030\004 \001(\0132\030.bgs.protocol.Vie"
+    "wMarker\"#\n\014ClubPosition\022\023\n\007club_id\030\001 \003(\004"
+    "B\002\020\001\"O\n\022ClubSharedSettings\0229\n\rclub_posit"
+    "ion\030\001 \001(\0132\".bgs.protocol.club.v1.ClubPos"
+    "ition\"V\n\031ClubSharedSettingsOptions\0229\n\rcl"
+    "ub_position\030\001 \001(\0132\".bgs.protocol.club.v1"
+    ".ClubPosition\"Y\n\034ClubSharedSettingsAssig"
+    "nment\0229\n\rclub_position\030\001 \001(\0132\".bgs.proto"
+    "col.club.v1.ClubPositionB\002H\001", 828);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_membership_types.proto", &protobuf_RegisterTypes);
+  ClubMembershipDescription::default_instance_ = new ClubMembershipDescription();
+  ClubMembershipState::default_instance_ = new ClubMembershipState();
+  ClubPosition::default_instance_ = new ClubPosition();
+  ClubSharedSettings::default_instance_ = new ClubSharedSettings();
+  ClubSharedSettingsOptions::default_instance_ = new ClubSharedSettingsOptions();
+  ClubSharedSettingsAssignment::default_instance_ = new ClubSharedSettingsAssignment();
+  ClubMembershipDescription::default_instance_->InitAsDefaultInstance();
+  ClubMembershipState::default_instance_->InitAsDefaultInstance();
+  ClubPosition::default_instance_->InitAsDefaultInstance();
+  ClubSharedSettings::default_instance_->InitAsDefaultInstance();
+  ClubSharedSettingsOptions::default_instance_->InitAsDefaultInstance();
+  ClubSharedSettingsAssignment::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5fmembership_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5fmembership_5ftypes_2eproto {
+  StaticDescriptorInitializer_club_5fmembership_5ftypes_2eproto() {
+    protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_club_5fmembership_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubMembershipDescription::kMemberIdFieldNumber;
+const int ClubMembershipDescription::kClubFieldNumber;
+#endif  // !_MSC_VER
+
+ClubMembershipDescription::ClubMembershipDescription()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubMembershipDescription)
+}
+
+void ClubMembershipDescription::InitAsDefaultInstance() {
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  club_ = const_cast< ::bgs::protocol::club::v1::ClubDescription*>(&::bgs::protocol::club::v1::ClubDescription::default_instance());
+}
+
+ClubMembershipDescription::ClubMembershipDescription(const ClubMembershipDescription& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubMembershipDescription)
+}
+
+void ClubMembershipDescription::SharedCtor() {
+  _cached_size_ = 0;
+  member_id_ = NULL;
+  club_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubMembershipDescription::~ClubMembershipDescription() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubMembershipDescription)
+  SharedDtor();
+}
+
+void ClubMembershipDescription::SharedDtor() {
+  if (this != default_instance_) {
+    delete member_id_;
+    delete club_;
+  }
+}
+
+void ClubMembershipDescription::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubMembershipDescription::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubMembershipDescription_descriptor_;
+}
+
+const ClubMembershipDescription& ClubMembershipDescription::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ClubMembershipDescription* ClubMembershipDescription::default_instance_ = NULL;
+
+ClubMembershipDescription* ClubMembershipDescription::New() const {
+  return new ClubMembershipDescription;
+}
+
+void ClubMembershipDescription::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_club()) {
+      if (club_ != NULL) club_->::bgs::protocol::club::v1::ClubDescription::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubMembershipDescription::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubMembershipDescription)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_club;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubDescription club = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_club:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_club()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubMembershipDescription)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubMembershipDescription)
+  return false;
+#undef DO_
+}
+
+void ClubMembershipDescription::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubMembershipDescription)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->member_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 2;
+  if (has_club()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->club(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubMembershipDescription)
+}
+
+::google::protobuf::uint8* ClubMembershipDescription::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubMembershipDescription)
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->member_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 2;
+  if (has_club()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->club(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubMembershipDescription)
+  return target;
+}
+
+int ClubMembershipDescription::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubDescription club = 2;
+    if (has_club()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->club());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubMembershipDescription::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubMembershipDescription* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubMembershipDescription*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubMembershipDescription::MergeFrom(const ClubMembershipDescription& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+    if (from.has_club()) {
+      mutable_club()->::bgs::protocol::club::v1::ClubDescription::MergeFrom(from.club());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubMembershipDescription::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubMembershipDescription::CopyFrom(const ClubMembershipDescription& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubMembershipDescription::IsInitialized() const {
+
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  if (has_club()) {
+    if (!this->club().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubMembershipDescription::Swap(ClubMembershipDescription* other) {
+  if (other != this) {
+    std::swap(member_id_, other->member_id_);
+    std::swap(club_, other->club_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubMembershipDescription::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubMembershipDescription_descriptor_;
+  metadata.reflection = ClubMembershipDescription_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubMembershipState::kDescriptionFieldNumber;
+const int ClubMembershipState::kInvitationFieldNumber;
+const int ClubMembershipState::kSettingFieldNumber;
+const int ClubMembershipState::kMentionViewFieldNumber;
+#endif  // !_MSC_VER
+
+ClubMembershipState::ClubMembershipState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubMembershipState)
+}
+
+void ClubMembershipState::InitAsDefaultInstance() {
+  setting_ = const_cast< ::bgs::protocol::club::v1::ClubSharedSettings*>(&::bgs::protocol::club::v1::ClubSharedSettings::default_instance());
+  mention_view_ = const_cast< ::bgs::protocol::ViewMarker*>(&::bgs::protocol::ViewMarker::default_instance());
+}
+
+ClubMembershipState::ClubMembershipState(const ClubMembershipState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubMembershipState)
+}
+
+void ClubMembershipState::SharedCtor() {
+  _cached_size_ = 0;
+  setting_ = NULL;
+  mention_view_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubMembershipState::~ClubMembershipState() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubMembershipState)
+  SharedDtor();
+}
+
+void ClubMembershipState::SharedDtor() {
+  if (this != default_instance_) {
+    delete setting_;
+    delete mention_view_;
+  }
+}
+
+void ClubMembershipState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubMembershipState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubMembershipState_descriptor_;
+}
+
+const ClubMembershipState& ClubMembershipState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ClubMembershipState* ClubMembershipState::default_instance_ = NULL;
+
+ClubMembershipState* ClubMembershipState::New() const {
+  return new ClubMembershipState;
+}
+
+void ClubMembershipState::Clear() {
+  if (_has_bits_[0 / 32] & 12) {
+    if (has_setting()) {
+      if (setting_ != NULL) setting_->::bgs::protocol::club::v1::ClubSharedSettings::Clear();
+    }
+    if (has_mention_view()) {
+      if (mention_view_ != NULL) mention_view_->::bgs::protocol::ViewMarker::Clear();
+    }
+  }
+  description_.Clear();
+  invitation_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubMembershipState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubMembershipState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.ClubMembershipDescription description = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_description()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_description;
+        if (input->ExpectTag(18)) goto parse_invitation;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_invitation:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_invitation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_invitation;
+        if (input->ExpectTag(26)) goto parse_setting;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSharedSettings setting = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_setting:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_setting()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_mention_view;
+        break;
+      }
+
+      // optional .bgs.protocol.ViewMarker mention_view = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_mention_view:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_mention_view()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubMembershipState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubMembershipState)
+  return false;
+#undef DO_
+}
+
+void ClubMembershipState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubMembershipState)
+  // repeated .bgs.protocol.club.v1.ClubMembershipDescription description = 1;
+  for (int i = 0; i < this->description_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->description(i), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 2;
+  for (int i = 0; i < this->invitation_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->invitation(i), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSharedSettings setting = 3;
+  if (has_setting()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->setting(), output);
+  }
+
+  // optional .bgs.protocol.ViewMarker mention_view = 4;
+  if (has_mention_view()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->mention_view(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubMembershipState)
+}
+
+::google::protobuf::uint8* ClubMembershipState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubMembershipState)
+  // repeated .bgs.protocol.club.v1.ClubMembershipDescription description = 1;
+  for (int i = 0; i < this->description_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->description(i), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 2;
+  for (int i = 0; i < this->invitation_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->invitation(i), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSharedSettings setting = 3;
+  if (has_setting()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->setting(), target);
+  }
+
+  // optional .bgs.protocol.ViewMarker mention_view = 4;
+  if (has_mention_view()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->mention_view(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubMembershipState)
+  return target;
+}
+
+int ClubMembershipState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[2 / 32] & (0xffu << (2 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubSharedSettings setting = 3;
+    if (has_setting()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->setting());
+    }
+
+    // optional .bgs.protocol.ViewMarker mention_view = 4;
+    if (has_mention_view()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->mention_view());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.ClubMembershipDescription description = 1;
+  total_size += 1 * this->description_size();
+  for (int i = 0; i < this->description_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->description(i));
+  }
+
+  // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 2;
+  total_size += 1 * this->invitation_size();
+  for (int i = 0; i < this->invitation_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->invitation(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubMembershipState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubMembershipState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubMembershipState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubMembershipState::MergeFrom(const ClubMembershipState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  description_.MergeFrom(from.description_);
+  invitation_.MergeFrom(from.invitation_);
+  if (from._has_bits_[2 / 32] & (0xffu << (2 % 32))) {
+    if (from.has_setting()) {
+      mutable_setting()->::bgs::protocol::club::v1::ClubSharedSettings::MergeFrom(from.setting());
+    }
+    if (from.has_mention_view()) {
+      mutable_mention_view()->::bgs::protocol::ViewMarker::MergeFrom(from.mention_view());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubMembershipState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubMembershipState::CopyFrom(const ClubMembershipState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubMembershipState::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->description())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->invitation())) return false;
+  return true;
+}
+
+void ClubMembershipState::Swap(ClubMembershipState* other) {
+  if (other != this) {
+    description_.Swap(&other->description_);
+    invitation_.Swap(&other->invitation_);
+    std::swap(setting_, other->setting_);
+    std::swap(mention_view_, other->mention_view_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubMembershipState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubMembershipState_descriptor_;
+  metadata.reflection = ClubMembershipState_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubPosition::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+ClubPosition::ClubPosition()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubPosition)
+}
+
+void ClubPosition::InitAsDefaultInstance() {
+}
+
+ClubPosition::ClubPosition(const ClubPosition& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubPosition)
+}
+
+void ClubPosition::SharedCtor() {
+  _cached_size_ = 0;
+  _club_id_cached_byte_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubPosition::~ClubPosition() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubPosition)
+  SharedDtor();
+}
+
+void ClubPosition::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ClubPosition::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubPosition::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubPosition_descriptor_;
+}
+
+const ClubPosition& ClubPosition::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ClubPosition* ClubPosition::default_instance_ = NULL;
+
+ClubPosition* ClubPosition::New() const {
+  return new ClubPosition;
+}
+
+void ClubPosition::Clear() {
+  club_id_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubPosition::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubPosition)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated uint64 club_id = 1 [packed = true];
+      case 1: {
+        if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, this->mutable_club_id())));
+        } else if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 1, 10, input, this->mutable_club_id())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubPosition)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubPosition)
+  return false;
+#undef DO_
+}
+
+void ClubPosition::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubPosition)
+  // repeated uint64 club_id = 1 [packed = true];
+  if (this->club_id_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_club_id_cached_byte_size_);
+  }
+  for (int i = 0; i < this->club_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64NoTag(
+      this->club_id(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubPosition)
+}
+
+::google::protobuf::uint8* ClubPosition::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubPosition)
+  // repeated uint64 club_id = 1 [packed = true];
+  if (this->club_id_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      1,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _club_id_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->club_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt64NoTagToArray(this->club_id(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubPosition)
+  return target;
+}
+
+int ClubPosition::ByteSize() const {
+  int total_size = 0;
+
+  // repeated uint64 club_id = 1 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->club_id_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt64Size(this->club_id(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _club_id_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubPosition::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubPosition* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubPosition*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubPosition::MergeFrom(const ClubPosition& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  club_id_.MergeFrom(from.club_id_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubPosition::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubPosition::CopyFrom(const ClubPosition& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubPosition::IsInitialized() const {
+
+  return true;
+}
+
+void ClubPosition::Swap(ClubPosition* other) {
+  if (other != this) {
+    club_id_.Swap(&other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubPosition::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubPosition_descriptor_;
+  metadata.reflection = ClubPosition_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubSharedSettings::kClubPositionFieldNumber;
+#endif  // !_MSC_VER
+
+ClubSharedSettings::ClubSharedSettings()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubSharedSettings)
+}
+
+void ClubSharedSettings::InitAsDefaultInstance() {
+  club_position_ = const_cast< ::bgs::protocol::club::v1::ClubPosition*>(&::bgs::protocol::club::v1::ClubPosition::default_instance());
+}
+
+ClubSharedSettings::ClubSharedSettings(const ClubSharedSettings& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubSharedSettings)
+}
+
+void ClubSharedSettings::SharedCtor() {
+  _cached_size_ = 0;
+  club_position_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubSharedSettings::~ClubSharedSettings() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubSharedSettings)
+  SharedDtor();
+}
+
+void ClubSharedSettings::SharedDtor() {
+  if (this != default_instance_) {
+    delete club_position_;
+  }
+}
+
+void ClubSharedSettings::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubSharedSettings::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSharedSettings_descriptor_;
+}
+
+const ClubSharedSettings& ClubSharedSettings::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ClubSharedSettings* ClubSharedSettings::default_instance_ = NULL;
+
+ClubSharedSettings* ClubSharedSettings::New() const {
+  return new ClubSharedSettings;
+}
+
+void ClubSharedSettings::Clear() {
+  if (has_club_position()) {
+    if (club_position_ != NULL) club_position_->::bgs::protocol::club::v1::ClubPosition::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubSharedSettings::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubSharedSettings)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_club_position()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubSharedSettings)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubSharedSettings)
+  return false;
+#undef DO_
+}
+
+void ClubSharedSettings::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubSharedSettings)
+  // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+  if (has_club_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->club_position(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubSharedSettings)
+}
+
+::google::protobuf::uint8* ClubSharedSettings::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubSharedSettings)
+  // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+  if (has_club_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->club_position(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubSharedSettings)
+  return target;
+}
+
+int ClubSharedSettings::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+    if (has_club_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->club_position());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubSharedSettings::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubSharedSettings* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubSharedSettings*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubSharedSettings::MergeFrom(const ClubSharedSettings& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_position()) {
+      mutable_club_position()->::bgs::protocol::club::v1::ClubPosition::MergeFrom(from.club_position());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubSharedSettings::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubSharedSettings::CopyFrom(const ClubSharedSettings& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubSharedSettings::IsInitialized() const {
+
+  return true;
+}
+
+void ClubSharedSettings::Swap(ClubSharedSettings* other) {
+  if (other != this) {
+    std::swap(club_position_, other->club_position_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubSharedSettings::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubSharedSettings_descriptor_;
+  metadata.reflection = ClubSharedSettings_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubSharedSettingsOptions::kClubPositionFieldNumber;
+#endif  // !_MSC_VER
+
+ClubSharedSettingsOptions::ClubSharedSettingsOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+}
+
+void ClubSharedSettingsOptions::InitAsDefaultInstance() {
+  club_position_ = const_cast< ::bgs::protocol::club::v1::ClubPosition*>(&::bgs::protocol::club::v1::ClubPosition::default_instance());
+}
+
+ClubSharedSettingsOptions::ClubSharedSettingsOptions(const ClubSharedSettingsOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+}
+
+void ClubSharedSettingsOptions::SharedCtor() {
+  _cached_size_ = 0;
+  club_position_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubSharedSettingsOptions::~ClubSharedSettingsOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+  SharedDtor();
+}
+
+void ClubSharedSettingsOptions::SharedDtor() {
+  if (this != default_instance_) {
+    delete club_position_;
+  }
+}
+
+void ClubSharedSettingsOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubSharedSettingsOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSharedSettingsOptions_descriptor_;
+}
+
+const ClubSharedSettingsOptions& ClubSharedSettingsOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ClubSharedSettingsOptions* ClubSharedSettingsOptions::default_instance_ = NULL;
+
+ClubSharedSettingsOptions* ClubSharedSettingsOptions::New() const {
+  return new ClubSharedSettingsOptions;
+}
+
+void ClubSharedSettingsOptions::Clear() {
+  if (has_club_position()) {
+    if (club_position_ != NULL) club_position_->::bgs::protocol::club::v1::ClubPosition::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubSharedSettingsOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_club_position()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+  return false;
+#undef DO_
+}
+
+void ClubSharedSettingsOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+  // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+  if (has_club_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->club_position(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+}
+
+::google::protobuf::uint8* ClubSharedSettingsOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+  // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+  if (has_club_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->club_position(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+  return target;
+}
+
+int ClubSharedSettingsOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+    if (has_club_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->club_position());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubSharedSettingsOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubSharedSettingsOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubSharedSettingsOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubSharedSettingsOptions::MergeFrom(const ClubSharedSettingsOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_position()) {
+      mutable_club_position()->::bgs::protocol::club::v1::ClubPosition::MergeFrom(from.club_position());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubSharedSettingsOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubSharedSettingsOptions::CopyFrom(const ClubSharedSettingsOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubSharedSettingsOptions::IsInitialized() const {
+
+  return true;
+}
+
+void ClubSharedSettingsOptions::Swap(ClubSharedSettingsOptions* other) {
+  if (other != this) {
+    std::swap(club_position_, other->club_position_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubSharedSettingsOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubSharedSettingsOptions_descriptor_;
+  metadata.reflection = ClubSharedSettingsOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubSharedSettingsAssignment::kClubPositionFieldNumber;
+#endif  // !_MSC_VER
+
+ClubSharedSettingsAssignment::ClubSharedSettingsAssignment()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+}
+
+void ClubSharedSettingsAssignment::InitAsDefaultInstance() {
+  club_position_ = const_cast< ::bgs::protocol::club::v1::ClubPosition*>(&::bgs::protocol::club::v1::ClubPosition::default_instance());
+}
+
+ClubSharedSettingsAssignment::ClubSharedSettingsAssignment(const ClubSharedSettingsAssignment& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+}
+
+void ClubSharedSettingsAssignment::SharedCtor() {
+  _cached_size_ = 0;
+  club_position_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubSharedSettingsAssignment::~ClubSharedSettingsAssignment() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+  SharedDtor();
+}
+
+void ClubSharedSettingsAssignment::SharedDtor() {
+  if (this != default_instance_) {
+    delete club_position_;
+  }
+}
+
+void ClubSharedSettingsAssignment::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubSharedSettingsAssignment::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSharedSettingsAssignment_descriptor_;
+}
+
+const ClubSharedSettingsAssignment& ClubSharedSettingsAssignment::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ClubSharedSettingsAssignment* ClubSharedSettingsAssignment::default_instance_ = NULL;
+
+ClubSharedSettingsAssignment* ClubSharedSettingsAssignment::New() const {
+  return new ClubSharedSettingsAssignment;
+}
+
+void ClubSharedSettingsAssignment::Clear() {
+  if (has_club_position()) {
+    if (club_position_ != NULL) club_position_->::bgs::protocol::club::v1::ClubPosition::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubSharedSettingsAssignment::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_club_position()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+  return false;
+#undef DO_
+}
+
+void ClubSharedSettingsAssignment::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+  // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+  if (has_club_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->club_position(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+}
+
+::google::protobuf::uint8* ClubSharedSettingsAssignment::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+  // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+  if (has_club_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->club_position(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+  return target;
+}
+
+int ClubSharedSettingsAssignment::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+    if (has_club_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->club_position());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubSharedSettingsAssignment::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubSharedSettingsAssignment* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubSharedSettingsAssignment*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubSharedSettingsAssignment::MergeFrom(const ClubSharedSettingsAssignment& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_position()) {
+      mutable_club_position()->::bgs::protocol::club::v1::ClubPosition::MergeFrom(from.club_position());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubSharedSettingsAssignment::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubSharedSettingsAssignment::CopyFrom(const ClubSharedSettingsAssignment& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubSharedSettingsAssignment::IsInitialized() const {
+
+  return true;
+}
+
+void ClubSharedSettingsAssignment::Swap(ClubSharedSettingsAssignment* other) {
+  if (other != this) {
+    std::swap(club_position_, other->club_position_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubSharedSettingsAssignment::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubSharedSettingsAssignment_descriptor_;
+  metadata.reflection = ClubSharedSettingsAssignment_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_membership_types.pb.h b/src/server/proto/Client/club_membership_types.pb.h
new file mode 100644
index 00000000000..ef7197b1dc1
--- /dev/null
+++ b/src/server/proto/Client/club_membership_types.pb.h
@@ -0,0 +1,1015 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_membership_types.proto
+
+#ifndef PROTOBUF_club_5fmembership_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_club_5fmembership_5ftypes_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "club_core.pb.h"
+#include "club_member.pb.h"
+#include "club_invitation.pb.h"
+#include "event_view_types.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+void protobuf_AssignDesc_club_5fmembership_5ftypes_2eproto();
+void protobuf_ShutdownFile_club_5fmembership_5ftypes_2eproto();
+
+class ClubMembershipDescription;
+class ClubMembershipState;
+class ClubPosition;
+class ClubSharedSettings;
+class ClubSharedSettingsOptions;
+class ClubSharedSettingsAssignment;
+
+// ===================================================================
+
+class TC_PROTO_API ClubMembershipDescription : public ::google::protobuf::Message {
+ public:
+  ClubMembershipDescription();
+  virtual ~ClubMembershipDescription();
+
+  ClubMembershipDescription(const ClubMembershipDescription& from);
+
+  inline ClubMembershipDescription& operator=(const ClubMembershipDescription& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubMembershipDescription& default_instance();
+
+  void Swap(ClubMembershipDescription* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubMembershipDescription* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubMembershipDescription& from);
+  void MergeFrom(const ClubMembershipDescription& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 1;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 2;
+  inline bool has_club() const;
+  inline void clear_club();
+  static const int kClubFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::ClubDescription& club() const;
+  inline ::bgs::protocol::club::v1::ClubDescription* mutable_club();
+  inline ::bgs::protocol::club::v1::ClubDescription* release_club();
+  inline void set_allocated_club(::bgs::protocol::club::v1::ClubDescription* club);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubMembershipDescription)
+ private:
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+  inline void set_has_club();
+  inline void clear_has_club();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  ::bgs::protocol::club::v1::ClubDescription* club_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubMembershipDescription* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubMembershipState : public ::google::protobuf::Message {
+ public:
+  ClubMembershipState();
+  virtual ~ClubMembershipState();
+
+  ClubMembershipState(const ClubMembershipState& from);
+
+  inline ClubMembershipState& operator=(const ClubMembershipState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubMembershipState& default_instance();
+
+  void Swap(ClubMembershipState* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubMembershipState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubMembershipState& from);
+  void MergeFrom(const ClubMembershipState& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.ClubMembershipDescription description = 1;
+  inline int description_size() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubMembershipDescription& description(int index) const;
+  inline ::bgs::protocol::club::v1::ClubMembershipDescription* mutable_description(int index);
+  inline ::bgs::protocol::club::v1::ClubMembershipDescription* add_description();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubMembershipDescription >&
+      description() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubMembershipDescription >*
+      mutable_description();
+
+  // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 2;
+  inline int invitation_size() const;
+  inline void clear_invitation();
+  static const int kInvitationFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::ClubInvitation& invitation(int index) const;
+  inline ::bgs::protocol::club::v1::ClubInvitation* mutable_invitation(int index);
+  inline ::bgs::protocol::club::v1::ClubInvitation* add_invitation();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation >&
+      invitation() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation >*
+      mutable_invitation();
+
+  // optional .bgs.protocol.club.v1.ClubSharedSettings setting = 3;
+  inline bool has_setting() const;
+  inline void clear_setting();
+  static const int kSettingFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::ClubSharedSettings& setting() const;
+  inline ::bgs::protocol::club::v1::ClubSharedSettings* mutable_setting();
+  inline ::bgs::protocol::club::v1::ClubSharedSettings* release_setting();
+  inline void set_allocated_setting(::bgs::protocol::club::v1::ClubSharedSettings* setting);
+
+  // optional .bgs.protocol.ViewMarker mention_view = 4;
+  inline bool has_mention_view() const;
+  inline void clear_mention_view();
+  static const int kMentionViewFieldNumber = 4;
+  inline const ::bgs::protocol::ViewMarker& mention_view() const;
+  inline ::bgs::protocol::ViewMarker* mutable_mention_view();
+  inline ::bgs::protocol::ViewMarker* release_mention_view();
+  inline void set_allocated_mention_view(::bgs::protocol::ViewMarker* mention_view);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubMembershipState)
+ private:
+  inline void set_has_setting();
+  inline void clear_has_setting();
+  inline void set_has_mention_view();
+  inline void clear_has_mention_view();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubMembershipDescription > description_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation > invitation_;
+  ::bgs::protocol::club::v1::ClubSharedSettings* setting_;
+  ::bgs::protocol::ViewMarker* mention_view_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubMembershipState* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubPosition : public ::google::protobuf::Message {
+ public:
+  ClubPosition();
+  virtual ~ClubPosition();
+
+  ClubPosition(const ClubPosition& from);
+
+  inline ClubPosition& operator=(const ClubPosition& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubPosition& default_instance();
+
+  void Swap(ClubPosition* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubPosition* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubPosition& from);
+  void MergeFrom(const ClubPosition& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated uint64 club_id = 1 [packed = true];
+  inline int club_id_size() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 club_id(int index) const;
+  inline void set_club_id(int index, ::google::protobuf::uint64 value);
+  inline void add_club_id(::google::protobuf::uint64 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+      club_id() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+      mutable_club_id();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubPosition)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > club_id_;
+  mutable int _club_id_cached_byte_size_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubPosition* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubSharedSettings : public ::google::protobuf::Message {
+ public:
+  ClubSharedSettings();
+  virtual ~ClubSharedSettings();
+
+  ClubSharedSettings(const ClubSharedSettings& from);
+
+  inline ClubSharedSettings& operator=(const ClubSharedSettings& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubSharedSettings& default_instance();
+
+  void Swap(ClubSharedSettings* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubSharedSettings* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubSharedSettings& from);
+  void MergeFrom(const ClubSharedSettings& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+  inline bool has_club_position() const;
+  inline void clear_club_position();
+  static const int kClubPositionFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubPosition& club_position() const;
+  inline ::bgs::protocol::club::v1::ClubPosition* mutable_club_position();
+  inline ::bgs::protocol::club::v1::ClubPosition* release_club_position();
+  inline void set_allocated_club_position(::bgs::protocol::club::v1::ClubPosition* club_position);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubSharedSettings)
+ private:
+  inline void set_has_club_position();
+  inline void clear_has_club_position();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubPosition* club_position_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubSharedSettings* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubSharedSettingsOptions : public ::google::protobuf::Message {
+ public:
+  ClubSharedSettingsOptions();
+  virtual ~ClubSharedSettingsOptions();
+
+  ClubSharedSettingsOptions(const ClubSharedSettingsOptions& from);
+
+  inline ClubSharedSettingsOptions& operator=(const ClubSharedSettingsOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubSharedSettingsOptions& default_instance();
+
+  void Swap(ClubSharedSettingsOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubSharedSettingsOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubSharedSettingsOptions& from);
+  void MergeFrom(const ClubSharedSettingsOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+  inline bool has_club_position() const;
+  inline void clear_club_position();
+  static const int kClubPositionFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubPosition& club_position() const;
+  inline ::bgs::protocol::club::v1::ClubPosition* mutable_club_position();
+  inline ::bgs::protocol::club::v1::ClubPosition* release_club_position();
+  inline void set_allocated_club_position(::bgs::protocol::club::v1::ClubPosition* club_position);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubSharedSettingsOptions)
+ private:
+  inline void set_has_club_position();
+  inline void clear_has_club_position();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubPosition* club_position_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubSharedSettingsOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubSharedSettingsAssignment : public ::google::protobuf::Message {
+ public:
+  ClubSharedSettingsAssignment();
+  virtual ~ClubSharedSettingsAssignment();
+
+  ClubSharedSettingsAssignment(const ClubSharedSettingsAssignment& from);
+
+  inline ClubSharedSettingsAssignment& operator=(const ClubSharedSettingsAssignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubSharedSettingsAssignment& default_instance();
+
+  void Swap(ClubSharedSettingsAssignment* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubSharedSettingsAssignment* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubSharedSettingsAssignment& from);
+  void MergeFrom(const ClubSharedSettingsAssignment& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+  inline bool has_club_position() const;
+  inline void clear_club_position();
+  static const int kClubPositionFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubPosition& club_position() const;
+  inline ::bgs::protocol::club::v1::ClubPosition* mutable_club_position();
+  inline ::bgs::protocol::club::v1::ClubPosition* release_club_position();
+  inline void set_allocated_club_position(::bgs::protocol::club::v1::ClubPosition* club_position);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubSharedSettingsAssignment)
+ private:
+  inline void set_has_club_position();
+  inline void clear_has_club_position();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubPosition* club_position_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_club_5fmembership_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_club_5fmembership_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubSharedSettingsAssignment* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ClubMembershipDescription
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 1;
+inline bool ClubMembershipDescription::has_member_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubMembershipDescription::set_has_member_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubMembershipDescription::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubMembershipDescription::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& ClubMembershipDescription::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMembershipDescription.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubMembershipDescription::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMembershipDescription.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubMembershipDescription::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void ClubMembershipDescription::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubMembershipDescription.member_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubDescription club = 2;
+inline bool ClubMembershipDescription::has_club() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubMembershipDescription::set_has_club() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubMembershipDescription::clear_has_club() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubMembershipDescription::clear_club() {
+  if (club_ != NULL) club_->::bgs::protocol::club::v1::ClubDescription::Clear();
+  clear_has_club();
+}
+inline const ::bgs::protocol::club::v1::ClubDescription& ClubMembershipDescription::club() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMembershipDescription.club)
+  return club_ != NULL ? *club_ : *default_instance_->club_;
+}
+inline ::bgs::protocol::club::v1::ClubDescription* ClubMembershipDescription::mutable_club() {
+  set_has_club();
+  if (club_ == NULL) club_ = new ::bgs::protocol::club::v1::ClubDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMembershipDescription.club)
+  return club_;
+}
+inline ::bgs::protocol::club::v1::ClubDescription* ClubMembershipDescription::release_club() {
+  clear_has_club();
+  ::bgs::protocol::club::v1::ClubDescription* temp = club_;
+  club_ = NULL;
+  return temp;
+}
+inline void ClubMembershipDescription::set_allocated_club(::bgs::protocol::club::v1::ClubDescription* club) {
+  delete club_;
+  club_ = club;
+  if (club) {
+    set_has_club();
+  } else {
+    clear_has_club();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubMembershipDescription.club)
+}
+
+// -------------------------------------------------------------------
+
+// ClubMembershipState
+
+// repeated .bgs.protocol.club.v1.ClubMembershipDescription description = 1;
+inline int ClubMembershipState::description_size() const {
+  return description_.size();
+}
+inline void ClubMembershipState::clear_description() {
+  description_.Clear();
+}
+inline const ::bgs::protocol::club::v1::ClubMembershipDescription& ClubMembershipState::description(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMembershipState.description)
+  return description_.Get(index);
+}
+inline ::bgs::protocol::club::v1::ClubMembershipDescription* ClubMembershipState::mutable_description(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMembershipState.description)
+  return description_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::ClubMembershipDescription* ClubMembershipState::add_description() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubMembershipState.description)
+  return description_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubMembershipDescription >&
+ClubMembershipState::description() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubMembershipState.description)
+  return description_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubMembershipDescription >*
+ClubMembershipState::mutable_description() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubMembershipState.description)
+  return &description_;
+}
+
+// repeated .bgs.protocol.club.v1.ClubInvitation invitation = 2;
+inline int ClubMembershipState::invitation_size() const {
+  return invitation_.size();
+}
+inline void ClubMembershipState::clear_invitation() {
+  invitation_.Clear();
+}
+inline const ::bgs::protocol::club::v1::ClubInvitation& ClubMembershipState::invitation(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMembershipState.invitation)
+  return invitation_.Get(index);
+}
+inline ::bgs::protocol::club::v1::ClubInvitation* ClubMembershipState::mutable_invitation(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMembershipState.invitation)
+  return invitation_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::ClubInvitation* ClubMembershipState::add_invitation() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubMembershipState.invitation)
+  return invitation_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation >&
+ClubMembershipState::invitation() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubMembershipState.invitation)
+  return invitation_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation >*
+ClubMembershipState::mutable_invitation() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubMembershipState.invitation)
+  return &invitation_;
+}
+
+// optional .bgs.protocol.club.v1.ClubSharedSettings setting = 3;
+inline bool ClubMembershipState::has_setting() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubMembershipState::set_has_setting() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubMembershipState::clear_has_setting() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubMembershipState::clear_setting() {
+  if (setting_ != NULL) setting_->::bgs::protocol::club::v1::ClubSharedSettings::Clear();
+  clear_has_setting();
+}
+inline const ::bgs::protocol::club::v1::ClubSharedSettings& ClubMembershipState::setting() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMembershipState.setting)
+  return setting_ != NULL ? *setting_ : *default_instance_->setting_;
+}
+inline ::bgs::protocol::club::v1::ClubSharedSettings* ClubMembershipState::mutable_setting() {
+  set_has_setting();
+  if (setting_ == NULL) setting_ = new ::bgs::protocol::club::v1::ClubSharedSettings;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMembershipState.setting)
+  return setting_;
+}
+inline ::bgs::protocol::club::v1::ClubSharedSettings* ClubMembershipState::release_setting() {
+  clear_has_setting();
+  ::bgs::protocol::club::v1::ClubSharedSettings* temp = setting_;
+  setting_ = NULL;
+  return temp;
+}
+inline void ClubMembershipState::set_allocated_setting(::bgs::protocol::club::v1::ClubSharedSettings* setting) {
+  delete setting_;
+  setting_ = setting;
+  if (setting) {
+    set_has_setting();
+  } else {
+    clear_has_setting();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubMembershipState.setting)
+}
+
+// optional .bgs.protocol.ViewMarker mention_view = 4;
+inline bool ClubMembershipState::has_mention_view() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubMembershipState::set_has_mention_view() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubMembershipState::clear_has_mention_view() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubMembershipState::clear_mention_view() {
+  if (mention_view_ != NULL) mention_view_->::bgs::protocol::ViewMarker::Clear();
+  clear_has_mention_view();
+}
+inline const ::bgs::protocol::ViewMarker& ClubMembershipState::mention_view() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMembershipState.mention_view)
+  return mention_view_ != NULL ? *mention_view_ : *default_instance_->mention_view_;
+}
+inline ::bgs::protocol::ViewMarker* ClubMembershipState::mutable_mention_view() {
+  set_has_mention_view();
+  if (mention_view_ == NULL) mention_view_ = new ::bgs::protocol::ViewMarker;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMembershipState.mention_view)
+  return mention_view_;
+}
+inline ::bgs::protocol::ViewMarker* ClubMembershipState::release_mention_view() {
+  clear_has_mention_view();
+  ::bgs::protocol::ViewMarker* temp = mention_view_;
+  mention_view_ = NULL;
+  return temp;
+}
+inline void ClubMembershipState::set_allocated_mention_view(::bgs::protocol::ViewMarker* mention_view) {
+  delete mention_view_;
+  mention_view_ = mention_view;
+  if (mention_view) {
+    set_has_mention_view();
+  } else {
+    clear_has_mention_view();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubMembershipState.mention_view)
+}
+
+// -------------------------------------------------------------------
+
+// ClubPosition
+
+// repeated uint64 club_id = 1 [packed = true];
+inline int ClubPosition::club_id_size() const {
+  return club_id_.size();
+}
+inline void ClubPosition::clear_club_id() {
+  club_id_.Clear();
+}
+inline ::google::protobuf::uint64 ClubPosition::club_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPosition.club_id)
+  return club_id_.Get(index);
+}
+inline void ClubPosition::set_club_id(int index, ::google::protobuf::uint64 value) {
+  club_id_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPosition.club_id)
+}
+inline void ClubPosition::add_club_id(::google::protobuf::uint64 value) {
+  club_id_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubPosition.club_id)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+ClubPosition::club_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubPosition.club_id)
+  return club_id_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+ClubPosition::mutable_club_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubPosition.club_id)
+  return &club_id_;
+}
+
+// -------------------------------------------------------------------
+
+// ClubSharedSettings
+
+// optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+inline bool ClubSharedSettings::has_club_position() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubSharedSettings::set_has_club_position() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubSharedSettings::clear_has_club_position() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubSharedSettings::clear_club_position() {
+  if (club_position_ != NULL) club_position_->::bgs::protocol::club::v1::ClubPosition::Clear();
+  clear_has_club_position();
+}
+inline const ::bgs::protocol::club::v1::ClubPosition& ClubSharedSettings::club_position() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSharedSettings.club_position)
+  return club_position_ != NULL ? *club_position_ : *default_instance_->club_position_;
+}
+inline ::bgs::protocol::club::v1::ClubPosition* ClubSharedSettings::mutable_club_position() {
+  set_has_club_position();
+  if (club_position_ == NULL) club_position_ = new ::bgs::protocol::club::v1::ClubPosition;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSharedSettings.club_position)
+  return club_position_;
+}
+inline ::bgs::protocol::club::v1::ClubPosition* ClubSharedSettings::release_club_position() {
+  clear_has_club_position();
+  ::bgs::protocol::club::v1::ClubPosition* temp = club_position_;
+  club_position_ = NULL;
+  return temp;
+}
+inline void ClubSharedSettings::set_allocated_club_position(::bgs::protocol::club::v1::ClubPosition* club_position) {
+  delete club_position_;
+  club_position_ = club_position;
+  if (club_position) {
+    set_has_club_position();
+  } else {
+    clear_has_club_position();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubSharedSettings.club_position)
+}
+
+// -------------------------------------------------------------------
+
+// ClubSharedSettingsOptions
+
+// optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+inline bool ClubSharedSettingsOptions::has_club_position() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubSharedSettingsOptions::set_has_club_position() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubSharedSettingsOptions::clear_has_club_position() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubSharedSettingsOptions::clear_club_position() {
+  if (club_position_ != NULL) club_position_->::bgs::protocol::club::v1::ClubPosition::Clear();
+  clear_has_club_position();
+}
+inline const ::bgs::protocol::club::v1::ClubPosition& ClubSharedSettingsOptions::club_position() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSharedSettingsOptions.club_position)
+  return club_position_ != NULL ? *club_position_ : *default_instance_->club_position_;
+}
+inline ::bgs::protocol::club::v1::ClubPosition* ClubSharedSettingsOptions::mutable_club_position() {
+  set_has_club_position();
+  if (club_position_ == NULL) club_position_ = new ::bgs::protocol::club::v1::ClubPosition;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSharedSettingsOptions.club_position)
+  return club_position_;
+}
+inline ::bgs::protocol::club::v1::ClubPosition* ClubSharedSettingsOptions::release_club_position() {
+  clear_has_club_position();
+  ::bgs::protocol::club::v1::ClubPosition* temp = club_position_;
+  club_position_ = NULL;
+  return temp;
+}
+inline void ClubSharedSettingsOptions::set_allocated_club_position(::bgs::protocol::club::v1::ClubPosition* club_position) {
+  delete club_position_;
+  club_position_ = club_position;
+  if (club_position) {
+    set_has_club_position();
+  } else {
+    clear_has_club_position();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubSharedSettingsOptions.club_position)
+}
+
+// -------------------------------------------------------------------
+
+// ClubSharedSettingsAssignment
+
+// optional .bgs.protocol.club.v1.ClubPosition club_position = 1;
+inline bool ClubSharedSettingsAssignment::has_club_position() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubSharedSettingsAssignment::set_has_club_position() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubSharedSettingsAssignment::clear_has_club_position() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubSharedSettingsAssignment::clear_club_position() {
+  if (club_position_ != NULL) club_position_->::bgs::protocol::club::v1::ClubPosition::Clear();
+  clear_has_club_position();
+}
+inline const ::bgs::protocol::club::v1::ClubPosition& ClubSharedSettingsAssignment::club_position() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSharedSettingsAssignment.club_position)
+  return club_position_ != NULL ? *club_position_ : *default_instance_->club_position_;
+}
+inline ::bgs::protocol::club::v1::ClubPosition* ClubSharedSettingsAssignment::mutable_club_position() {
+  set_has_club_position();
+  if (club_position_ == NULL) club_position_ = new ::bgs::protocol::club::v1::ClubPosition;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSharedSettingsAssignment.club_position)
+  return club_position_;
+}
+inline ::bgs::protocol::club::v1::ClubPosition* ClubSharedSettingsAssignment::release_club_position() {
+  clear_has_club_position();
+  ::bgs::protocol::club::v1::ClubPosition* temp = club_position_;
+  club_position_ = NULL;
+  return temp;
+}
+inline void ClubSharedSettingsAssignment::set_allocated_club_position(::bgs::protocol::club::v1::ClubPosition* club_position) {
+  delete club_position_;
+  club_position_ = club_position;
+  if (club_position) {
+    set_has_club_position();
+  } else {
+    clear_has_club_position();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubSharedSettingsAssignment.club_position)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5fmembership_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_notification.pb.cc b/src/server/proto/Client/club_notification.pb.cc
new file mode 100644
index 00000000000..e2581bb9c02
--- /dev/null
+++ b/src/server/proto/Client/club_notification.pb.cc
@@ -0,0 +1,8282 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_notification.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_notification.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* SubscribeNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnsubscribeNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsubscribeNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StateChangedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StateChangedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SettingsChangedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SettingsChangedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberRemovedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberStateChangedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberStateChangedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscriberStateChangedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscriberStateChangedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberRoleChangedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberRoleChangedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SuggestionAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SuggestionAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SuggestionRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SuggestionRemovedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamRemovedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamStateChangedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamStateChangedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamMessageAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamMessageAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamMessageUpdatedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamMessageUpdatedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamTypingIndicatorNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamTypingIndicatorNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamUnreadIndicatorNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamUnreadIndicatorNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamAdvanceViewTimeNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamAdvanceViewTimeNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubActivityNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubActivityNotification_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5fnotification_2eproto() {
+  protobuf_AddDesc_club_5fnotification_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_notification.proto");
+  GOOGLE_CHECK(file != NULL);
+  SubscribeNotification_descriptor_ = file->message_type(0);
+  static const int SubscribeNotification_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, club_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, view_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, settings_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, member_),
+  };
+  SubscribeNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeNotification_descriptor_,
+      SubscribeNotification::default_instance_,
+      SubscribeNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeNotification));
+  UnsubscribeNotification_descriptor_ = file->message_type(1);
+  static const int UnsubscribeNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeNotification, club_id_),
+  };
+  UnsubscribeNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsubscribeNotification_descriptor_,
+      UnsubscribeNotification::default_instance_,
+      UnsubscribeNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsubscribeNotification));
+  StateChangedNotification_descriptor_ = file->message_type(2);
+  static const int StateChangedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, assignment_),
+  };
+  StateChangedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StateChangedNotification_descriptor_,
+      StateChangedNotification::default_instance_,
+      StateChangedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StateChangedNotification));
+  SettingsChangedNotification_descriptor_ = file->message_type(3);
+  static const int SettingsChangedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SettingsChangedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SettingsChangedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SettingsChangedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SettingsChangedNotification, assignment_),
+  };
+  SettingsChangedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SettingsChangedNotification_descriptor_,
+      SettingsChangedNotification::default_instance_,
+      SettingsChangedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SettingsChangedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SettingsChangedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SettingsChangedNotification));
+  MemberAddedNotification_descriptor_ = file->message_type(4);
+  static const int MemberAddedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, member_),
+  };
+  MemberAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberAddedNotification_descriptor_,
+      MemberAddedNotification::default_instance_,
+      MemberAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberAddedNotification));
+  MemberRemovedNotification_descriptor_ = file->message_type(5);
+  static const int MemberRemovedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, member_),
+  };
+  MemberRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberRemovedNotification_descriptor_,
+      MemberRemovedNotification::default_instance_,
+      MemberRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberRemovedNotification));
+  MemberStateChangedNotification_descriptor_ = file->message_type(6);
+  static const int MemberStateChangedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateChangedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateChangedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateChangedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateChangedNotification, assignment_),
+  };
+  MemberStateChangedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberStateChangedNotification_descriptor_,
+      MemberStateChangedNotification::default_instance_,
+      MemberStateChangedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateChangedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberStateChangedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberStateChangedNotification));
+  SubscriberStateChangedNotification_descriptor_ = file->message_type(7);
+  static const int SubscriberStateChangedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateChangedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateChangedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateChangedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateChangedNotification, assignment_),
+  };
+  SubscriberStateChangedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscriberStateChangedNotification_descriptor_,
+      SubscriberStateChangedNotification::default_instance_,
+      SubscriberStateChangedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateChangedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberStateChangedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscriberStateChangedNotification));
+  MemberRoleChangedNotification_descriptor_ = file->message_type(8);
+  static const int MemberRoleChangedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRoleChangedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRoleChangedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRoleChangedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRoleChangedNotification, assignment_),
+  };
+  MemberRoleChangedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberRoleChangedNotification_descriptor_,
+      MemberRoleChangedNotification::default_instance_,
+      MemberRoleChangedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRoleChangedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRoleChangedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberRoleChangedNotification));
+  SuggestionAddedNotification_descriptor_ = file->message_type(9);
+  static const int SuggestionAddedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionAddedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionAddedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionAddedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionAddedNotification, suggestion_),
+  };
+  SuggestionAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SuggestionAddedNotification_descriptor_,
+      SuggestionAddedNotification::default_instance_,
+      SuggestionAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SuggestionAddedNotification));
+  SuggestionRemovedNotification_descriptor_ = file->message_type(10);
+  static const int SuggestionRemovedNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionRemovedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionRemovedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionRemovedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionRemovedNotification, suggestion_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionRemovedNotification, reason_),
+  };
+  SuggestionRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SuggestionRemovedNotification_descriptor_,
+      SuggestionRemovedNotification::default_instance_,
+      SuggestionRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SuggestionRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SuggestionRemovedNotification));
+  StreamAddedNotification_descriptor_ = file->message_type(11);
+  static const int StreamAddedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAddedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAddedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAddedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAddedNotification, stream_),
+  };
+  StreamAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamAddedNotification_descriptor_,
+      StreamAddedNotification::default_instance_,
+      StreamAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamAddedNotification));
+  StreamRemovedNotification_descriptor_ = file->message_type(12);
+  static const int StreamRemovedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamRemovedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamRemovedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamRemovedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamRemovedNotification, stream_id_),
+  };
+  StreamRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamRemovedNotification_descriptor_,
+      StreamRemovedNotification::default_instance_,
+      StreamRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamRemovedNotification));
+  StreamStateChangedNotification_descriptor_ = file->message_type(13);
+  static const int StreamStateChangedNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateChangedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateChangedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateChangedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateChangedNotification, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateChangedNotification, assignment_),
+  };
+  StreamStateChangedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamStateChangedNotification_descriptor_,
+      StreamStateChangedNotification::default_instance_,
+      StreamStateChangedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateChangedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateChangedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamStateChangedNotification));
+  StreamMessageAddedNotification_descriptor_ = file->message_type(14);
+  static const int StreamMessageAddedNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageAddedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageAddedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageAddedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageAddedNotification, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageAddedNotification, message_),
+  };
+  StreamMessageAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamMessageAddedNotification_descriptor_,
+      StreamMessageAddedNotification::default_instance_,
+      StreamMessageAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamMessageAddedNotification));
+  StreamMessageUpdatedNotification_descriptor_ = file->message_type(15);
+  static const int StreamMessageUpdatedNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageUpdatedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageUpdatedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageUpdatedNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageUpdatedNotification, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageUpdatedNotification, message_),
+  };
+  StreamMessageUpdatedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamMessageUpdatedNotification_descriptor_,
+      StreamMessageUpdatedNotification::default_instance_,
+      StreamMessageUpdatedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageUpdatedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessageUpdatedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamMessageUpdatedNotification));
+  StreamTypingIndicatorNotification_descriptor_ = file->message_type(16);
+  static const int StreamTypingIndicatorNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicatorNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicatorNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicatorNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicatorNotification, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicatorNotification, indicator_),
+  };
+  StreamTypingIndicatorNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamTypingIndicatorNotification_descriptor_,
+      StreamTypingIndicatorNotification::default_instance_,
+      StreamTypingIndicatorNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicatorNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicatorNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamTypingIndicatorNotification));
+  StreamUnreadIndicatorNotification_descriptor_ = file->message_type(17);
+  static const int StreamUnreadIndicatorNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamUnreadIndicatorNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamUnreadIndicatorNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamUnreadIndicatorNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamUnreadIndicatorNotification, event_),
+  };
+  StreamUnreadIndicatorNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamUnreadIndicatorNotification_descriptor_,
+      StreamUnreadIndicatorNotification::default_instance_,
+      StreamUnreadIndicatorNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamUnreadIndicatorNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamUnreadIndicatorNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamUnreadIndicatorNotification));
+  StreamAdvanceViewTimeNotification_descriptor_ = file->message_type(18);
+  static const int StreamAdvanceViewTimeNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTimeNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTimeNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTimeNotification, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTimeNotification, view_),
+  };
+  StreamAdvanceViewTimeNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamAdvanceViewTimeNotification_descriptor_,
+      StreamAdvanceViewTimeNotification::default_instance_,
+      StreamAdvanceViewTimeNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTimeNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTimeNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamAdvanceViewTimeNotification));
+  ClubActivityNotification_descriptor_ = file->message_type(19);
+  static const int ClubActivityNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubActivityNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubActivityNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubActivityNotification, club_id_),
+  };
+  ClubActivityNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubActivityNotification_descriptor_,
+      ClubActivityNotification::default_instance_,
+      ClubActivityNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubActivityNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubActivityNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubActivityNotification));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5fnotification_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeNotification_descriptor_, &SubscribeNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsubscribeNotification_descriptor_, &UnsubscribeNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StateChangedNotification_descriptor_, &StateChangedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SettingsChangedNotification_descriptor_, &SettingsChangedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberAddedNotification_descriptor_, &MemberAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberRemovedNotification_descriptor_, &MemberRemovedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberStateChangedNotification_descriptor_, &MemberStateChangedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscriberStateChangedNotification_descriptor_, &SubscriberStateChangedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberRoleChangedNotification_descriptor_, &MemberRoleChangedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SuggestionAddedNotification_descriptor_, &SuggestionAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SuggestionRemovedNotification_descriptor_, &SuggestionRemovedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamAddedNotification_descriptor_, &StreamAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamRemovedNotification_descriptor_, &StreamRemovedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamStateChangedNotification_descriptor_, &StreamStateChangedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamMessageAddedNotification_descriptor_, &StreamMessageAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamMessageUpdatedNotification_descriptor_, &StreamMessageUpdatedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamTypingIndicatorNotification_descriptor_, &StreamTypingIndicatorNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamUnreadIndicatorNotification_descriptor_, &StreamUnreadIndicatorNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamAdvanceViewTimeNotification_descriptor_, &StreamAdvanceViewTimeNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubActivityNotification_descriptor_, &ClubActivityNotification::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5fnotification_2eproto() {
+  delete SubscribeNotification::default_instance_;
+  delete SubscribeNotification_reflection_;
+  delete UnsubscribeNotification::default_instance_;
+  delete UnsubscribeNotification_reflection_;
+  delete StateChangedNotification::default_instance_;
+  delete StateChangedNotification_reflection_;
+  delete SettingsChangedNotification::default_instance_;
+  delete SettingsChangedNotification_reflection_;
+  delete MemberAddedNotification::default_instance_;
+  delete MemberAddedNotification_reflection_;
+  delete MemberRemovedNotification::default_instance_;
+  delete MemberRemovedNotification_reflection_;
+  delete MemberStateChangedNotification::default_instance_;
+  delete MemberStateChangedNotification_reflection_;
+  delete SubscriberStateChangedNotification::default_instance_;
+  delete SubscriberStateChangedNotification_reflection_;
+  delete MemberRoleChangedNotification::default_instance_;
+  delete MemberRoleChangedNotification_reflection_;
+  delete SuggestionAddedNotification::default_instance_;
+  delete SuggestionAddedNotification_reflection_;
+  delete SuggestionRemovedNotification::default_instance_;
+  delete SuggestionRemovedNotification_reflection_;
+  delete StreamAddedNotification::default_instance_;
+  delete StreamAddedNotification_reflection_;
+  delete StreamRemovedNotification::default_instance_;
+  delete StreamRemovedNotification_reflection_;
+  delete StreamStateChangedNotification::default_instance_;
+  delete StreamStateChangedNotification_reflection_;
+  delete StreamMessageAddedNotification::default_instance_;
+  delete StreamMessageAddedNotification_reflection_;
+  delete StreamMessageUpdatedNotification::default_instance_;
+  delete StreamMessageUpdatedNotification_reflection_;
+  delete StreamTypingIndicatorNotification::default_instance_;
+  delete StreamTypingIndicatorNotification_reflection_;
+  delete StreamUnreadIndicatorNotification::default_instance_;
+  delete StreamUnreadIndicatorNotification_reflection_;
+  delete StreamAdvanceViewTimeNotification::default_instance_;
+  delete StreamAdvanceViewTimeNotification_reflection_;
+  delete ClubActivityNotification::default_instance_;
+  delete ClubActivityNotification_reflection_;
+}
+
+void protobuf_AddDesc_club_5fnotification_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\027club_notification.proto\022\024bgs.protocol."
+    "club.v1\032\020club_types.proto\032\017rpc_types.pro"
+    "to\"\315\002\n\025SubscribeNotification\0220\n\010agent_id"
+    "\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId\0225"
+    "\n\rsubscriber_id\030\002 \001(\0132\036.bgs.protocol.clu"
+    "b.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\022(\n\004club\030\004"
+    " \001(\0132\032.bgs.protocol.club.v1.Club\022,\n\004view"
+    "\030\005 \001(\0132\036.bgs.protocol.club.v1.ClubView\0224"
+    "\n\010settings\030\n \001(\0132\".bgs.protocol.club.v1."
+    "ClubSettings\022,\n\006member\030\013 \001(\0132\034.bgs.proto"
+    "col.club.v1.Member\"\223\001\n\027UnsubscribeNotifi"
+    "cation\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol."
+    "club.v1.MemberId\0225\n\rsubscriber_id\030\002 \001(\0132"
+    "\036.bgs.protocol.club.v1.MemberId\022\017\n\007club_"
+    "id\030\003 \001(\004\"\323\001\n\030StateChangedNotification\0220\n"
+    "\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.M"
+    "emberId\0225\n\rsubscriber_id\030\002 \001(\0132\036.bgs.pro"
+    "tocol.club.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\022"
+    "=\n\nassignment\030\005 \001(\0132).bgs.protocol.club."
+    "v1.ClubStateAssignment\"\331\001\n\033SettingsChang"
+    "edNotification\0220\n\010agent_id\030\001 \001(\0132\036.bgs.p"
+    "rotocol.club.v1.MemberId\0225\n\rsubscriber_i"
+    "d\030\002 \001(\0132\036.bgs.protocol.club.v1.MemberId\022"
+    "\017\n\007club_id\030\003 \001(\004\022@\n\nassignment\030\004 \001(\0132,.b"
+    "gs.protocol.club.v1.ClubSettingsAssignme"
+    "nt\"\301\001\n\027MemberAddedNotification\0220\n\010agent_"
+    "id\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId"
+    "\0225\n\rsubscriber_id\030\002 \001(\0132\036.bgs.protocol.c"
+    "lub.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\022,\n\006memb"
+    "er\030\004 \003(\0132\034.bgs.protocol.club.v1.Member\"\324"
+    "\001\n\031MemberRemovedNotification\0220\n\010agent_id"
+    "\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId\0225"
+    "\n\rsubscriber_id\030\002 \001(\0132\036.bgs.protocol.clu"
+    "b.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\022=\n\006member"
+    "\030\004 \003(\0132-.bgs.protocol.club.v1.MemberRemo"
+    "vedAssignment\"\333\001\n\036MemberStateChangedNoti"
+    "fication\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protoco"
+    "l.club.v1.MemberId\0225\n\rsubscriber_id\030\002 \001("
+    "\0132\036.bgs.protocol.club.v1.MemberId\022\017\n\007clu"
+    "b_id\030\003 \001(\004\022\?\n\nassignment\030\004 \003(\0132+.bgs.pro"
+    "tocol.club.v1.MemberStateAssignment\"\343\001\n\""
+    "SubscriberStateChangedNotification\0220\n\010ag"
+    "ent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Memb"
+    "erId\0225\n\rsubscriber_id\030\002 \001(\0132\036.bgs.protoc"
+    "ol.club.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\022C\n\n"
+    "assignment\030\004 \003(\0132/.bgs.protocol.club.v1."
+    "SubscriberStateAssignment\"\323\001\n\035MemberRole"
+    "ChangedNotification\0220\n\010agent_id\030\001 \001(\0132\036."
+    "bgs.protocol.club.v1.MemberId\0225\n\rsubscri"
+    "ber_id\030\002 \001(\0132\036.bgs.protocol.club.v1.Memb"
+    "erId\022\017\n\007club_id\030\003 \001(\004\0228\n\nassignment\030\004 \003("
+    "\0132$.bgs.protocol.club.v1.RoleAssignment\""
+    "\321\001\n\033SuggestionAddedNotification\0220\n\010agent"
+    "_id\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberI"
+    "d\0225\n\rsubscriber_id\030\002 \001(\0132\036.bgs.protocol."
+    "club.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\0228\n\nsug"
+    "gestion\030\004 \002(\0132$.bgs.protocol.club.v1.Clu"
+    "bSuggestion\"\347\001\n\035SuggestionRemovedNotific"
+    "ation\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.c"
+    "lub.v1.MemberId\0225\n\rsubscriber_id\030\002 \001(\0132\036"
+    ".bgs.protocol.club.v1.MemberId\022\017\n\007club_i"
+    "d\030\003 \001(\004\022\025\n\rsuggestion_id\030\004 \001(\006\0225\n\006reason"
+    "\030\005 \001(\0162%.bgs.protocol.SuggestionRemovedR"
+    "eason\"\301\001\n\027StreamAddedNotification\0220\n\010age"
+    "nt_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Membe"
+    "rId\0225\n\rsubscriber_id\030\002 \001(\0132\036.bgs.protoco"
+    "l.club.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\022,\n\006s"
+    "tream\030\004 \001(\0132\034.bgs.protocol.club.v1.Strea"
+    "m\"\250\001\n\031StreamRemovedNotification\0220\n\010agent"
+    "_id\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberI"
+    "d\0225\n\rsubscriber_id\030\002 \001(\0132\036.bgs.protocol."
+    "club.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\022\021\n\tstr"
+    "eam_id\030\004 \001(\004\"\356\001\n\036StreamStateChangedNotif"
+    "ication\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol"
+    ".club.v1.MemberId\0225\n\rsubscriber_id\030\002 \001(\013"
+    "2\036.bgs.protocol.club.v1.MemberId\022\017\n\007club"
+    "_id\030\003 \001(\004\022\021\n\tstream_id\030\004 \001(\004\022\?\n\nassignme"
+    "nt\030\005 \001(\0132+.bgs.protocol.club.v1.StreamSt"
+    "ateAssignment\"\343\001\n\036StreamMessageAddedNoti"
+    "fication\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protoco"
+    "l.club.v1.MemberId\0225\n\rsubscriber_id\030\002 \001("
+    "\0132\036.bgs.protocol.club.v1.MemberId\022\017\n\007clu"
+    "b_id\030\003 \001(\004\022\021\n\tstream_id\030\004 \001(\004\0224\n\007message"
+    "\030\005 \001(\0132#.bgs.protocol.club.v1.StreamMess"
+    "age\"\345\001\n StreamMessageUpdatedNotification"
+    "\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v"
+    "1.MemberId\0225\n\rsubscriber_id\030\002 \001(\0132\036.bgs."
+    "protocol.club.v1.MemberId\022\017\n\007club_id\030\003 \001"
+    "(\004\022\021\n\tstream_id\030\004 \001(\004\0224\n\007message\030\005 \001(\0132#"
+    ".bgs.protocol.club.v1.StreamMessage\"\360\001\n!"
+    "StreamTypingIndicatorNotification\0220\n\010age"
+    "nt_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Membe"
+    "rId\0225\n\rsubscriber_id\030\002 \001(\0132\036.bgs.protoco"
+    "l.club.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\022\021\n\ts"
+    "tream_id\030\004 \001(\004\022>\n\tindicator\030\005 \003(\0132+.bgs."
+    "protocol.club.v1.StreamTypingIndicator\"\323"
+    "\001\n!StreamUnreadIndicatorNotification\0220\n\010"
+    "agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Me"
+    "mberId\0225\n\rsubscriber_id\030\002 \001(\0132\036.bgs.prot"
+    "ocol.club.v1.MemberId\022\017\n\007club_id\030\003 \001(\004\0224"
+    "\n\005event\030\004 \001(\0132%.bgs.protocol.club.v1.Str"
+    "eamEventTime\"\330\001\n!StreamAdvanceViewTimeNo"
+    "tification\0220\n\010agent_id\030\001 \001(\0132\036.bgs.proto"
+    "col.club.v1.MemberId\0225\n\rsubscriber_id\030\002 "
+    "\001(\0132\036.bgs.protocol.club.v1.MemberId\022\017\n\007c"
+    "lub_id\030\003 \001(\004\0229\n\004view\030\004 \003(\0132+.bgs.protoco"
+    "l.club.v1.StreamAdvanceViewTime\"\224\001\n\030Club"
+    "ActivityNotification\0220\n\010agent_id\030\001 \001(\0132\036"
+    ".bgs.protocol.club.v1.MemberId\0225\n\rsubscr"
+    "iber_id\030\002 \001(\0132\036.bgs.protocol.club.v1.Mem"
+    "berId\022\017\n\007club_id\030\003 \001(\004B\002H\001P\000P\001", 4430);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_notification.proto", &protobuf_RegisterTypes);
+  SubscribeNotification::default_instance_ = new SubscribeNotification();
+  UnsubscribeNotification::default_instance_ = new UnsubscribeNotification();
+  StateChangedNotification::default_instance_ = new StateChangedNotification();
+  SettingsChangedNotification::default_instance_ = new SettingsChangedNotification();
+  MemberAddedNotification::default_instance_ = new MemberAddedNotification();
+  MemberRemovedNotification::default_instance_ = new MemberRemovedNotification();
+  MemberStateChangedNotification::default_instance_ = new MemberStateChangedNotification();
+  SubscriberStateChangedNotification::default_instance_ = new SubscriberStateChangedNotification();
+  MemberRoleChangedNotification::default_instance_ = new MemberRoleChangedNotification();
+  SuggestionAddedNotification::default_instance_ = new SuggestionAddedNotification();
+  SuggestionRemovedNotification::default_instance_ = new SuggestionRemovedNotification();
+  StreamAddedNotification::default_instance_ = new StreamAddedNotification();
+  StreamRemovedNotification::default_instance_ = new StreamRemovedNotification();
+  StreamStateChangedNotification::default_instance_ = new StreamStateChangedNotification();
+  StreamMessageAddedNotification::default_instance_ = new StreamMessageAddedNotification();
+  StreamMessageUpdatedNotification::default_instance_ = new StreamMessageUpdatedNotification();
+  StreamTypingIndicatorNotification::default_instance_ = new StreamTypingIndicatorNotification();
+  StreamUnreadIndicatorNotification::default_instance_ = new StreamUnreadIndicatorNotification();
+  StreamAdvanceViewTimeNotification::default_instance_ = new StreamAdvanceViewTimeNotification();
+  ClubActivityNotification::default_instance_ = new ClubActivityNotification();
+  SubscribeNotification::default_instance_->InitAsDefaultInstance();
+  UnsubscribeNotification::default_instance_->InitAsDefaultInstance();
+  StateChangedNotification::default_instance_->InitAsDefaultInstance();
+  SettingsChangedNotification::default_instance_->InitAsDefaultInstance();
+  MemberAddedNotification::default_instance_->InitAsDefaultInstance();
+  MemberRemovedNotification::default_instance_->InitAsDefaultInstance();
+  MemberStateChangedNotification::default_instance_->InitAsDefaultInstance();
+  SubscriberStateChangedNotification::default_instance_->InitAsDefaultInstance();
+  MemberRoleChangedNotification::default_instance_->InitAsDefaultInstance();
+  SuggestionAddedNotification::default_instance_->InitAsDefaultInstance();
+  SuggestionRemovedNotification::default_instance_->InitAsDefaultInstance();
+  StreamAddedNotification::default_instance_->InitAsDefaultInstance();
+  StreamRemovedNotification::default_instance_->InitAsDefaultInstance();
+  StreamStateChangedNotification::default_instance_->InitAsDefaultInstance();
+  StreamMessageAddedNotification::default_instance_->InitAsDefaultInstance();
+  StreamMessageUpdatedNotification::default_instance_->InitAsDefaultInstance();
+  StreamTypingIndicatorNotification::default_instance_->InitAsDefaultInstance();
+  StreamUnreadIndicatorNotification::default_instance_->InitAsDefaultInstance();
+  StreamAdvanceViewTimeNotification::default_instance_->InitAsDefaultInstance();
+  ClubActivityNotification::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5fnotification_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5fnotification_2eproto {
+  StaticDescriptorInitializer_club_5fnotification_2eproto() {
+    protobuf_AddDesc_club_5fnotification_2eproto();
+  }
+} static_descriptor_initializer_club_5fnotification_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeNotification::kAgentIdFieldNumber;
+const int SubscribeNotification::kSubscriberIdFieldNumber;
+const int SubscribeNotification::kClubIdFieldNumber;
+const int SubscribeNotification::kClubFieldNumber;
+const int SubscribeNotification::kViewFieldNumber;
+const int SubscribeNotification::kSettingsFieldNumber;
+const int SubscribeNotification::kMemberFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeNotification::SubscribeNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SubscribeNotification)
+}
+
+void SubscribeNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  club_ = const_cast< ::bgs::protocol::club::v1::Club*>(&::bgs::protocol::club::v1::Club::default_instance());
+  view_ = const_cast< ::bgs::protocol::club::v1::ClubView*>(&::bgs::protocol::club::v1::ClubView::default_instance());
+  settings_ = const_cast< ::bgs::protocol::club::v1::ClubSettings*>(&::bgs::protocol::club::v1::ClubSettings::default_instance());
+  member_ = const_cast< ::bgs::protocol::club::v1::Member*>(&::bgs::protocol::club::v1::Member::default_instance());
+}
+
+SubscribeNotification::SubscribeNotification(const SubscribeNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SubscribeNotification)
+}
+
+void SubscribeNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  club_ = NULL;
+  view_ = NULL;
+  settings_ = NULL;
+  member_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeNotification::~SubscribeNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SubscribeNotification)
+  SharedDtor();
+}
+
+void SubscribeNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete club_;
+    delete view_;
+    delete settings_;
+    delete member_;
+  }
+}
+
+void SubscribeNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeNotification_descriptor_;
+}
+
+const SubscribeNotification& SubscribeNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+SubscribeNotification* SubscribeNotification::default_instance_ = NULL;
+
+SubscribeNotification* SubscribeNotification::New() const {
+  return new SubscribeNotification;
+}
+
+void SubscribeNotification::Clear() {
+  if (_has_bits_[0 / 32] & 127) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_club()) {
+      if (club_ != NULL) club_->::bgs::protocol::club::v1::Club::Clear();
+    }
+    if (has_view()) {
+      if (view_ != NULL) view_->::bgs::protocol::club::v1::ClubView::Clear();
+    }
+    if (has_settings()) {
+      if (settings_ != NULL) settings_->::bgs::protocol::club::v1::ClubSettings::Clear();
+    }
+    if (has_member()) {
+      if (member_ != NULL) member_->::bgs::protocol::club::v1::Member::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SubscribeNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_club;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.Club club = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_club:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_club()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_view;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubView view = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_view:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_view()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_settings;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSettings settings = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_settings:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_settings()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(90)) goto parse_member;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.Member member = 11;
+      case 11: {
+        if (tag == 90) {
+         parse_member:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SubscribeNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SubscribeNotification)
+  return false;
+#undef DO_
+}
+
+void SubscribeNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SubscribeNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.Club club = 4;
+  if (has_club()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->club(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubView view = 5;
+  if (has_view()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->view(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettings settings = 10;
+  if (has_settings()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->settings(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.Member member = 11;
+  if (has_member()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      11, this->member(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SubscribeNotification)
+}
+
+::google::protobuf::uint8* SubscribeNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SubscribeNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.Club club = 4;
+  if (has_club()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->club(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubView view = 5;
+  if (has_view()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->view(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettings settings = 10;
+  if (has_settings()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->settings(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.Member member = 11;
+  if (has_member()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        11, this->member(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SubscribeNotification)
+  return target;
+}
+
+int SubscribeNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.Club club = 4;
+    if (has_club()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->club());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubView view = 5;
+    if (has_view()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->view());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSettings settings = 10;
+    if (has_settings()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->settings());
+    }
+
+    // optional .bgs.protocol.club.v1.Member member = 11;
+    if (has_member()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeNotification::MergeFrom(const SubscribeNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_club()) {
+      mutable_club()->::bgs::protocol::club::v1::Club::MergeFrom(from.club());
+    }
+    if (from.has_view()) {
+      mutable_view()->::bgs::protocol::club::v1::ClubView::MergeFrom(from.view());
+    }
+    if (from.has_settings()) {
+      mutable_settings()->::bgs::protocol::club::v1::ClubSettings::MergeFrom(from.settings());
+    }
+    if (from.has_member()) {
+      mutable_member()->::bgs::protocol::club::v1::Member::MergeFrom(from.member());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeNotification::CopyFrom(const SubscribeNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (has_club()) {
+    if (!this->club().IsInitialized()) return false;
+  }
+  if (has_member()) {
+    if (!this->member().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscribeNotification::Swap(SubscribeNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(club_, other->club_);
+    std::swap(view_, other->view_);
+    std::swap(settings_, other->settings_);
+    std::swap(member_, other->member_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeNotification_descriptor_;
+  metadata.reflection = SubscribeNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsubscribeNotification::kAgentIdFieldNumber;
+const int UnsubscribeNotification::kSubscriberIdFieldNumber;
+const int UnsubscribeNotification::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+UnsubscribeNotification::UnsubscribeNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UnsubscribeNotification)
+}
+
+void UnsubscribeNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+UnsubscribeNotification::UnsubscribeNotification(const UnsubscribeNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UnsubscribeNotification)
+}
+
+void UnsubscribeNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsubscribeNotification::~UnsubscribeNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UnsubscribeNotification)
+  SharedDtor();
+}
+
+void UnsubscribeNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void UnsubscribeNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsubscribeNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsubscribeNotification_descriptor_;
+}
+
+const UnsubscribeNotification& UnsubscribeNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+UnsubscribeNotification* UnsubscribeNotification::default_instance_ = NULL;
+
+UnsubscribeNotification* UnsubscribeNotification::New() const {
+  return new UnsubscribeNotification;
+}
+
+void UnsubscribeNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsubscribeNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UnsubscribeNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UnsubscribeNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UnsubscribeNotification)
+  return false;
+#undef DO_
+}
+
+void UnsubscribeNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UnsubscribeNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UnsubscribeNotification)
+}
+
+::google::protobuf::uint8* UnsubscribeNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UnsubscribeNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UnsubscribeNotification)
+  return target;
+}
+
+int UnsubscribeNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsubscribeNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsubscribeNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsubscribeNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsubscribeNotification::MergeFrom(const UnsubscribeNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsubscribeNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsubscribeNotification::CopyFrom(const UnsubscribeNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsubscribeNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnsubscribeNotification::Swap(UnsubscribeNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsubscribeNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsubscribeNotification_descriptor_;
+  metadata.reflection = UnsubscribeNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StateChangedNotification::kAgentIdFieldNumber;
+const int StateChangedNotification::kSubscriberIdFieldNumber;
+const int StateChangedNotification::kClubIdFieldNumber;
+const int StateChangedNotification::kAssignmentFieldNumber;
+#endif  // !_MSC_VER
+
+StateChangedNotification::StateChangedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StateChangedNotification)
+}
+
+void StateChangedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  assignment_ = const_cast< ::bgs::protocol::club::v1::ClubStateAssignment*>(&::bgs::protocol::club::v1::ClubStateAssignment::default_instance());
+}
+
+StateChangedNotification::StateChangedNotification(const StateChangedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StateChangedNotification)
+}
+
+void StateChangedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  assignment_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StateChangedNotification::~StateChangedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StateChangedNotification)
+  SharedDtor();
+}
+
+void StateChangedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete assignment_;
+  }
+}
+
+void StateChangedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StateChangedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StateChangedNotification_descriptor_;
+}
+
+const StateChangedNotification& StateChangedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+StateChangedNotification* StateChangedNotification::default_instance_ = NULL;
+
+StateChangedNotification* StateChangedNotification::New() const {
+  return new StateChangedNotification;
+}
+
+void StateChangedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_assignment()) {
+      if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::ClubStateAssignment::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StateChangedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StateChangedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_assignment;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubStateAssignment assignment = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_assignment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_assignment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StateChangedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StateChangedNotification)
+  return false;
+#undef DO_
+}
+
+void StateChangedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StateChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubStateAssignment assignment = 5;
+  if (has_assignment()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->assignment(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StateChangedNotification)
+}
+
+::google::protobuf::uint8* StateChangedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StateChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubStateAssignment assignment = 5;
+  if (has_assignment()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->assignment(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StateChangedNotification)
+  return target;
+}
+
+int StateChangedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubStateAssignment assignment = 5;
+    if (has_assignment()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->assignment());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StateChangedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StateChangedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StateChangedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StateChangedNotification::MergeFrom(const StateChangedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_assignment()) {
+      mutable_assignment()->::bgs::protocol::club::v1::ClubStateAssignment::MergeFrom(from.assignment());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StateChangedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StateChangedNotification::CopyFrom(const StateChangedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StateChangedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (has_assignment()) {
+    if (!this->assignment().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StateChangedNotification::Swap(StateChangedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(assignment_, other->assignment_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StateChangedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StateChangedNotification_descriptor_;
+  metadata.reflection = StateChangedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SettingsChangedNotification::kAgentIdFieldNumber;
+const int SettingsChangedNotification::kSubscriberIdFieldNumber;
+const int SettingsChangedNotification::kClubIdFieldNumber;
+const int SettingsChangedNotification::kAssignmentFieldNumber;
+#endif  // !_MSC_VER
+
+SettingsChangedNotification::SettingsChangedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SettingsChangedNotification)
+}
+
+void SettingsChangedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  assignment_ = const_cast< ::bgs::protocol::club::v1::ClubSettingsAssignment*>(&::bgs::protocol::club::v1::ClubSettingsAssignment::default_instance());
+}
+
+SettingsChangedNotification::SettingsChangedNotification(const SettingsChangedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SettingsChangedNotification)
+}
+
+void SettingsChangedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  assignment_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SettingsChangedNotification::~SettingsChangedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SettingsChangedNotification)
+  SharedDtor();
+}
+
+void SettingsChangedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete assignment_;
+  }
+}
+
+void SettingsChangedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SettingsChangedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SettingsChangedNotification_descriptor_;
+}
+
+const SettingsChangedNotification& SettingsChangedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+SettingsChangedNotification* SettingsChangedNotification::default_instance_ = NULL;
+
+SettingsChangedNotification* SettingsChangedNotification::New() const {
+  return new SettingsChangedNotification;
+}
+
+void SettingsChangedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_assignment()) {
+      if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::ClubSettingsAssignment::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SettingsChangedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SettingsChangedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_assignment;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSettingsAssignment assignment = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_assignment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_assignment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SettingsChangedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SettingsChangedNotification)
+  return false;
+#undef DO_
+}
+
+void SettingsChangedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SettingsChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettingsAssignment assignment = 4;
+  if (has_assignment()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->assignment(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SettingsChangedNotification)
+}
+
+::google::protobuf::uint8* SettingsChangedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SettingsChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettingsAssignment assignment = 4;
+  if (has_assignment()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->assignment(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SettingsChangedNotification)
+  return target;
+}
+
+int SettingsChangedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSettingsAssignment assignment = 4;
+    if (has_assignment()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->assignment());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SettingsChangedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SettingsChangedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SettingsChangedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SettingsChangedNotification::MergeFrom(const SettingsChangedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_assignment()) {
+      mutable_assignment()->::bgs::protocol::club::v1::ClubSettingsAssignment::MergeFrom(from.assignment());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SettingsChangedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SettingsChangedNotification::CopyFrom(const SettingsChangedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SettingsChangedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SettingsChangedNotification::Swap(SettingsChangedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(assignment_, other->assignment_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SettingsChangedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SettingsChangedNotification_descriptor_;
+  metadata.reflection = SettingsChangedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberAddedNotification::kAgentIdFieldNumber;
+const int MemberAddedNotification::kSubscriberIdFieldNumber;
+const int MemberAddedNotification::kClubIdFieldNumber;
+const int MemberAddedNotification::kMemberFieldNumber;
+#endif  // !_MSC_VER
+
+MemberAddedNotification::MemberAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberAddedNotification)
+}
+
+void MemberAddedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+MemberAddedNotification::MemberAddedNotification(const MemberAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberAddedNotification)
+}
+
+void MemberAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberAddedNotification::~MemberAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberAddedNotification)
+  SharedDtor();
+}
+
+void MemberAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void MemberAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberAddedNotification_descriptor_;
+}
+
+const MemberAddedNotification& MemberAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+MemberAddedNotification* MemberAddedNotification::default_instance_ = NULL;
+
+MemberAddedNotification* MemberAddedNotification::New() const {
+  return new MemberAddedNotification;
+}
+
+void MemberAddedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  member_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_member;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.Member member = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_member:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_member;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberAddedNotification)
+  return false;
+#undef DO_
+}
+
+void MemberAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.Member member = 4;
+  for (int i = 0; i < this->member_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->member(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberAddedNotification)
+}
+
+::google::protobuf::uint8* MemberAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.Member member = 4;
+  for (int i = 0; i < this->member_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->member(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberAddedNotification)
+  return target;
+}
+
+int MemberAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.Member member = 4;
+  total_size += 1 * this->member_size();
+  for (int i = 0; i < this->member_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->member(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberAddedNotification::MergeFrom(const MemberAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  member_.MergeFrom(from.member_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberAddedNotification::CopyFrom(const MemberAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberAddedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->member())) return false;
+  return true;
+}
+
+void MemberAddedNotification::Swap(MemberAddedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    member_.Swap(&other->member_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberAddedNotification_descriptor_;
+  metadata.reflection = MemberAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberRemovedNotification::kAgentIdFieldNumber;
+const int MemberRemovedNotification::kSubscriberIdFieldNumber;
+const int MemberRemovedNotification::kClubIdFieldNumber;
+const int MemberRemovedNotification::kMemberFieldNumber;
+#endif  // !_MSC_VER
+
+MemberRemovedNotification::MemberRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberRemovedNotification)
+}
+
+void MemberRemovedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+MemberRemovedNotification::MemberRemovedNotification(const MemberRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberRemovedNotification)
+}
+
+void MemberRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberRemovedNotification::~MemberRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberRemovedNotification)
+  SharedDtor();
+}
+
+void MemberRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void MemberRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberRemovedNotification_descriptor_;
+}
+
+const MemberRemovedNotification& MemberRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+MemberRemovedNotification* MemberRemovedNotification::default_instance_ = NULL;
+
+MemberRemovedNotification* MemberRemovedNotification::New() const {
+  return new MemberRemovedNotification;
+}
+
+void MemberRemovedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  member_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_member;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.MemberRemovedAssignment member = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_member:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_member;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void MemberRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberRemovedAssignment member = 4;
+  for (int i = 0; i < this->member_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->member(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberRemovedNotification)
+}
+
+::google::protobuf::uint8* MemberRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberRemovedAssignment member = 4;
+  for (int i = 0; i < this->member_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->member(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberRemovedNotification)
+  return target;
+}
+
+int MemberRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.MemberRemovedAssignment member = 4;
+  total_size += 1 * this->member_size();
+  for (int i = 0; i < this->member_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->member(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberRemovedNotification::MergeFrom(const MemberRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  member_.MergeFrom(from.member_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberRemovedNotification::CopyFrom(const MemberRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberRemovedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->member())) return false;
+  return true;
+}
+
+void MemberRemovedNotification::Swap(MemberRemovedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    member_.Swap(&other->member_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberRemovedNotification_descriptor_;
+  metadata.reflection = MemberRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberStateChangedNotification::kAgentIdFieldNumber;
+const int MemberStateChangedNotification::kSubscriberIdFieldNumber;
+const int MemberStateChangedNotification::kClubIdFieldNumber;
+const int MemberStateChangedNotification::kAssignmentFieldNumber;
+#endif  // !_MSC_VER
+
+MemberStateChangedNotification::MemberStateChangedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberStateChangedNotification)
+}
+
+void MemberStateChangedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+MemberStateChangedNotification::MemberStateChangedNotification(const MemberStateChangedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberStateChangedNotification)
+}
+
+void MemberStateChangedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberStateChangedNotification::~MemberStateChangedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberStateChangedNotification)
+  SharedDtor();
+}
+
+void MemberStateChangedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void MemberStateChangedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberStateChangedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberStateChangedNotification_descriptor_;
+}
+
+const MemberStateChangedNotification& MemberStateChangedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+MemberStateChangedNotification* MemberStateChangedNotification::default_instance_ = NULL;
+
+MemberStateChangedNotification* MemberStateChangedNotification::New() const {
+  return new MemberStateChangedNotification;
+}
+
+void MemberStateChangedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  assignment_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberStateChangedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberStateChangedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_assignment;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.MemberStateAssignment assignment = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_assignment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_assignment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_assignment;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberStateChangedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberStateChangedNotification)
+  return false;
+#undef DO_
+}
+
+void MemberStateChangedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberStateChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberStateAssignment assignment = 4;
+  for (int i = 0; i < this->assignment_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->assignment(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberStateChangedNotification)
+}
+
+::google::protobuf::uint8* MemberStateChangedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberStateChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberStateAssignment assignment = 4;
+  for (int i = 0; i < this->assignment_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->assignment(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberStateChangedNotification)
+  return target;
+}
+
+int MemberStateChangedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.MemberStateAssignment assignment = 4;
+  total_size += 1 * this->assignment_size();
+  for (int i = 0; i < this->assignment_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->assignment(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberStateChangedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberStateChangedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberStateChangedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberStateChangedNotification::MergeFrom(const MemberStateChangedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  assignment_.MergeFrom(from.assignment_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberStateChangedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberStateChangedNotification::CopyFrom(const MemberStateChangedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberStateChangedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->assignment())) return false;
+  return true;
+}
+
+void MemberStateChangedNotification::Swap(MemberStateChangedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    assignment_.Swap(&other->assignment_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberStateChangedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberStateChangedNotification_descriptor_;
+  metadata.reflection = MemberStateChangedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscriberStateChangedNotification::kAgentIdFieldNumber;
+const int SubscriberStateChangedNotification::kSubscriberIdFieldNumber;
+const int SubscriberStateChangedNotification::kClubIdFieldNumber;
+const int SubscriberStateChangedNotification::kAssignmentFieldNumber;
+#endif  // !_MSC_VER
+
+SubscriberStateChangedNotification::SubscriberStateChangedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+}
+
+void SubscriberStateChangedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+SubscriberStateChangedNotification::SubscriberStateChangedNotification(const SubscriberStateChangedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+}
+
+void SubscriberStateChangedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscriberStateChangedNotification::~SubscriberStateChangedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+  SharedDtor();
+}
+
+void SubscriberStateChangedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void SubscriberStateChangedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscriberStateChangedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscriberStateChangedNotification_descriptor_;
+}
+
+const SubscriberStateChangedNotification& SubscriberStateChangedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+SubscriberStateChangedNotification* SubscriberStateChangedNotification::default_instance_ = NULL;
+
+SubscriberStateChangedNotification* SubscriberStateChangedNotification::New() const {
+  return new SubscriberStateChangedNotification;
+}
+
+void SubscriberStateChangedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  assignment_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscriberStateChangedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_assignment;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.SubscriberStateAssignment assignment = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_assignment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_assignment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_assignment;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+  return false;
+#undef DO_
+}
+
+void SubscriberStateChangedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.SubscriberStateAssignment assignment = 4;
+  for (int i = 0; i < this->assignment_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->assignment(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+}
+
+::google::protobuf::uint8* SubscriberStateChangedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.SubscriberStateAssignment assignment = 4;
+  for (int i = 0; i < this->assignment_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->assignment(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+  return target;
+}
+
+int SubscriberStateChangedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.SubscriberStateAssignment assignment = 4;
+  total_size += 1 * this->assignment_size();
+  for (int i = 0; i < this->assignment_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->assignment(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscriberStateChangedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscriberStateChangedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscriberStateChangedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscriberStateChangedNotification::MergeFrom(const SubscriberStateChangedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  assignment_.MergeFrom(from.assignment_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscriberStateChangedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscriberStateChangedNotification::CopyFrom(const SubscriberStateChangedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscriberStateChangedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->assignment())) return false;
+  return true;
+}
+
+void SubscriberStateChangedNotification::Swap(SubscriberStateChangedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    assignment_.Swap(&other->assignment_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscriberStateChangedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscriberStateChangedNotification_descriptor_;
+  metadata.reflection = SubscriberStateChangedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberRoleChangedNotification::kAgentIdFieldNumber;
+const int MemberRoleChangedNotification::kSubscriberIdFieldNumber;
+const int MemberRoleChangedNotification::kClubIdFieldNumber;
+const int MemberRoleChangedNotification::kAssignmentFieldNumber;
+#endif  // !_MSC_VER
+
+MemberRoleChangedNotification::MemberRoleChangedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MemberRoleChangedNotification)
+}
+
+void MemberRoleChangedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+MemberRoleChangedNotification::MemberRoleChangedNotification(const MemberRoleChangedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MemberRoleChangedNotification)
+}
+
+void MemberRoleChangedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberRoleChangedNotification::~MemberRoleChangedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MemberRoleChangedNotification)
+  SharedDtor();
+}
+
+void MemberRoleChangedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void MemberRoleChangedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberRoleChangedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberRoleChangedNotification_descriptor_;
+}
+
+const MemberRoleChangedNotification& MemberRoleChangedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+MemberRoleChangedNotification* MemberRoleChangedNotification::default_instance_ = NULL;
+
+MemberRoleChangedNotification* MemberRoleChangedNotification::New() const {
+  return new MemberRoleChangedNotification;
+}
+
+void MemberRoleChangedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  assignment_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberRoleChangedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MemberRoleChangedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_assignment;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.RoleAssignment assignment = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_assignment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_assignment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_assignment;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MemberRoleChangedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MemberRoleChangedNotification)
+  return false;
+#undef DO_
+}
+
+void MemberRoleChangedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MemberRoleChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.RoleAssignment assignment = 4;
+  for (int i = 0; i < this->assignment_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->assignment(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MemberRoleChangedNotification)
+}
+
+::google::protobuf::uint8* MemberRoleChangedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MemberRoleChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.RoleAssignment assignment = 4;
+  for (int i = 0; i < this->assignment_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->assignment(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MemberRoleChangedNotification)
+  return target;
+}
+
+int MemberRoleChangedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.RoleAssignment assignment = 4;
+  total_size += 1 * this->assignment_size();
+  for (int i = 0; i < this->assignment_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->assignment(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberRoleChangedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberRoleChangedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberRoleChangedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberRoleChangedNotification::MergeFrom(const MemberRoleChangedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  assignment_.MergeFrom(from.assignment_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberRoleChangedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberRoleChangedNotification::CopyFrom(const MemberRoleChangedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberRoleChangedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->assignment())) return false;
+  return true;
+}
+
+void MemberRoleChangedNotification::Swap(MemberRoleChangedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    assignment_.Swap(&other->assignment_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberRoleChangedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberRoleChangedNotification_descriptor_;
+  metadata.reflection = MemberRoleChangedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SuggestionAddedNotification::kAgentIdFieldNumber;
+const int SuggestionAddedNotification::kSubscriberIdFieldNumber;
+const int SuggestionAddedNotification::kClubIdFieldNumber;
+const int SuggestionAddedNotification::kSuggestionFieldNumber;
+#endif  // !_MSC_VER
+
+SuggestionAddedNotification::SuggestionAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SuggestionAddedNotification)
+}
+
+void SuggestionAddedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  suggestion_ = const_cast< ::bgs::protocol::club::v1::ClubSuggestion*>(&::bgs::protocol::club::v1::ClubSuggestion::default_instance());
+}
+
+SuggestionAddedNotification::SuggestionAddedNotification(const SuggestionAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SuggestionAddedNotification)
+}
+
+void SuggestionAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  suggestion_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SuggestionAddedNotification::~SuggestionAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SuggestionAddedNotification)
+  SharedDtor();
+}
+
+void SuggestionAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete suggestion_;
+  }
+}
+
+void SuggestionAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SuggestionAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SuggestionAddedNotification_descriptor_;
+}
+
+const SuggestionAddedNotification& SuggestionAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+SuggestionAddedNotification* SuggestionAddedNotification::default_instance_ = NULL;
+
+SuggestionAddedNotification* SuggestionAddedNotification::New() const {
+  return new SuggestionAddedNotification;
+}
+
+void SuggestionAddedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_suggestion()) {
+      if (suggestion_ != NULL) suggestion_->::bgs::protocol::club::v1::ClubSuggestion::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SuggestionAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SuggestionAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_suggestion;
+        break;
+      }
+
+      // required .bgs.protocol.club.v1.ClubSuggestion suggestion = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_suggestion:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suggestion()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SuggestionAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SuggestionAddedNotification)
+  return false;
+#undef DO_
+}
+
+void SuggestionAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SuggestionAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // required .bgs.protocol.club.v1.ClubSuggestion suggestion = 4;
+  if (has_suggestion()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->suggestion(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SuggestionAddedNotification)
+}
+
+::google::protobuf::uint8* SuggestionAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SuggestionAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // required .bgs.protocol.club.v1.ClubSuggestion suggestion = 4;
+  if (has_suggestion()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->suggestion(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SuggestionAddedNotification)
+  return target;
+}
+
+int SuggestionAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // required .bgs.protocol.club.v1.ClubSuggestion suggestion = 4;
+    if (has_suggestion()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suggestion());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SuggestionAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SuggestionAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SuggestionAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SuggestionAddedNotification::MergeFrom(const SuggestionAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_suggestion()) {
+      mutable_suggestion()->::bgs::protocol::club::v1::ClubSuggestion::MergeFrom(from.suggestion());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SuggestionAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SuggestionAddedNotification::CopyFrom(const SuggestionAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SuggestionAddedNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (has_suggestion()) {
+    if (!this->suggestion().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SuggestionAddedNotification::Swap(SuggestionAddedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(suggestion_, other->suggestion_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SuggestionAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SuggestionAddedNotification_descriptor_;
+  metadata.reflection = SuggestionAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SuggestionRemovedNotification::kAgentIdFieldNumber;
+const int SuggestionRemovedNotification::kSubscriberIdFieldNumber;
+const int SuggestionRemovedNotification::kClubIdFieldNumber;
+const int SuggestionRemovedNotification::kSuggestionIdFieldNumber;
+const int SuggestionRemovedNotification::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+SuggestionRemovedNotification::SuggestionRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SuggestionRemovedNotification)
+}
+
+void SuggestionRemovedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+SuggestionRemovedNotification::SuggestionRemovedNotification(const SuggestionRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SuggestionRemovedNotification)
+}
+
+void SuggestionRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  suggestion_id_ = GOOGLE_ULONGLONG(0);
+  reason_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SuggestionRemovedNotification::~SuggestionRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SuggestionRemovedNotification)
+  SharedDtor();
+}
+
+void SuggestionRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void SuggestionRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SuggestionRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SuggestionRemovedNotification_descriptor_;
+}
+
+const SuggestionRemovedNotification& SuggestionRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+SuggestionRemovedNotification* SuggestionRemovedNotification::default_instance_ = NULL;
+
+SuggestionRemovedNotification* SuggestionRemovedNotification::New() const {
+  return new SuggestionRemovedNotification;
+}
+
+void SuggestionRemovedNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<SuggestionRemovedNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(club_id_, reason_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SuggestionRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SuggestionRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(33)) goto parse_suggestion_id;
+        break;
+      }
+
+      // optional fixed64 suggestion_id = 4;
+      case 4: {
+        if (tag == 33) {
+         parse_suggestion_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &suggestion_id_)));
+          set_has_suggestion_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_reason;
+        break;
+      }
+
+      // optional .bgs.protocol.SuggestionRemovedReason reason = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_reason:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::SuggestionRemovedReason_IsValid(value)) {
+            set_reason(static_cast< ::bgs::protocol::SuggestionRemovedReason >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(5, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SuggestionRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SuggestionRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void SuggestionRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SuggestionRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional fixed64 suggestion_id = 4;
+  if (has_suggestion_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->suggestion_id(), output);
+  }
+
+  // optional .bgs.protocol.SuggestionRemovedReason reason = 5;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SuggestionRemovedNotification)
+}
+
+::google::protobuf::uint8* SuggestionRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SuggestionRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional fixed64 suggestion_id = 4;
+  if (has_suggestion_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->suggestion_id(), target);
+  }
+
+  // optional .bgs.protocol.SuggestionRemovedReason reason = 5;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      5, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SuggestionRemovedNotification)
+  return target;
+}
+
+int SuggestionRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional fixed64 suggestion_id = 4;
+    if (has_suggestion_id()) {
+      total_size += 1 + 8;
+    }
+
+    // optional .bgs.protocol.SuggestionRemovedReason reason = 5;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->reason());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SuggestionRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SuggestionRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SuggestionRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SuggestionRemovedNotification::MergeFrom(const SuggestionRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_suggestion_id()) {
+      set_suggestion_id(from.suggestion_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SuggestionRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SuggestionRemovedNotification::CopyFrom(const SuggestionRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SuggestionRemovedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SuggestionRemovedNotification::Swap(SuggestionRemovedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(suggestion_id_, other->suggestion_id_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SuggestionRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SuggestionRemovedNotification_descriptor_;
+  metadata.reflection = SuggestionRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamAddedNotification::kAgentIdFieldNumber;
+const int StreamAddedNotification::kSubscriberIdFieldNumber;
+const int StreamAddedNotification::kClubIdFieldNumber;
+const int StreamAddedNotification::kStreamFieldNumber;
+#endif  // !_MSC_VER
+
+StreamAddedNotification::StreamAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamAddedNotification)
+}
+
+void StreamAddedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  stream_ = const_cast< ::bgs::protocol::club::v1::Stream*>(&::bgs::protocol::club::v1::Stream::default_instance());
+}
+
+StreamAddedNotification::StreamAddedNotification(const StreamAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamAddedNotification)
+}
+
+void StreamAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamAddedNotification::~StreamAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamAddedNotification)
+  SharedDtor();
+}
+
+void StreamAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete stream_;
+  }
+}
+
+void StreamAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamAddedNotification_descriptor_;
+}
+
+const StreamAddedNotification& StreamAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+StreamAddedNotification* StreamAddedNotification::default_instance_ = NULL;
+
+StreamAddedNotification* StreamAddedNotification::New() const {
+  return new StreamAddedNotification;
+}
+
+void StreamAddedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_stream()) {
+      if (stream_ != NULL) stream_->::bgs::protocol::club::v1::Stream::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_stream;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.Stream stream = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_stream:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_stream()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamAddedNotification)
+  return false;
+#undef DO_
+}
+
+void StreamAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.Stream stream = 4;
+  if (has_stream()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->stream(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamAddedNotification)
+}
+
+::google::protobuf::uint8* StreamAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.Stream stream = 4;
+  if (has_stream()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->stream(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamAddedNotification)
+  return target;
+}
+
+int StreamAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.Stream stream = 4;
+    if (has_stream()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->stream());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamAddedNotification::MergeFrom(const StreamAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream()) {
+      mutable_stream()->::bgs::protocol::club::v1::Stream::MergeFrom(from.stream());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamAddedNotification::CopyFrom(const StreamAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamAddedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamAddedNotification::Swap(StreamAddedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_, other->stream_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamAddedNotification_descriptor_;
+  metadata.reflection = StreamAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamRemovedNotification::kAgentIdFieldNumber;
+const int StreamRemovedNotification::kSubscriberIdFieldNumber;
+const int StreamRemovedNotification::kClubIdFieldNumber;
+const int StreamRemovedNotification::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+StreamRemovedNotification::StreamRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamRemovedNotification)
+}
+
+void StreamRemovedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+StreamRemovedNotification::StreamRemovedNotification(const StreamRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamRemovedNotification)
+}
+
+void StreamRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamRemovedNotification::~StreamRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamRemovedNotification)
+  SharedDtor();
+}
+
+void StreamRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void StreamRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamRemovedNotification_descriptor_;
+}
+
+const StreamRemovedNotification& StreamRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+StreamRemovedNotification* StreamRemovedNotification::default_instance_ = NULL;
+
+StreamRemovedNotification* StreamRemovedNotification::New() const {
+  return new StreamRemovedNotification;
+}
+
+void StreamRemovedNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamRemovedNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void StreamRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->stream_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamRemovedNotification)
+}
+
+::google::protobuf::uint8* StreamRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamRemovedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->stream_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamRemovedNotification)
+  return target;
+}
+
+int StreamRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 4;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamRemovedNotification::MergeFrom(const StreamRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamRemovedNotification::CopyFrom(const StreamRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamRemovedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamRemovedNotification::Swap(StreamRemovedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamRemovedNotification_descriptor_;
+  metadata.reflection = StreamRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamStateChangedNotification::kAgentIdFieldNumber;
+const int StreamStateChangedNotification::kSubscriberIdFieldNumber;
+const int StreamStateChangedNotification::kClubIdFieldNumber;
+const int StreamStateChangedNotification::kStreamIdFieldNumber;
+const int StreamStateChangedNotification::kAssignmentFieldNumber;
+#endif  // !_MSC_VER
+
+StreamStateChangedNotification::StreamStateChangedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamStateChangedNotification)
+}
+
+void StreamStateChangedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  assignment_ = const_cast< ::bgs::protocol::club::v1::StreamStateAssignment*>(&::bgs::protocol::club::v1::StreamStateAssignment::default_instance());
+}
+
+StreamStateChangedNotification::StreamStateChangedNotification(const StreamStateChangedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamStateChangedNotification)
+}
+
+void StreamStateChangedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  assignment_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamStateChangedNotification::~StreamStateChangedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamStateChangedNotification)
+  SharedDtor();
+}
+
+void StreamStateChangedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete assignment_;
+  }
+}
+
+void StreamStateChangedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamStateChangedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamStateChangedNotification_descriptor_;
+}
+
+const StreamStateChangedNotification& StreamStateChangedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+StreamStateChangedNotification* StreamStateChangedNotification::default_instance_ = NULL;
+
+StreamStateChangedNotification* StreamStateChangedNotification::New() const {
+  return new StreamStateChangedNotification;
+}
+
+void StreamStateChangedNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamStateChangedNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_assignment()) {
+      if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::StreamStateAssignment::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamStateChangedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamStateChangedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_assignment;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamStateAssignment assignment = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_assignment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_assignment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamStateChangedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamStateChangedNotification)
+  return false;
+#undef DO_
+}
+
+void StreamStateChangedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamStateChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamStateAssignment assignment = 5;
+  if (has_assignment()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->assignment(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamStateChangedNotification)
+}
+
+::google::protobuf::uint8* StreamStateChangedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamStateChangedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamStateAssignment assignment = 5;
+  if (has_assignment()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->assignment(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamStateChangedNotification)
+  return target;
+}
+
+int StreamStateChangedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 4;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamStateAssignment assignment = 5;
+    if (has_assignment()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->assignment());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamStateChangedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamStateChangedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamStateChangedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamStateChangedNotification::MergeFrom(const StreamStateChangedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_assignment()) {
+      mutable_assignment()->::bgs::protocol::club::v1::StreamStateAssignment::MergeFrom(from.assignment());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamStateChangedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamStateChangedNotification::CopyFrom(const StreamStateChangedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamStateChangedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamStateChangedNotification::Swap(StreamStateChangedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(assignment_, other->assignment_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamStateChangedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamStateChangedNotification_descriptor_;
+  metadata.reflection = StreamStateChangedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamMessageAddedNotification::kAgentIdFieldNumber;
+const int StreamMessageAddedNotification::kSubscriberIdFieldNumber;
+const int StreamMessageAddedNotification::kClubIdFieldNumber;
+const int StreamMessageAddedNotification::kStreamIdFieldNumber;
+const int StreamMessageAddedNotification::kMessageFieldNumber;
+#endif  // !_MSC_VER
+
+StreamMessageAddedNotification::StreamMessageAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamMessageAddedNotification)
+}
+
+void StreamMessageAddedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  message_ = const_cast< ::bgs::protocol::club::v1::StreamMessage*>(&::bgs::protocol::club::v1::StreamMessage::default_instance());
+}
+
+StreamMessageAddedNotification::StreamMessageAddedNotification(const StreamMessageAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamMessageAddedNotification)
+}
+
+void StreamMessageAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  message_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamMessageAddedNotification::~StreamMessageAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamMessageAddedNotification)
+  SharedDtor();
+}
+
+void StreamMessageAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete message_;
+  }
+}
+
+void StreamMessageAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamMessageAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamMessageAddedNotification_descriptor_;
+}
+
+const StreamMessageAddedNotification& StreamMessageAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+StreamMessageAddedNotification* StreamMessageAddedNotification::default_instance_ = NULL;
+
+StreamMessageAddedNotification* StreamMessageAddedNotification::New() const {
+  return new StreamMessageAddedNotification;
+}
+
+void StreamMessageAddedNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamMessageAddedNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_message()) {
+      if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamMessageAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamMessageAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_message;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamMessageAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamMessageAddedNotification)
+  return false;
+#undef DO_
+}
+
+void StreamMessageAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamMessageAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->message(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamMessageAddedNotification)
+}
+
+::google::protobuf::uint8* StreamMessageAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamMessageAddedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+  if (has_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->message(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamMessageAddedNotification)
+  return target;
+}
+
+int StreamMessageAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 4;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+    if (has_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamMessageAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamMessageAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamMessageAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamMessageAddedNotification::MergeFrom(const StreamMessageAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_message()) {
+      mutable_message()->::bgs::protocol::club::v1::StreamMessage::MergeFrom(from.message());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamMessageAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamMessageAddedNotification::CopyFrom(const StreamMessageAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamMessageAddedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (has_message()) {
+    if (!this->message().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamMessageAddedNotification::Swap(StreamMessageAddedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(message_, other->message_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamMessageAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamMessageAddedNotification_descriptor_;
+  metadata.reflection = StreamMessageAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamMessageUpdatedNotification::kAgentIdFieldNumber;
+const int StreamMessageUpdatedNotification::kSubscriberIdFieldNumber;
+const int StreamMessageUpdatedNotification::kClubIdFieldNumber;
+const int StreamMessageUpdatedNotification::kStreamIdFieldNumber;
+const int StreamMessageUpdatedNotification::kMessageFieldNumber;
+#endif  // !_MSC_VER
+
+StreamMessageUpdatedNotification::StreamMessageUpdatedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+}
+
+void StreamMessageUpdatedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  message_ = const_cast< ::bgs::protocol::club::v1::StreamMessage*>(&::bgs::protocol::club::v1::StreamMessage::default_instance());
+}
+
+StreamMessageUpdatedNotification::StreamMessageUpdatedNotification(const StreamMessageUpdatedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+}
+
+void StreamMessageUpdatedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  message_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamMessageUpdatedNotification::~StreamMessageUpdatedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+  SharedDtor();
+}
+
+void StreamMessageUpdatedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete message_;
+  }
+}
+
+void StreamMessageUpdatedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamMessageUpdatedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamMessageUpdatedNotification_descriptor_;
+}
+
+const StreamMessageUpdatedNotification& StreamMessageUpdatedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+StreamMessageUpdatedNotification* StreamMessageUpdatedNotification::default_instance_ = NULL;
+
+StreamMessageUpdatedNotification* StreamMessageUpdatedNotification::New() const {
+  return new StreamMessageUpdatedNotification;
+}
+
+void StreamMessageUpdatedNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamMessageUpdatedNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_message()) {
+      if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamMessageUpdatedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_message;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+  return false;
+#undef DO_
+}
+
+void StreamMessageUpdatedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->message(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+}
+
+::google::protobuf::uint8* StreamMessageUpdatedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+  if (has_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->message(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+  return target;
+}
+
+int StreamMessageUpdatedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 4;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+    if (has_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamMessageUpdatedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamMessageUpdatedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamMessageUpdatedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamMessageUpdatedNotification::MergeFrom(const StreamMessageUpdatedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_message()) {
+      mutable_message()->::bgs::protocol::club::v1::StreamMessage::MergeFrom(from.message());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamMessageUpdatedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamMessageUpdatedNotification::CopyFrom(const StreamMessageUpdatedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamMessageUpdatedNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (has_message()) {
+    if (!this->message().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamMessageUpdatedNotification::Swap(StreamMessageUpdatedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(message_, other->message_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamMessageUpdatedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamMessageUpdatedNotification_descriptor_;
+  metadata.reflection = StreamMessageUpdatedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamTypingIndicatorNotification::kAgentIdFieldNumber;
+const int StreamTypingIndicatorNotification::kSubscriberIdFieldNumber;
+const int StreamTypingIndicatorNotification::kClubIdFieldNumber;
+const int StreamTypingIndicatorNotification::kStreamIdFieldNumber;
+const int StreamTypingIndicatorNotification::kIndicatorFieldNumber;
+#endif  // !_MSC_VER
+
+StreamTypingIndicatorNotification::StreamTypingIndicatorNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+}
+
+void StreamTypingIndicatorNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+StreamTypingIndicatorNotification::StreamTypingIndicatorNotification(const StreamTypingIndicatorNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+}
+
+void StreamTypingIndicatorNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamTypingIndicatorNotification::~StreamTypingIndicatorNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+  SharedDtor();
+}
+
+void StreamTypingIndicatorNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void StreamTypingIndicatorNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamTypingIndicatorNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamTypingIndicatorNotification_descriptor_;
+}
+
+const StreamTypingIndicatorNotification& StreamTypingIndicatorNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+StreamTypingIndicatorNotification* StreamTypingIndicatorNotification::default_instance_ = NULL;
+
+StreamTypingIndicatorNotification* StreamTypingIndicatorNotification::New() const {
+  return new StreamTypingIndicatorNotification;
+}
+
+void StreamTypingIndicatorNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamTypingIndicatorNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  indicator_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamTypingIndicatorNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_indicator;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.StreamTypingIndicator indicator = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_indicator:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_indicator()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_indicator;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+  return false;
+#undef DO_
+}
+
+void StreamTypingIndicatorNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->stream_id(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.StreamTypingIndicator indicator = 5;
+  for (int i = 0; i < this->indicator_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->indicator(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+}
+
+::google::protobuf::uint8* StreamTypingIndicatorNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 4;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->stream_id(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.StreamTypingIndicator indicator = 5;
+  for (int i = 0; i < this->indicator_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->indicator(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+  return target;
+}
+
+int StreamTypingIndicatorNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 4;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.StreamTypingIndicator indicator = 5;
+  total_size += 1 * this->indicator_size();
+  for (int i = 0; i < this->indicator_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->indicator(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamTypingIndicatorNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamTypingIndicatorNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamTypingIndicatorNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamTypingIndicatorNotification::MergeFrom(const StreamTypingIndicatorNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  indicator_.MergeFrom(from.indicator_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamTypingIndicatorNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamTypingIndicatorNotification::CopyFrom(const StreamTypingIndicatorNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamTypingIndicatorNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->indicator())) return false;
+  return true;
+}
+
+void StreamTypingIndicatorNotification::Swap(StreamTypingIndicatorNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    indicator_.Swap(&other->indicator_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamTypingIndicatorNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamTypingIndicatorNotification_descriptor_;
+  metadata.reflection = StreamTypingIndicatorNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamUnreadIndicatorNotification::kAgentIdFieldNumber;
+const int StreamUnreadIndicatorNotification::kSubscriberIdFieldNumber;
+const int StreamUnreadIndicatorNotification::kClubIdFieldNumber;
+const int StreamUnreadIndicatorNotification::kEventFieldNumber;
+#endif  // !_MSC_VER
+
+StreamUnreadIndicatorNotification::StreamUnreadIndicatorNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+}
+
+void StreamUnreadIndicatorNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  event_ = const_cast< ::bgs::protocol::club::v1::StreamEventTime*>(&::bgs::protocol::club::v1::StreamEventTime::default_instance());
+}
+
+StreamUnreadIndicatorNotification::StreamUnreadIndicatorNotification(const StreamUnreadIndicatorNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+}
+
+void StreamUnreadIndicatorNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  event_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamUnreadIndicatorNotification::~StreamUnreadIndicatorNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+  SharedDtor();
+}
+
+void StreamUnreadIndicatorNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+    delete event_;
+  }
+}
+
+void StreamUnreadIndicatorNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamUnreadIndicatorNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamUnreadIndicatorNotification_descriptor_;
+}
+
+const StreamUnreadIndicatorNotification& StreamUnreadIndicatorNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+StreamUnreadIndicatorNotification* StreamUnreadIndicatorNotification::default_instance_ = NULL;
+
+StreamUnreadIndicatorNotification* StreamUnreadIndicatorNotification::New() const {
+  return new StreamUnreadIndicatorNotification;
+}
+
+void StreamUnreadIndicatorNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_event()) {
+      if (event_ != NULL) event_->::bgs::protocol::club::v1::StreamEventTime::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamUnreadIndicatorNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_event;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamEventTime event = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_event:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_event()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+  return false;
+#undef DO_
+}
+
+void StreamUnreadIndicatorNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamEventTime event = 4;
+  if (has_event()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->event(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+}
+
+::google::protobuf::uint8* StreamUnreadIndicatorNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamEventTime event = 4;
+  if (has_event()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->event(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+  return target;
+}
+
+int StreamUnreadIndicatorNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamEventTime event = 4;
+    if (has_event()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->event());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamUnreadIndicatorNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamUnreadIndicatorNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamUnreadIndicatorNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamUnreadIndicatorNotification::MergeFrom(const StreamUnreadIndicatorNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_event()) {
+      mutable_event()->::bgs::protocol::club::v1::StreamEventTime::MergeFrom(from.event());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamUnreadIndicatorNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamUnreadIndicatorNotification::CopyFrom(const StreamUnreadIndicatorNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamUnreadIndicatorNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamUnreadIndicatorNotification::Swap(StreamUnreadIndicatorNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(event_, other->event_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamUnreadIndicatorNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamUnreadIndicatorNotification_descriptor_;
+  metadata.reflection = StreamUnreadIndicatorNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamAdvanceViewTimeNotification::kAgentIdFieldNumber;
+const int StreamAdvanceViewTimeNotification::kSubscriberIdFieldNumber;
+const int StreamAdvanceViewTimeNotification::kClubIdFieldNumber;
+const int StreamAdvanceViewTimeNotification::kViewFieldNumber;
+#endif  // !_MSC_VER
+
+StreamAdvanceViewTimeNotification::StreamAdvanceViewTimeNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+}
+
+void StreamAdvanceViewTimeNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+StreamAdvanceViewTimeNotification::StreamAdvanceViewTimeNotification(const StreamAdvanceViewTimeNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+}
+
+void StreamAdvanceViewTimeNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamAdvanceViewTimeNotification::~StreamAdvanceViewTimeNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+  SharedDtor();
+}
+
+void StreamAdvanceViewTimeNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void StreamAdvanceViewTimeNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamAdvanceViewTimeNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamAdvanceViewTimeNotification_descriptor_;
+}
+
+const StreamAdvanceViewTimeNotification& StreamAdvanceViewTimeNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+StreamAdvanceViewTimeNotification* StreamAdvanceViewTimeNotification::default_instance_ = NULL;
+
+StreamAdvanceViewTimeNotification* StreamAdvanceViewTimeNotification::New() const {
+  return new StreamAdvanceViewTimeNotification;
+}
+
+void StreamAdvanceViewTimeNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  view_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamAdvanceViewTimeNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_view;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.StreamAdvanceViewTime view = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_view:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_view()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_view;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+  return false;
+#undef DO_
+}
+
+void StreamAdvanceViewTimeNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.StreamAdvanceViewTime view = 4;
+  for (int i = 0; i < this->view_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->view(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+}
+
+::google::protobuf::uint8* StreamAdvanceViewTimeNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.StreamAdvanceViewTime view = 4;
+  for (int i = 0; i < this->view_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->view(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+  return target;
+}
+
+int StreamAdvanceViewTimeNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.StreamAdvanceViewTime view = 4;
+  total_size += 1 * this->view_size();
+  for (int i = 0; i < this->view_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->view(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamAdvanceViewTimeNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamAdvanceViewTimeNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamAdvanceViewTimeNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamAdvanceViewTimeNotification::MergeFrom(const StreamAdvanceViewTimeNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  view_.MergeFrom(from.view_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamAdvanceViewTimeNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamAdvanceViewTimeNotification::CopyFrom(const StreamAdvanceViewTimeNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamAdvanceViewTimeNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamAdvanceViewTimeNotification::Swap(StreamAdvanceViewTimeNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    view_.Swap(&other->view_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamAdvanceViewTimeNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamAdvanceViewTimeNotification_descriptor_;
+  metadata.reflection = StreamAdvanceViewTimeNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubActivityNotification::kAgentIdFieldNumber;
+const int ClubActivityNotification::kSubscriberIdFieldNumber;
+const int ClubActivityNotification::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+ClubActivityNotification::ClubActivityNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubActivityNotification)
+}
+
+void ClubActivityNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  subscriber_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+ClubActivityNotification::ClubActivityNotification(const ClubActivityNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubActivityNotification)
+}
+
+void ClubActivityNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  subscriber_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubActivityNotification::~ClubActivityNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubActivityNotification)
+  SharedDtor();
+}
+
+void ClubActivityNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete subscriber_id_;
+  }
+}
+
+void ClubActivityNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubActivityNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubActivityNotification_descriptor_;
+}
+
+const ClubActivityNotification& ClubActivityNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fnotification_2eproto();
+  return *default_instance_;
+}
+
+ClubActivityNotification* ClubActivityNotification::default_instance_ = NULL;
+
+ClubActivityNotification* ClubActivityNotification::New() const {
+  return new ClubActivityNotification;
+}
+
+void ClubActivityNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_subscriber_id()) {
+      if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubActivityNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubActivityNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubActivityNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubActivityNotification)
+  return false;
+#undef DO_
+}
+
+void ClubActivityNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubActivityNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber_id(), output);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->club_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubActivityNotification)
+}
+
+::google::protobuf::uint8* ClubActivityNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubActivityNotification)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber_id(), target);
+  }
+
+  // optional uint64 club_id = 3;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->club_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubActivityNotification)
+  return target;
+}
+
+int ClubActivityNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+    // optional uint64 club_id = 3;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubActivityNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubActivityNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubActivityNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubActivityNotification::MergeFrom(const ClubActivityNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.subscriber_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubActivityNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubActivityNotification::CopyFrom(const ClubActivityNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubActivityNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClubActivityNotification::Swap(ClubActivityNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubActivityNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubActivityNotification_descriptor_;
+  metadata.reflection = ClubActivityNotification_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_notification.pb.h b/src/server/proto/Client/club_notification.pb.h
new file mode 100644
index 00000000000..43688c80ca0
--- /dev/null
+++ b/src/server/proto/Client/club_notification.pb.h
@@ -0,0 +1,5524 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_notification.proto
+
+#ifndef PROTOBUF_club_5fnotification_2eproto__INCLUDED
+#define PROTOBUF_club_5fnotification_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "club_types.pb.h"  // IWYU pragma: export
+#include "rpc_types.pb.h"  // IWYU pragma: export
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+void protobuf_AssignDesc_club_5fnotification_2eproto();
+void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+class SubscribeNotification;
+class UnsubscribeNotification;
+class StateChangedNotification;
+class SettingsChangedNotification;
+class MemberAddedNotification;
+class MemberRemovedNotification;
+class MemberStateChangedNotification;
+class SubscriberStateChangedNotification;
+class MemberRoleChangedNotification;
+class SuggestionAddedNotification;
+class SuggestionRemovedNotification;
+class StreamAddedNotification;
+class StreamRemovedNotification;
+class StreamStateChangedNotification;
+class StreamMessageAddedNotification;
+class StreamMessageUpdatedNotification;
+class StreamTypingIndicatorNotification;
+class StreamUnreadIndicatorNotification;
+class StreamAdvanceViewTimeNotification;
+class ClubActivityNotification;
+
+// ===================================================================
+
+class TC_PROTO_API SubscribeNotification : public ::google::protobuf::Message {
+ public:
+  SubscribeNotification();
+  virtual ~SubscribeNotification();
+
+  SubscribeNotification(const SubscribeNotification& from);
+
+  inline SubscribeNotification& operator=(const SubscribeNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubscribeNotification& default_instance();
+
+  void Swap(SubscribeNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeNotification& from);
+  void MergeFrom(const SubscribeNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.Club club = 4;
+  inline bool has_club() const;
+  inline void clear_club();
+  static const int kClubFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::Club& club() const;
+  inline ::bgs::protocol::club::v1::Club* mutable_club();
+  inline ::bgs::protocol::club::v1::Club* release_club();
+  inline void set_allocated_club(::bgs::protocol::club::v1::Club* club);
+
+  // optional .bgs.protocol.club.v1.ClubView view = 5;
+  inline bool has_view() const;
+  inline void clear_view();
+  static const int kViewFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::ClubView& view() const;
+  inline ::bgs::protocol::club::v1::ClubView* mutable_view();
+  inline ::bgs::protocol::club::v1::ClubView* release_view();
+  inline void set_allocated_view(::bgs::protocol::club::v1::ClubView* view);
+
+  // optional .bgs.protocol.club.v1.ClubSettings settings = 10;
+  inline bool has_settings() const;
+  inline void clear_settings();
+  static const int kSettingsFieldNumber = 10;
+  inline const ::bgs::protocol::club::v1::ClubSettings& settings() const;
+  inline ::bgs::protocol::club::v1::ClubSettings* mutable_settings();
+  inline ::bgs::protocol::club::v1::ClubSettings* release_settings();
+  inline void set_allocated_settings(::bgs::protocol::club::v1::ClubSettings* settings);
+
+  // optional .bgs.protocol.club.v1.Member member = 11;
+  inline bool has_member() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 11;
+  inline const ::bgs::protocol::club::v1::Member& member() const;
+  inline ::bgs::protocol::club::v1::Member* mutable_member();
+  inline ::bgs::protocol::club::v1::Member* release_member();
+  inline void set_allocated_member(::bgs::protocol::club::v1::Member* member);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SubscribeNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_club();
+  inline void clear_has_club();
+  inline void set_has_view();
+  inline void clear_has_view();
+  inline void set_has_settings();
+  inline void clear_has_settings();
+  inline void set_has_member();
+  inline void clear_has_member();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::Club* club_;
+  ::bgs::protocol::club::v1::ClubView* view_;
+  ::bgs::protocol::club::v1::ClubSettings* settings_;
+  ::bgs::protocol::club::v1::Member* member_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UnsubscribeNotification : public ::google::protobuf::Message {
+ public:
+  UnsubscribeNotification();
+  virtual ~UnsubscribeNotification();
+
+  UnsubscribeNotification(const UnsubscribeNotification& from);
+
+  inline UnsubscribeNotification& operator=(const UnsubscribeNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UnsubscribeNotification& default_instance();
+
+  void Swap(UnsubscribeNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsubscribeNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsubscribeNotification& from);
+  void MergeFrom(const UnsubscribeNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UnsubscribeNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsubscribeNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StateChangedNotification : public ::google::protobuf::Message {
+ public:
+  StateChangedNotification();
+  virtual ~StateChangedNotification();
+
+  StateChangedNotification(const StateChangedNotification& from);
+
+  inline StateChangedNotification& operator=(const StateChangedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StateChangedNotification& default_instance();
+
+  void Swap(StateChangedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StateChangedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StateChangedNotification& from);
+  void MergeFrom(const StateChangedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.ClubStateAssignment assignment = 5;
+  inline bool has_assignment() const;
+  inline void clear_assignment();
+  static const int kAssignmentFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::ClubStateAssignment& assignment() const;
+  inline ::bgs::protocol::club::v1::ClubStateAssignment* mutable_assignment();
+  inline ::bgs::protocol::club::v1::ClubStateAssignment* release_assignment();
+  inline void set_allocated_assignment(::bgs::protocol::club::v1::ClubStateAssignment* assignment);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StateChangedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_assignment();
+  inline void clear_has_assignment();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::ClubStateAssignment* assignment_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static StateChangedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SettingsChangedNotification : public ::google::protobuf::Message {
+ public:
+  SettingsChangedNotification();
+  virtual ~SettingsChangedNotification();
+
+  SettingsChangedNotification(const SettingsChangedNotification& from);
+
+  inline SettingsChangedNotification& operator=(const SettingsChangedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SettingsChangedNotification& default_instance();
+
+  void Swap(SettingsChangedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SettingsChangedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SettingsChangedNotification& from);
+  void MergeFrom(const SettingsChangedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.ClubSettingsAssignment assignment = 4;
+  inline bool has_assignment() const;
+  inline void clear_assignment();
+  static const int kAssignmentFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::ClubSettingsAssignment& assignment() const;
+  inline ::bgs::protocol::club::v1::ClubSettingsAssignment* mutable_assignment();
+  inline ::bgs::protocol::club::v1::ClubSettingsAssignment* release_assignment();
+  inline void set_allocated_assignment(::bgs::protocol::club::v1::ClubSettingsAssignment* assignment);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SettingsChangedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_assignment();
+  inline void clear_has_assignment();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::ClubSettingsAssignment* assignment_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static SettingsChangedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberAddedNotification : public ::google::protobuf::Message {
+ public:
+  MemberAddedNotification();
+  virtual ~MemberAddedNotification();
+
+  MemberAddedNotification(const MemberAddedNotification& from);
+
+  inline MemberAddedNotification& operator=(const MemberAddedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberAddedNotification& default_instance();
+
+  void Swap(MemberAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberAddedNotification& from);
+  void MergeFrom(const MemberAddedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.club.v1.Member member = 4;
+  inline int member_size() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::Member& member(int index) const;
+  inline ::bgs::protocol::club::v1::Member* mutable_member(int index);
+  inline ::bgs::protocol::club::v1::Member* add_member();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member >&
+      member() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member >*
+      mutable_member();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberAddedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member > member_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberRemovedNotification : public ::google::protobuf::Message {
+ public:
+  MemberRemovedNotification();
+  virtual ~MemberRemovedNotification();
+
+  MemberRemovedNotification(const MemberRemovedNotification& from);
+
+  inline MemberRemovedNotification& operator=(const MemberRemovedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberRemovedNotification& default_instance();
+
+  void Swap(MemberRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberRemovedNotification& from);
+  void MergeFrom(const MemberRemovedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.club.v1.MemberRemovedAssignment member = 4;
+  inline int member_size() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::MemberRemovedAssignment& member(int index) const;
+  inline ::bgs::protocol::club::v1::MemberRemovedAssignment* mutable_member(int index);
+  inline ::bgs::protocol::club::v1::MemberRemovedAssignment* add_member();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberRemovedAssignment >&
+      member() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberRemovedAssignment >*
+      mutable_member();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberRemovedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberRemovedAssignment > member_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberRemovedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberStateChangedNotification : public ::google::protobuf::Message {
+ public:
+  MemberStateChangedNotification();
+  virtual ~MemberStateChangedNotification();
+
+  MemberStateChangedNotification(const MemberStateChangedNotification& from);
+
+  inline MemberStateChangedNotification& operator=(const MemberStateChangedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberStateChangedNotification& default_instance();
+
+  void Swap(MemberStateChangedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberStateChangedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberStateChangedNotification& from);
+  void MergeFrom(const MemberStateChangedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.club.v1.MemberStateAssignment assignment = 4;
+  inline int assignment_size() const;
+  inline void clear_assignment();
+  static const int kAssignmentFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::MemberStateAssignment& assignment(int index) const;
+  inline ::bgs::protocol::club::v1::MemberStateAssignment* mutable_assignment(int index);
+  inline ::bgs::protocol::club::v1::MemberStateAssignment* add_assignment();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberStateAssignment >&
+      assignment() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberStateAssignment >*
+      mutable_assignment();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberStateChangedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberStateAssignment > assignment_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberStateChangedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SubscriberStateChangedNotification : public ::google::protobuf::Message {
+ public:
+  SubscriberStateChangedNotification();
+  virtual ~SubscriberStateChangedNotification();
+
+  SubscriberStateChangedNotification(const SubscriberStateChangedNotification& from);
+
+  inline SubscriberStateChangedNotification& operator=(const SubscriberStateChangedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubscriberStateChangedNotification& default_instance();
+
+  void Swap(SubscriberStateChangedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscriberStateChangedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscriberStateChangedNotification& from);
+  void MergeFrom(const SubscriberStateChangedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.club.v1.SubscriberStateAssignment assignment = 4;
+  inline int assignment_size() const;
+  inline void clear_assignment();
+  static const int kAssignmentFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::SubscriberStateAssignment& assignment(int index) const;
+  inline ::bgs::protocol::club::v1::SubscriberStateAssignment* mutable_assignment(int index);
+  inline ::bgs::protocol::club::v1::SubscriberStateAssignment* add_assignment();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::SubscriberStateAssignment >&
+      assignment() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::SubscriberStateAssignment >*
+      mutable_assignment();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SubscriberStateChangedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::SubscriberStateAssignment > assignment_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscriberStateChangedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MemberRoleChangedNotification : public ::google::protobuf::Message {
+ public:
+  MemberRoleChangedNotification();
+  virtual ~MemberRoleChangedNotification();
+
+  MemberRoleChangedNotification(const MemberRoleChangedNotification& from);
+
+  inline MemberRoleChangedNotification& operator=(const MemberRoleChangedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MemberRoleChangedNotification& default_instance();
+
+  void Swap(MemberRoleChangedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberRoleChangedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberRoleChangedNotification& from);
+  void MergeFrom(const MemberRoleChangedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.club.v1.RoleAssignment assignment = 4;
+  inline int assignment_size() const;
+  inline void clear_assignment();
+  static const int kAssignmentFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::RoleAssignment& assignment(int index) const;
+  inline ::bgs::protocol::club::v1::RoleAssignment* mutable_assignment(int index);
+  inline ::bgs::protocol::club::v1::RoleAssignment* add_assignment();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::RoleAssignment >&
+      assignment() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::RoleAssignment >*
+      mutable_assignment();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MemberRoleChangedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::RoleAssignment > assignment_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberRoleChangedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SuggestionAddedNotification : public ::google::protobuf::Message {
+ public:
+  SuggestionAddedNotification();
+  virtual ~SuggestionAddedNotification();
+
+  SuggestionAddedNotification(const SuggestionAddedNotification& from);
+
+  inline SuggestionAddedNotification& operator=(const SuggestionAddedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SuggestionAddedNotification& default_instance();
+
+  void Swap(SuggestionAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SuggestionAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SuggestionAddedNotification& from);
+  void MergeFrom(const SuggestionAddedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // required .bgs.protocol.club.v1.ClubSuggestion suggestion = 4;
+  inline bool has_suggestion() const;
+  inline void clear_suggestion();
+  static const int kSuggestionFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::ClubSuggestion& suggestion() const;
+  inline ::bgs::protocol::club::v1::ClubSuggestion* mutable_suggestion();
+  inline ::bgs::protocol::club::v1::ClubSuggestion* release_suggestion();
+  inline void set_allocated_suggestion(::bgs::protocol::club::v1::ClubSuggestion* suggestion);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SuggestionAddedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_suggestion();
+  inline void clear_has_suggestion();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::ClubSuggestion* suggestion_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static SuggestionAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SuggestionRemovedNotification : public ::google::protobuf::Message {
+ public:
+  SuggestionRemovedNotification();
+  virtual ~SuggestionRemovedNotification();
+
+  SuggestionRemovedNotification(const SuggestionRemovedNotification& from);
+
+  inline SuggestionRemovedNotification& operator=(const SuggestionRemovedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SuggestionRemovedNotification& default_instance();
+
+  void Swap(SuggestionRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SuggestionRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SuggestionRemovedNotification& from);
+  void MergeFrom(const SuggestionRemovedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional fixed64 suggestion_id = 4;
+  inline bool has_suggestion_id() const;
+  inline void clear_suggestion_id();
+  static const int kSuggestionIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 suggestion_id() const;
+  inline void set_suggestion_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.SuggestionRemovedReason reason = 5;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 5;
+  inline ::bgs::protocol::SuggestionRemovedReason reason() const;
+  inline void set_reason(::bgs::protocol::SuggestionRemovedReason value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SuggestionRemovedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_suggestion_id();
+  inline void clear_has_suggestion_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 suggestion_id_;
+  int reason_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static SuggestionRemovedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamAddedNotification : public ::google::protobuf::Message {
+ public:
+  StreamAddedNotification();
+  virtual ~StreamAddedNotification();
+
+  StreamAddedNotification(const StreamAddedNotification& from);
+
+  inline StreamAddedNotification& operator=(const StreamAddedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamAddedNotification& default_instance();
+
+  void Swap(StreamAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamAddedNotification& from);
+  void MergeFrom(const StreamAddedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.Stream stream = 4;
+  inline bool has_stream() const;
+  inline void clear_stream();
+  static const int kStreamFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::Stream& stream() const;
+  inline ::bgs::protocol::club::v1::Stream* mutable_stream();
+  inline ::bgs::protocol::club::v1::Stream* release_stream();
+  inline void set_allocated_stream(::bgs::protocol::club::v1::Stream* stream);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamAddedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream();
+  inline void clear_has_stream();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::Stream* stream_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamRemovedNotification : public ::google::protobuf::Message {
+ public:
+  StreamRemovedNotification();
+  virtual ~StreamRemovedNotification();
+
+  StreamRemovedNotification(const StreamRemovedNotification& from);
+
+  inline StreamRemovedNotification& operator=(const StreamRemovedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamRemovedNotification& default_instance();
+
+  void Swap(StreamRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamRemovedNotification& from);
+  void MergeFrom(const StreamRemovedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 4;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamRemovedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamRemovedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamStateChangedNotification : public ::google::protobuf::Message {
+ public:
+  StreamStateChangedNotification();
+  virtual ~StreamStateChangedNotification();
+
+  StreamStateChangedNotification(const StreamStateChangedNotification& from);
+
+  inline StreamStateChangedNotification& operator=(const StreamStateChangedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamStateChangedNotification& default_instance();
+
+  void Swap(StreamStateChangedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamStateChangedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamStateChangedNotification& from);
+  void MergeFrom(const StreamStateChangedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 4;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.StreamStateAssignment assignment = 5;
+  inline bool has_assignment() const;
+  inline void clear_assignment();
+  static const int kAssignmentFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::StreamStateAssignment& assignment() const;
+  inline ::bgs::protocol::club::v1::StreamStateAssignment* mutable_assignment();
+  inline ::bgs::protocol::club::v1::StreamStateAssignment* release_assignment();
+  inline void set_allocated_assignment(::bgs::protocol::club::v1::StreamStateAssignment* assignment);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamStateChangedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_assignment();
+  inline void clear_has_assignment();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::club::v1::StreamStateAssignment* assignment_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamStateChangedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamMessageAddedNotification : public ::google::protobuf::Message {
+ public:
+  StreamMessageAddedNotification();
+  virtual ~StreamMessageAddedNotification();
+
+  StreamMessageAddedNotification(const StreamMessageAddedNotification& from);
+
+  inline StreamMessageAddedNotification& operator=(const StreamMessageAddedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamMessageAddedNotification& default_instance();
+
+  void Swap(StreamMessageAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamMessageAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamMessageAddedNotification& from);
+  void MergeFrom(const StreamMessageAddedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 4;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+  inline bool has_message() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::StreamMessage& message() const;
+  inline ::bgs::protocol::club::v1::StreamMessage* mutable_message();
+  inline ::bgs::protocol::club::v1::StreamMessage* release_message();
+  inline void set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamMessageAddedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_message();
+  inline void clear_has_message();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::club::v1::StreamMessage* message_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamMessageAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamMessageUpdatedNotification : public ::google::protobuf::Message {
+ public:
+  StreamMessageUpdatedNotification();
+  virtual ~StreamMessageUpdatedNotification();
+
+  StreamMessageUpdatedNotification(const StreamMessageUpdatedNotification& from);
+
+  inline StreamMessageUpdatedNotification& operator=(const StreamMessageUpdatedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamMessageUpdatedNotification& default_instance();
+
+  void Swap(StreamMessageUpdatedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamMessageUpdatedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamMessageUpdatedNotification& from);
+  void MergeFrom(const StreamMessageUpdatedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 4;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.StreamMessage message = 5;
+  inline bool has_message() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::StreamMessage& message() const;
+  inline ::bgs::protocol::club::v1::StreamMessage* mutable_message();
+  inline ::bgs::protocol::club::v1::StreamMessage* release_message();
+  inline void set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamMessageUpdatedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_message();
+  inline void clear_has_message();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::club::v1::StreamMessage* message_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamMessageUpdatedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamTypingIndicatorNotification : public ::google::protobuf::Message {
+ public:
+  StreamTypingIndicatorNotification();
+  virtual ~StreamTypingIndicatorNotification();
+
+  StreamTypingIndicatorNotification(const StreamTypingIndicatorNotification& from);
+
+  inline StreamTypingIndicatorNotification& operator=(const StreamTypingIndicatorNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamTypingIndicatorNotification& default_instance();
+
+  void Swap(StreamTypingIndicatorNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamTypingIndicatorNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamTypingIndicatorNotification& from);
+  void MergeFrom(const StreamTypingIndicatorNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 4;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.club.v1.StreamTypingIndicator indicator = 5;
+  inline int indicator_size() const;
+  inline void clear_indicator();
+  static const int kIndicatorFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::StreamTypingIndicator& indicator(int index) const;
+  inline ::bgs::protocol::club::v1::StreamTypingIndicator* mutable_indicator(int index);
+  inline ::bgs::protocol::club::v1::StreamTypingIndicator* add_indicator();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamTypingIndicator >&
+      indicator() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamTypingIndicator >*
+      mutable_indicator();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamTypingIndicatorNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamTypingIndicator > indicator_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamTypingIndicatorNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamUnreadIndicatorNotification : public ::google::protobuf::Message {
+ public:
+  StreamUnreadIndicatorNotification();
+  virtual ~StreamUnreadIndicatorNotification();
+
+  StreamUnreadIndicatorNotification(const StreamUnreadIndicatorNotification& from);
+
+  inline StreamUnreadIndicatorNotification& operator=(const StreamUnreadIndicatorNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamUnreadIndicatorNotification& default_instance();
+
+  void Swap(StreamUnreadIndicatorNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamUnreadIndicatorNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamUnreadIndicatorNotification& from);
+  void MergeFrom(const StreamUnreadIndicatorNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.StreamEventTime event = 4;
+  inline bool has_event() const;
+  inline void clear_event();
+  static const int kEventFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::StreamEventTime& event() const;
+  inline ::bgs::protocol::club::v1::StreamEventTime* mutable_event();
+  inline ::bgs::protocol::club::v1::StreamEventTime* release_event();
+  inline void set_allocated_event(::bgs::protocol::club::v1::StreamEventTime* event);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamUnreadIndicatorNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_event();
+  inline void clear_has_event();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::StreamEventTime* event_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamUnreadIndicatorNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamAdvanceViewTimeNotification : public ::google::protobuf::Message {
+ public:
+  StreamAdvanceViewTimeNotification();
+  virtual ~StreamAdvanceViewTimeNotification();
+
+  StreamAdvanceViewTimeNotification(const StreamAdvanceViewTimeNotification& from);
+
+  inline StreamAdvanceViewTimeNotification& operator=(const StreamAdvanceViewTimeNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamAdvanceViewTimeNotification& default_instance();
+
+  void Swap(StreamAdvanceViewTimeNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamAdvanceViewTimeNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamAdvanceViewTimeNotification& from);
+  void MergeFrom(const StreamAdvanceViewTimeNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.club.v1.StreamAdvanceViewTime view = 4;
+  inline int view_size() const;
+  inline void clear_view();
+  static const int kViewFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::StreamAdvanceViewTime& view(int index) const;
+  inline ::bgs::protocol::club::v1::StreamAdvanceViewTime* mutable_view(int index);
+  inline ::bgs::protocol::club::v1::StreamAdvanceViewTime* add_view();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamAdvanceViewTime >&
+      view() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamAdvanceViewTime >*
+      mutable_view();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamAdvanceViewTime > view_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamAdvanceViewTimeNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubActivityNotification : public ::google::protobuf::Message {
+ public:
+  ClubActivityNotification();
+  virtual ~ClubActivityNotification();
+
+  ClubActivityNotification(const ClubActivityNotification& from);
+
+  inline ClubActivityNotification& operator=(const ClubActivityNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubActivityNotification& default_instance();
+
+  void Swap(ClubActivityNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubActivityNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubActivityNotification& from);
+  void MergeFrom(const ClubActivityNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::MemberId& subscriber_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_subscriber_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id);
+
+  // optional uint64 club_id = 3;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubActivityNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::MemberId* subscriber_id_;
+  ::google::protobuf::uint64 club_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fnotification_2eproto();
+  friend void protobuf_AssignDesc_club_5fnotification_2eproto();
+  friend void protobuf_ShutdownFile_club_5fnotification_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubActivityNotification* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// SubscribeNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SubscribeNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SubscribeNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscribeNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscribeNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscribeNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SubscribeNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscribeNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool SubscribeNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscribeNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscribeNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscribeNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SubscribeNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscribeNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscribeNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscribeNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void SubscribeNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscribeNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool SubscribeNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SubscribeNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SubscribeNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SubscribeNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SubscribeNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeNotification.club_id)
+  return club_id_;
+}
+inline void SubscribeNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SubscribeNotification.club_id)
+}
+
+// optional .bgs.protocol.club.v1.Club club = 4;
+inline bool SubscribeNotification::has_club() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SubscribeNotification::set_has_club() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SubscribeNotification::clear_has_club() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SubscribeNotification::clear_club() {
+  if (club_ != NULL) club_->::bgs::protocol::club::v1::Club::Clear();
+  clear_has_club();
+}
+inline const ::bgs::protocol::club::v1::Club& SubscribeNotification::club() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeNotification.club)
+  return club_ != NULL ? *club_ : *default_instance_->club_;
+}
+inline ::bgs::protocol::club::v1::Club* SubscribeNotification::mutable_club() {
+  set_has_club();
+  if (club_ == NULL) club_ = new ::bgs::protocol::club::v1::Club;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscribeNotification.club)
+  return club_;
+}
+inline ::bgs::protocol::club::v1::Club* SubscribeNotification::release_club() {
+  clear_has_club();
+  ::bgs::protocol::club::v1::Club* temp = club_;
+  club_ = NULL;
+  return temp;
+}
+inline void SubscribeNotification::set_allocated_club(::bgs::protocol::club::v1::Club* club) {
+  delete club_;
+  club_ = club;
+  if (club) {
+    set_has_club();
+  } else {
+    clear_has_club();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscribeNotification.club)
+}
+
+// optional .bgs.protocol.club.v1.ClubView view = 5;
+inline bool SubscribeNotification::has_view() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void SubscribeNotification::set_has_view() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void SubscribeNotification::clear_has_view() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void SubscribeNotification::clear_view() {
+  if (view_ != NULL) view_->::bgs::protocol::club::v1::ClubView::Clear();
+  clear_has_view();
+}
+inline const ::bgs::protocol::club::v1::ClubView& SubscribeNotification::view() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeNotification.view)
+  return view_ != NULL ? *view_ : *default_instance_->view_;
+}
+inline ::bgs::protocol::club::v1::ClubView* SubscribeNotification::mutable_view() {
+  set_has_view();
+  if (view_ == NULL) view_ = new ::bgs::protocol::club::v1::ClubView;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscribeNotification.view)
+  return view_;
+}
+inline ::bgs::protocol::club::v1::ClubView* SubscribeNotification::release_view() {
+  clear_has_view();
+  ::bgs::protocol::club::v1::ClubView* temp = view_;
+  view_ = NULL;
+  return temp;
+}
+inline void SubscribeNotification::set_allocated_view(::bgs::protocol::club::v1::ClubView* view) {
+  delete view_;
+  view_ = view;
+  if (view) {
+    set_has_view();
+  } else {
+    clear_has_view();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscribeNotification.view)
+}
+
+// optional .bgs.protocol.club.v1.ClubSettings settings = 10;
+inline bool SubscribeNotification::has_settings() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void SubscribeNotification::set_has_settings() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void SubscribeNotification::clear_has_settings() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void SubscribeNotification::clear_settings() {
+  if (settings_ != NULL) settings_->::bgs::protocol::club::v1::ClubSettings::Clear();
+  clear_has_settings();
+}
+inline const ::bgs::protocol::club::v1::ClubSettings& SubscribeNotification::settings() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeNotification.settings)
+  return settings_ != NULL ? *settings_ : *default_instance_->settings_;
+}
+inline ::bgs::protocol::club::v1::ClubSettings* SubscribeNotification::mutable_settings() {
+  set_has_settings();
+  if (settings_ == NULL) settings_ = new ::bgs::protocol::club::v1::ClubSettings;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscribeNotification.settings)
+  return settings_;
+}
+inline ::bgs::protocol::club::v1::ClubSettings* SubscribeNotification::release_settings() {
+  clear_has_settings();
+  ::bgs::protocol::club::v1::ClubSettings* temp = settings_;
+  settings_ = NULL;
+  return temp;
+}
+inline void SubscribeNotification::set_allocated_settings(::bgs::protocol::club::v1::ClubSettings* settings) {
+  delete settings_;
+  settings_ = settings;
+  if (settings) {
+    set_has_settings();
+  } else {
+    clear_has_settings();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscribeNotification.settings)
+}
+
+// optional .bgs.protocol.club.v1.Member member = 11;
+inline bool SubscribeNotification::has_member() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void SubscribeNotification::set_has_member() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void SubscribeNotification::clear_has_member() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void SubscribeNotification::clear_member() {
+  if (member_ != NULL) member_->::bgs::protocol::club::v1::Member::Clear();
+  clear_has_member();
+}
+inline const ::bgs::protocol::club::v1::Member& SubscribeNotification::member() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeNotification.member)
+  return member_ != NULL ? *member_ : *default_instance_->member_;
+}
+inline ::bgs::protocol::club::v1::Member* SubscribeNotification::mutable_member() {
+  set_has_member();
+  if (member_ == NULL) member_ = new ::bgs::protocol::club::v1::Member;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscribeNotification.member)
+  return member_;
+}
+inline ::bgs::protocol::club::v1::Member* SubscribeNotification::release_member() {
+  clear_has_member();
+  ::bgs::protocol::club::v1::Member* temp = member_;
+  member_ = NULL;
+  return temp;
+}
+inline void SubscribeNotification::set_allocated_member(::bgs::protocol::club::v1::Member* member) {
+  delete member_;
+  member_ = member;
+  if (member) {
+    set_has_member();
+  } else {
+    clear_has_member();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscribeNotification.member)
+}
+
+// -------------------------------------------------------------------
+
+// UnsubscribeNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool UnsubscribeNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsubscribeNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsubscribeNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsubscribeNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UnsubscribeNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnsubscribeNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnsubscribeNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UnsubscribeNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnsubscribeNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UnsubscribeNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool UnsubscribeNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnsubscribeNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnsubscribeNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnsubscribeNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UnsubscribeNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnsubscribeNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnsubscribeNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UnsubscribeNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnsubscribeNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UnsubscribeNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool UnsubscribeNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UnsubscribeNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UnsubscribeNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UnsubscribeNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 UnsubscribeNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnsubscribeNotification.club_id)
+  return club_id_;
+}
+inline void UnsubscribeNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UnsubscribeNotification.club_id)
+}
+
+// -------------------------------------------------------------------
+
+// StateChangedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StateChangedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StateChangedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StateChangedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StateChangedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StateChangedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StateChangedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StateChangedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StateChangedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StateChangedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StateChangedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StateChangedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool StateChangedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StateChangedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StateChangedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StateChangedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StateChangedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StateChangedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StateChangedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StateChangedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StateChangedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StateChangedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StateChangedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool StateChangedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StateChangedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StateChangedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StateChangedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StateChangedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StateChangedNotification.club_id)
+  return club_id_;
+}
+inline void StateChangedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StateChangedNotification.club_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubStateAssignment assignment = 5;
+inline bool StateChangedNotification::has_assignment() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StateChangedNotification::set_has_assignment() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StateChangedNotification::clear_has_assignment() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StateChangedNotification::clear_assignment() {
+  if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::ClubStateAssignment::Clear();
+  clear_has_assignment();
+}
+inline const ::bgs::protocol::club::v1::ClubStateAssignment& StateChangedNotification::assignment() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StateChangedNotification.assignment)
+  return assignment_ != NULL ? *assignment_ : *default_instance_->assignment_;
+}
+inline ::bgs::protocol::club::v1::ClubStateAssignment* StateChangedNotification::mutable_assignment() {
+  set_has_assignment();
+  if (assignment_ == NULL) assignment_ = new ::bgs::protocol::club::v1::ClubStateAssignment;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StateChangedNotification.assignment)
+  return assignment_;
+}
+inline ::bgs::protocol::club::v1::ClubStateAssignment* StateChangedNotification::release_assignment() {
+  clear_has_assignment();
+  ::bgs::protocol::club::v1::ClubStateAssignment* temp = assignment_;
+  assignment_ = NULL;
+  return temp;
+}
+inline void StateChangedNotification::set_allocated_assignment(::bgs::protocol::club::v1::ClubStateAssignment* assignment) {
+  delete assignment_;
+  assignment_ = assignment;
+  if (assignment) {
+    set_has_assignment();
+  } else {
+    clear_has_assignment();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StateChangedNotification.assignment)
+}
+
+// -------------------------------------------------------------------
+
+// SettingsChangedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SettingsChangedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SettingsChangedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SettingsChangedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SettingsChangedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SettingsChangedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SettingsChangedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SettingsChangedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SettingsChangedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SettingsChangedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SettingsChangedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SettingsChangedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool SettingsChangedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SettingsChangedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SettingsChangedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SettingsChangedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SettingsChangedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SettingsChangedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SettingsChangedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SettingsChangedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SettingsChangedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void SettingsChangedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SettingsChangedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool SettingsChangedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SettingsChangedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SettingsChangedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SettingsChangedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SettingsChangedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SettingsChangedNotification.club_id)
+  return club_id_;
+}
+inline void SettingsChangedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SettingsChangedNotification.club_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubSettingsAssignment assignment = 4;
+inline bool SettingsChangedNotification::has_assignment() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SettingsChangedNotification::set_has_assignment() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SettingsChangedNotification::clear_has_assignment() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SettingsChangedNotification::clear_assignment() {
+  if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::ClubSettingsAssignment::Clear();
+  clear_has_assignment();
+}
+inline const ::bgs::protocol::club::v1::ClubSettingsAssignment& SettingsChangedNotification::assignment() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SettingsChangedNotification.assignment)
+  return assignment_ != NULL ? *assignment_ : *default_instance_->assignment_;
+}
+inline ::bgs::protocol::club::v1::ClubSettingsAssignment* SettingsChangedNotification::mutable_assignment() {
+  set_has_assignment();
+  if (assignment_ == NULL) assignment_ = new ::bgs::protocol::club::v1::ClubSettingsAssignment;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SettingsChangedNotification.assignment)
+  return assignment_;
+}
+inline ::bgs::protocol::club::v1::ClubSettingsAssignment* SettingsChangedNotification::release_assignment() {
+  clear_has_assignment();
+  ::bgs::protocol::club::v1::ClubSettingsAssignment* temp = assignment_;
+  assignment_ = NULL;
+  return temp;
+}
+inline void SettingsChangedNotification::set_allocated_assignment(::bgs::protocol::club::v1::ClubSettingsAssignment* assignment) {
+  delete assignment_;
+  assignment_ = assignment;
+  if (assignment) {
+    set_has_assignment();
+  } else {
+    clear_has_assignment();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SettingsChangedNotification.assignment)
+}
+
+// -------------------------------------------------------------------
+
+// MemberAddedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool MemberAddedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberAddedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberAddedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberAddedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberAddedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberAddedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberAddedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberAddedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberAddedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void MemberAddedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberAddedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool MemberAddedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberAddedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberAddedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberAddedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberAddedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberAddedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberAddedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberAddedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberAddedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void MemberAddedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberAddedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool MemberAddedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberAddedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberAddedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberAddedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 MemberAddedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberAddedNotification.club_id)
+  return club_id_;
+}
+inline void MemberAddedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberAddedNotification.club_id)
+}
+
+// repeated .bgs.protocol.club.v1.Member member = 4;
+inline int MemberAddedNotification::member_size() const {
+  return member_.size();
+}
+inline void MemberAddedNotification::clear_member() {
+  member_.Clear();
+}
+inline const ::bgs::protocol::club::v1::Member& MemberAddedNotification::member(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberAddedNotification.member)
+  return member_.Get(index);
+}
+inline ::bgs::protocol::club::v1::Member* MemberAddedNotification::mutable_member(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberAddedNotification.member)
+  return member_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::Member* MemberAddedNotification::add_member() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.MemberAddedNotification.member)
+  return member_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member >&
+MemberAddedNotification::member() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.MemberAddedNotification.member)
+  return member_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member >*
+MemberAddedNotification::mutable_member() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.MemberAddedNotification.member)
+  return &member_;
+}
+
+// -------------------------------------------------------------------
+
+// MemberRemovedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool MemberRemovedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberRemovedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberRemovedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberRemovedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberRemovedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRemovedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRemovedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberRemovedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRemovedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void MemberRemovedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberRemovedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool MemberRemovedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberRemovedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberRemovedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberRemovedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberRemovedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRemovedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRemovedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberRemovedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRemovedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void MemberRemovedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberRemovedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool MemberRemovedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberRemovedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberRemovedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberRemovedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 MemberRemovedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRemovedNotification.club_id)
+  return club_id_;
+}
+inline void MemberRemovedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberRemovedNotification.club_id)
+}
+
+// repeated .bgs.protocol.club.v1.MemberRemovedAssignment member = 4;
+inline int MemberRemovedNotification::member_size() const {
+  return member_.size();
+}
+inline void MemberRemovedNotification::clear_member() {
+  member_.Clear();
+}
+inline const ::bgs::protocol::club::v1::MemberRemovedAssignment& MemberRemovedNotification::member(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRemovedNotification.member)
+  return member_.Get(index);
+}
+inline ::bgs::protocol::club::v1::MemberRemovedAssignment* MemberRemovedNotification::mutable_member(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberRemovedNotification.member)
+  return member_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::MemberRemovedAssignment* MemberRemovedNotification::add_member() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.MemberRemovedNotification.member)
+  return member_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberRemovedAssignment >&
+MemberRemovedNotification::member() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.MemberRemovedNotification.member)
+  return member_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberRemovedAssignment >*
+MemberRemovedNotification::mutable_member() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.MemberRemovedNotification.member)
+  return &member_;
+}
+
+// -------------------------------------------------------------------
+
+// MemberStateChangedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool MemberStateChangedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberStateChangedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberStateChangedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberStateChangedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberStateChangedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateChangedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberStateChangedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberStateChangedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberStateChangedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void MemberStateChangedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberStateChangedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool MemberStateChangedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberStateChangedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberStateChangedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberStateChangedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberStateChangedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateChangedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberStateChangedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberStateChangedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberStateChangedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void MemberStateChangedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberStateChangedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool MemberStateChangedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberStateChangedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberStateChangedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberStateChangedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 MemberStateChangedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateChangedNotification.club_id)
+  return club_id_;
+}
+inline void MemberStateChangedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberStateChangedNotification.club_id)
+}
+
+// repeated .bgs.protocol.club.v1.MemberStateAssignment assignment = 4;
+inline int MemberStateChangedNotification::assignment_size() const {
+  return assignment_.size();
+}
+inline void MemberStateChangedNotification::clear_assignment() {
+  assignment_.Clear();
+}
+inline const ::bgs::protocol::club::v1::MemberStateAssignment& MemberStateChangedNotification::assignment(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberStateChangedNotification.assignment)
+  return assignment_.Get(index);
+}
+inline ::bgs::protocol::club::v1::MemberStateAssignment* MemberStateChangedNotification::mutable_assignment(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberStateChangedNotification.assignment)
+  return assignment_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::MemberStateAssignment* MemberStateChangedNotification::add_assignment() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.MemberStateChangedNotification.assignment)
+  return assignment_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberStateAssignment >&
+MemberStateChangedNotification::assignment() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.MemberStateChangedNotification.assignment)
+  return assignment_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberStateAssignment >*
+MemberStateChangedNotification::mutable_assignment() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.MemberStateChangedNotification.assignment)
+  return &assignment_;
+}
+
+// -------------------------------------------------------------------
+
+// SubscriberStateChangedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SubscriberStateChangedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscriberStateChangedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscriberStateChangedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscriberStateChangedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SubscriberStateChangedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscriberStateChangedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscriberStateChangedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscriberStateChangedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscriberStateChangedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SubscriberStateChangedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscriberStateChangedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool SubscriberStateChangedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscriberStateChangedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscriberStateChangedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscriberStateChangedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SubscriberStateChangedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscriberStateChangedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscriberStateChangedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscriberStateChangedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscriberStateChangedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void SubscriberStateChangedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscriberStateChangedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool SubscriberStateChangedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SubscriberStateChangedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SubscriberStateChangedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SubscriberStateChangedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SubscriberStateChangedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscriberStateChangedNotification.club_id)
+  return club_id_;
+}
+inline void SubscriberStateChangedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SubscriberStateChangedNotification.club_id)
+}
+
+// repeated .bgs.protocol.club.v1.SubscriberStateAssignment assignment = 4;
+inline int SubscriberStateChangedNotification::assignment_size() const {
+  return assignment_.size();
+}
+inline void SubscriberStateChangedNotification::clear_assignment() {
+  assignment_.Clear();
+}
+inline const ::bgs::protocol::club::v1::SubscriberStateAssignment& SubscriberStateChangedNotification::assignment(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscriberStateChangedNotification.assignment)
+  return assignment_.Get(index);
+}
+inline ::bgs::protocol::club::v1::SubscriberStateAssignment* SubscriberStateChangedNotification::mutable_assignment(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscriberStateChangedNotification.assignment)
+  return assignment_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::SubscriberStateAssignment* SubscriberStateChangedNotification::add_assignment() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.SubscriberStateChangedNotification.assignment)
+  return assignment_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::SubscriberStateAssignment >&
+SubscriberStateChangedNotification::assignment() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.SubscriberStateChangedNotification.assignment)
+  return assignment_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::SubscriberStateAssignment >*
+SubscriberStateChangedNotification::mutable_assignment() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.SubscriberStateChangedNotification.assignment)
+  return &assignment_;
+}
+
+// -------------------------------------------------------------------
+
+// MemberRoleChangedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool MemberRoleChangedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberRoleChangedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberRoleChangedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberRoleChangedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberRoleChangedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRoleChangedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRoleChangedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberRoleChangedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRoleChangedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void MemberRoleChangedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberRoleChangedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool MemberRoleChangedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberRoleChangedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberRoleChangedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberRoleChangedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MemberRoleChangedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRoleChangedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRoleChangedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberRoleChangedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* MemberRoleChangedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void MemberRoleChangedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.MemberRoleChangedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool MemberRoleChangedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberRoleChangedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberRoleChangedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberRoleChangedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 MemberRoleChangedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRoleChangedNotification.club_id)
+  return club_id_;
+}
+inline void MemberRoleChangedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MemberRoleChangedNotification.club_id)
+}
+
+// repeated .bgs.protocol.club.v1.RoleAssignment assignment = 4;
+inline int MemberRoleChangedNotification::assignment_size() const {
+  return assignment_.size();
+}
+inline void MemberRoleChangedNotification::clear_assignment() {
+  assignment_.Clear();
+}
+inline const ::bgs::protocol::club::v1::RoleAssignment& MemberRoleChangedNotification::assignment(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MemberRoleChangedNotification.assignment)
+  return assignment_.Get(index);
+}
+inline ::bgs::protocol::club::v1::RoleAssignment* MemberRoleChangedNotification::mutable_assignment(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MemberRoleChangedNotification.assignment)
+  return assignment_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::RoleAssignment* MemberRoleChangedNotification::add_assignment() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.MemberRoleChangedNotification.assignment)
+  return assignment_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::RoleAssignment >&
+MemberRoleChangedNotification::assignment() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.MemberRoleChangedNotification.assignment)
+  return assignment_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::RoleAssignment >*
+MemberRoleChangedNotification::mutable_assignment() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.MemberRoleChangedNotification.assignment)
+  return &assignment_;
+}
+
+// -------------------------------------------------------------------
+
+// SuggestionAddedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SuggestionAddedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SuggestionAddedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SuggestionAddedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SuggestionAddedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SuggestionAddedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SuggestionAddedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SuggestionAddedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SuggestionAddedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SuggestionAddedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SuggestionAddedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SuggestionAddedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool SuggestionAddedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SuggestionAddedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SuggestionAddedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SuggestionAddedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SuggestionAddedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SuggestionAddedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SuggestionAddedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SuggestionAddedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SuggestionAddedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void SuggestionAddedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SuggestionAddedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool SuggestionAddedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SuggestionAddedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SuggestionAddedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SuggestionAddedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SuggestionAddedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SuggestionAddedNotification.club_id)
+  return club_id_;
+}
+inline void SuggestionAddedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SuggestionAddedNotification.club_id)
+}
+
+// required .bgs.protocol.club.v1.ClubSuggestion suggestion = 4;
+inline bool SuggestionAddedNotification::has_suggestion() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SuggestionAddedNotification::set_has_suggestion() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SuggestionAddedNotification::clear_has_suggestion() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SuggestionAddedNotification::clear_suggestion() {
+  if (suggestion_ != NULL) suggestion_->::bgs::protocol::club::v1::ClubSuggestion::Clear();
+  clear_has_suggestion();
+}
+inline const ::bgs::protocol::club::v1::ClubSuggestion& SuggestionAddedNotification::suggestion() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SuggestionAddedNotification.suggestion)
+  return suggestion_ != NULL ? *suggestion_ : *default_instance_->suggestion_;
+}
+inline ::bgs::protocol::club::v1::ClubSuggestion* SuggestionAddedNotification::mutable_suggestion() {
+  set_has_suggestion();
+  if (suggestion_ == NULL) suggestion_ = new ::bgs::protocol::club::v1::ClubSuggestion;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SuggestionAddedNotification.suggestion)
+  return suggestion_;
+}
+inline ::bgs::protocol::club::v1::ClubSuggestion* SuggestionAddedNotification::release_suggestion() {
+  clear_has_suggestion();
+  ::bgs::protocol::club::v1::ClubSuggestion* temp = suggestion_;
+  suggestion_ = NULL;
+  return temp;
+}
+inline void SuggestionAddedNotification::set_allocated_suggestion(::bgs::protocol::club::v1::ClubSuggestion* suggestion) {
+  delete suggestion_;
+  suggestion_ = suggestion;
+  if (suggestion) {
+    set_has_suggestion();
+  } else {
+    clear_has_suggestion();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SuggestionAddedNotification.suggestion)
+}
+
+// -------------------------------------------------------------------
+
+// SuggestionRemovedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SuggestionRemovedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SuggestionRemovedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SuggestionRemovedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SuggestionRemovedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SuggestionRemovedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SuggestionRemovedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SuggestionRemovedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SuggestionRemovedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SuggestionRemovedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SuggestionRemovedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SuggestionRemovedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool SuggestionRemovedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SuggestionRemovedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SuggestionRemovedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SuggestionRemovedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SuggestionRemovedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SuggestionRemovedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SuggestionRemovedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SuggestionRemovedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SuggestionRemovedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void SuggestionRemovedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SuggestionRemovedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool SuggestionRemovedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SuggestionRemovedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SuggestionRemovedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SuggestionRemovedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SuggestionRemovedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SuggestionRemovedNotification.club_id)
+  return club_id_;
+}
+inline void SuggestionRemovedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SuggestionRemovedNotification.club_id)
+}
+
+// optional fixed64 suggestion_id = 4;
+inline bool SuggestionRemovedNotification::has_suggestion_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SuggestionRemovedNotification::set_has_suggestion_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SuggestionRemovedNotification::clear_has_suggestion_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SuggestionRemovedNotification::clear_suggestion_id() {
+  suggestion_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_suggestion_id();
+}
+inline ::google::protobuf::uint64 SuggestionRemovedNotification::suggestion_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SuggestionRemovedNotification.suggestion_id)
+  return suggestion_id_;
+}
+inline void SuggestionRemovedNotification::set_suggestion_id(::google::protobuf::uint64 value) {
+  set_has_suggestion_id();
+  suggestion_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SuggestionRemovedNotification.suggestion_id)
+}
+
+// optional .bgs.protocol.SuggestionRemovedReason reason = 5;
+inline bool SuggestionRemovedNotification::has_reason() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void SuggestionRemovedNotification::set_has_reason() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void SuggestionRemovedNotification::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void SuggestionRemovedNotification::clear_reason() {
+  reason_ = 0;
+  clear_has_reason();
+}
+inline ::bgs::protocol::SuggestionRemovedReason SuggestionRemovedNotification::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SuggestionRemovedNotification.reason)
+  return static_cast< ::bgs::protocol::SuggestionRemovedReason >(reason_);
+}
+inline void SuggestionRemovedNotification::set_reason(::bgs::protocol::SuggestionRemovedReason value) {
+  assert(::bgs::protocol::SuggestionRemovedReason_IsValid(value));
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SuggestionRemovedNotification.reason)
+}
+
+// -------------------------------------------------------------------
+
+// StreamAddedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StreamAddedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamAddedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamAddedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamAddedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamAddedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAddedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamAddedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamAddedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamAddedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamAddedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamAddedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool StreamAddedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamAddedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamAddedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamAddedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamAddedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAddedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamAddedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamAddedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamAddedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamAddedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamAddedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool StreamAddedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamAddedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamAddedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamAddedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamAddedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAddedNotification.club_id)
+  return club_id_;
+}
+inline void StreamAddedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamAddedNotification.club_id)
+}
+
+// optional .bgs.protocol.club.v1.Stream stream = 4;
+inline bool StreamAddedNotification::has_stream() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamAddedNotification::set_has_stream() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamAddedNotification::clear_has_stream() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamAddedNotification::clear_stream() {
+  if (stream_ != NULL) stream_->::bgs::protocol::club::v1::Stream::Clear();
+  clear_has_stream();
+}
+inline const ::bgs::protocol::club::v1::Stream& StreamAddedNotification::stream() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAddedNotification.stream)
+  return stream_ != NULL ? *stream_ : *default_instance_->stream_;
+}
+inline ::bgs::protocol::club::v1::Stream* StreamAddedNotification::mutable_stream() {
+  set_has_stream();
+  if (stream_ == NULL) stream_ = new ::bgs::protocol::club::v1::Stream;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamAddedNotification.stream)
+  return stream_;
+}
+inline ::bgs::protocol::club::v1::Stream* StreamAddedNotification::release_stream() {
+  clear_has_stream();
+  ::bgs::protocol::club::v1::Stream* temp = stream_;
+  stream_ = NULL;
+  return temp;
+}
+inline void StreamAddedNotification::set_allocated_stream(::bgs::protocol::club::v1::Stream* stream) {
+  delete stream_;
+  stream_ = stream;
+  if (stream) {
+    set_has_stream();
+  } else {
+    clear_has_stream();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamAddedNotification.stream)
+}
+
+// -------------------------------------------------------------------
+
+// StreamRemovedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StreamRemovedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamRemovedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamRemovedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamRemovedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamRemovedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamRemovedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamRemovedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamRemovedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamRemovedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamRemovedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamRemovedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool StreamRemovedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamRemovedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamRemovedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamRemovedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamRemovedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamRemovedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamRemovedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamRemovedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamRemovedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamRemovedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamRemovedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool StreamRemovedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamRemovedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamRemovedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamRemovedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamRemovedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamRemovedNotification.club_id)
+  return club_id_;
+}
+inline void StreamRemovedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamRemovedNotification.club_id)
+}
+
+// optional uint64 stream_id = 4;
+inline bool StreamRemovedNotification::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamRemovedNotification::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamRemovedNotification::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamRemovedNotification::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamRemovedNotification::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamRemovedNotification.stream_id)
+  return stream_id_;
+}
+inline void StreamRemovedNotification::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamRemovedNotification.stream_id)
+}
+
+// -------------------------------------------------------------------
+
+// StreamStateChangedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StreamStateChangedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamStateChangedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamStateChangedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamStateChangedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamStateChangedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateChangedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamStateChangedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateChangedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamStateChangedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamStateChangedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamStateChangedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool StreamStateChangedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamStateChangedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamStateChangedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamStateChangedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamStateChangedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateChangedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamStateChangedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateChangedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamStateChangedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamStateChangedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamStateChangedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool StreamStateChangedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamStateChangedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamStateChangedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamStateChangedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamStateChangedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateChangedNotification.club_id)
+  return club_id_;
+}
+inline void StreamStateChangedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateChangedNotification.club_id)
+}
+
+// optional uint64 stream_id = 4;
+inline bool StreamStateChangedNotification::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamStateChangedNotification::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamStateChangedNotification::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamStateChangedNotification::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamStateChangedNotification::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateChangedNotification.stream_id)
+  return stream_id_;
+}
+inline void StreamStateChangedNotification::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateChangedNotification.stream_id)
+}
+
+// optional .bgs.protocol.club.v1.StreamStateAssignment assignment = 5;
+inline bool StreamStateChangedNotification::has_assignment() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void StreamStateChangedNotification::set_has_assignment() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void StreamStateChangedNotification::clear_has_assignment() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void StreamStateChangedNotification::clear_assignment() {
+  if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::StreamStateAssignment::Clear();
+  clear_has_assignment();
+}
+inline const ::bgs::protocol::club::v1::StreamStateAssignment& StreamStateChangedNotification::assignment() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateChangedNotification.assignment)
+  return assignment_ != NULL ? *assignment_ : *default_instance_->assignment_;
+}
+inline ::bgs::protocol::club::v1::StreamStateAssignment* StreamStateChangedNotification::mutable_assignment() {
+  set_has_assignment();
+  if (assignment_ == NULL) assignment_ = new ::bgs::protocol::club::v1::StreamStateAssignment;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateChangedNotification.assignment)
+  return assignment_;
+}
+inline ::bgs::protocol::club::v1::StreamStateAssignment* StreamStateChangedNotification::release_assignment() {
+  clear_has_assignment();
+  ::bgs::protocol::club::v1::StreamStateAssignment* temp = assignment_;
+  assignment_ = NULL;
+  return temp;
+}
+inline void StreamStateChangedNotification::set_allocated_assignment(::bgs::protocol::club::v1::StreamStateAssignment* assignment) {
+  delete assignment_;
+  assignment_ = assignment;
+  if (assignment) {
+    set_has_assignment();
+  } else {
+    clear_has_assignment();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamStateChangedNotification.assignment)
+}
+
+// -------------------------------------------------------------------
+
+// StreamMessageAddedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StreamMessageAddedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamMessageAddedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamMessageAddedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamMessageAddedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamMessageAddedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageAddedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMessageAddedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessageAddedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMessageAddedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamMessageAddedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMessageAddedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool StreamMessageAddedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamMessageAddedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamMessageAddedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamMessageAddedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamMessageAddedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageAddedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMessageAddedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessageAddedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMessageAddedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamMessageAddedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMessageAddedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool StreamMessageAddedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamMessageAddedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamMessageAddedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamMessageAddedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamMessageAddedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageAddedNotification.club_id)
+  return club_id_;
+}
+inline void StreamMessageAddedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMessageAddedNotification.club_id)
+}
+
+// optional uint64 stream_id = 4;
+inline bool StreamMessageAddedNotification::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamMessageAddedNotification::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamMessageAddedNotification::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamMessageAddedNotification::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamMessageAddedNotification::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageAddedNotification.stream_id)
+  return stream_id_;
+}
+inline void StreamMessageAddedNotification::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMessageAddedNotification.stream_id)
+}
+
+// optional .bgs.protocol.club.v1.StreamMessage message = 5;
+inline bool StreamMessageAddedNotification::has_message() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void StreamMessageAddedNotification::set_has_message() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void StreamMessageAddedNotification::clear_has_message() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void StreamMessageAddedNotification::clear_message() {
+  if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+  clear_has_message();
+}
+inline const ::bgs::protocol::club::v1::StreamMessage& StreamMessageAddedNotification::message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageAddedNotification.message)
+  return message_ != NULL ? *message_ : *default_instance_->message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* StreamMessageAddedNotification::mutable_message() {
+  set_has_message();
+  if (message_ == NULL) message_ = new ::bgs::protocol::club::v1::StreamMessage;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessageAddedNotification.message)
+  return message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* StreamMessageAddedNotification::release_message() {
+  clear_has_message();
+  ::bgs::protocol::club::v1::StreamMessage* temp = message_;
+  message_ = NULL;
+  return temp;
+}
+inline void StreamMessageAddedNotification::set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message) {
+  delete message_;
+  message_ = message;
+  if (message) {
+    set_has_message();
+  } else {
+    clear_has_message();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMessageAddedNotification.message)
+}
+
+// -------------------------------------------------------------------
+
+// StreamMessageUpdatedNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StreamMessageUpdatedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamMessageUpdatedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamMessageUpdatedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamMessageUpdatedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamMessageUpdatedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageUpdatedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMessageUpdatedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessageUpdatedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMessageUpdatedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamMessageUpdatedNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMessageUpdatedNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool StreamMessageUpdatedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamMessageUpdatedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamMessageUpdatedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamMessageUpdatedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamMessageUpdatedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageUpdatedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMessageUpdatedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessageUpdatedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMessageUpdatedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamMessageUpdatedNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMessageUpdatedNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool StreamMessageUpdatedNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamMessageUpdatedNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamMessageUpdatedNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamMessageUpdatedNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamMessageUpdatedNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageUpdatedNotification.club_id)
+  return club_id_;
+}
+inline void StreamMessageUpdatedNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMessageUpdatedNotification.club_id)
+}
+
+// optional uint64 stream_id = 4;
+inline bool StreamMessageUpdatedNotification::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamMessageUpdatedNotification::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamMessageUpdatedNotification::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamMessageUpdatedNotification::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamMessageUpdatedNotification::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageUpdatedNotification.stream_id)
+  return stream_id_;
+}
+inline void StreamMessageUpdatedNotification::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMessageUpdatedNotification.stream_id)
+}
+
+// optional .bgs.protocol.club.v1.StreamMessage message = 5;
+inline bool StreamMessageUpdatedNotification::has_message() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void StreamMessageUpdatedNotification::set_has_message() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void StreamMessageUpdatedNotification::clear_has_message() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void StreamMessageUpdatedNotification::clear_message() {
+  if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+  clear_has_message();
+}
+inline const ::bgs::protocol::club::v1::StreamMessage& StreamMessageUpdatedNotification::message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessageUpdatedNotification.message)
+  return message_ != NULL ? *message_ : *default_instance_->message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* StreamMessageUpdatedNotification::mutable_message() {
+  set_has_message();
+  if (message_ == NULL) message_ = new ::bgs::protocol::club::v1::StreamMessage;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessageUpdatedNotification.message)
+  return message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* StreamMessageUpdatedNotification::release_message() {
+  clear_has_message();
+  ::bgs::protocol::club::v1::StreamMessage* temp = message_;
+  message_ = NULL;
+  return temp;
+}
+inline void StreamMessageUpdatedNotification::set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message) {
+  delete message_;
+  message_ = message;
+  if (message) {
+    set_has_message();
+  } else {
+    clear_has_message();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMessageUpdatedNotification.message)
+}
+
+// -------------------------------------------------------------------
+
+// StreamTypingIndicatorNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StreamTypingIndicatorNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamTypingIndicatorNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamTypingIndicatorNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamTypingIndicatorNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamTypingIndicatorNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamTypingIndicatorNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamTypingIndicatorNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamTypingIndicatorNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamTypingIndicatorNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamTypingIndicatorNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamTypingIndicatorNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool StreamTypingIndicatorNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamTypingIndicatorNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamTypingIndicatorNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamTypingIndicatorNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamTypingIndicatorNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamTypingIndicatorNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamTypingIndicatorNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamTypingIndicatorNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamTypingIndicatorNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamTypingIndicatorNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamTypingIndicatorNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool StreamTypingIndicatorNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamTypingIndicatorNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamTypingIndicatorNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamTypingIndicatorNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamTypingIndicatorNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamTypingIndicatorNotification.club_id)
+  return club_id_;
+}
+inline void StreamTypingIndicatorNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamTypingIndicatorNotification.club_id)
+}
+
+// optional uint64 stream_id = 4;
+inline bool StreamTypingIndicatorNotification::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamTypingIndicatorNotification::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamTypingIndicatorNotification::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamTypingIndicatorNotification::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamTypingIndicatorNotification::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamTypingIndicatorNotification.stream_id)
+  return stream_id_;
+}
+inline void StreamTypingIndicatorNotification::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamTypingIndicatorNotification.stream_id)
+}
+
+// repeated .bgs.protocol.club.v1.StreamTypingIndicator indicator = 5;
+inline int StreamTypingIndicatorNotification::indicator_size() const {
+  return indicator_.size();
+}
+inline void StreamTypingIndicatorNotification::clear_indicator() {
+  indicator_.Clear();
+}
+inline const ::bgs::protocol::club::v1::StreamTypingIndicator& StreamTypingIndicatorNotification::indicator(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamTypingIndicatorNotification.indicator)
+  return indicator_.Get(index);
+}
+inline ::bgs::protocol::club::v1::StreamTypingIndicator* StreamTypingIndicatorNotification::mutable_indicator(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamTypingIndicatorNotification.indicator)
+  return indicator_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::StreamTypingIndicator* StreamTypingIndicatorNotification::add_indicator() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.StreamTypingIndicatorNotification.indicator)
+  return indicator_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamTypingIndicator >&
+StreamTypingIndicatorNotification::indicator() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.StreamTypingIndicatorNotification.indicator)
+  return indicator_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamTypingIndicator >*
+StreamTypingIndicatorNotification::mutable_indicator() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.StreamTypingIndicatorNotification.indicator)
+  return &indicator_;
+}
+
+// -------------------------------------------------------------------
+
+// StreamUnreadIndicatorNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StreamUnreadIndicatorNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamUnreadIndicatorNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamUnreadIndicatorNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamUnreadIndicatorNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamUnreadIndicatorNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamUnreadIndicatorNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamUnreadIndicatorNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamUnreadIndicatorNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool StreamUnreadIndicatorNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamUnreadIndicatorNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamUnreadIndicatorNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamUnreadIndicatorNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamUnreadIndicatorNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamUnreadIndicatorNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamUnreadIndicatorNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamUnreadIndicatorNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool StreamUnreadIndicatorNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamUnreadIndicatorNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamUnreadIndicatorNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamUnreadIndicatorNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamUnreadIndicatorNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.club_id)
+  return club_id_;
+}
+inline void StreamUnreadIndicatorNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.club_id)
+}
+
+// optional .bgs.protocol.club.v1.StreamEventTime event = 4;
+inline bool StreamUnreadIndicatorNotification::has_event() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamUnreadIndicatorNotification::set_has_event() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamUnreadIndicatorNotification::clear_has_event() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamUnreadIndicatorNotification::clear_event() {
+  if (event_ != NULL) event_->::bgs::protocol::club::v1::StreamEventTime::Clear();
+  clear_has_event();
+}
+inline const ::bgs::protocol::club::v1::StreamEventTime& StreamUnreadIndicatorNotification::event() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.event)
+  return event_ != NULL ? *event_ : *default_instance_->event_;
+}
+inline ::bgs::protocol::club::v1::StreamEventTime* StreamUnreadIndicatorNotification::mutable_event() {
+  set_has_event();
+  if (event_ == NULL) event_ = new ::bgs::protocol::club::v1::StreamEventTime;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.event)
+  return event_;
+}
+inline ::bgs::protocol::club::v1::StreamEventTime* StreamUnreadIndicatorNotification::release_event() {
+  clear_has_event();
+  ::bgs::protocol::club::v1::StreamEventTime* temp = event_;
+  event_ = NULL;
+  return temp;
+}
+inline void StreamUnreadIndicatorNotification::set_allocated_event(::bgs::protocol::club::v1::StreamEventTime* event) {
+  delete event_;
+  event_ = event;
+  if (event) {
+    set_has_event();
+  } else {
+    clear_has_event();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamUnreadIndicatorNotification.event)
+}
+
+// -------------------------------------------------------------------
+
+// StreamAdvanceViewTimeNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool StreamAdvanceViewTimeNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamAdvanceViewTimeNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamAdvanceViewTimeNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamAdvanceViewTimeNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamAdvanceViewTimeNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamAdvanceViewTimeNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamAdvanceViewTimeNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void StreamAdvanceViewTimeNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool StreamAdvanceViewTimeNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamAdvanceViewTimeNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamAdvanceViewTimeNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamAdvanceViewTimeNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamAdvanceViewTimeNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamAdvanceViewTimeNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamAdvanceViewTimeNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StreamAdvanceViewTimeNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool StreamAdvanceViewTimeNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamAdvanceViewTimeNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamAdvanceViewTimeNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamAdvanceViewTimeNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamAdvanceViewTimeNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.club_id)
+  return club_id_;
+}
+inline void StreamAdvanceViewTimeNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.club_id)
+}
+
+// repeated .bgs.protocol.club.v1.StreamAdvanceViewTime view = 4;
+inline int StreamAdvanceViewTimeNotification::view_size() const {
+  return view_.size();
+}
+inline void StreamAdvanceViewTimeNotification::clear_view() {
+  view_.Clear();
+}
+inline const ::bgs::protocol::club::v1::StreamAdvanceViewTime& StreamAdvanceViewTimeNotification::view(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.view)
+  return view_.Get(index);
+}
+inline ::bgs::protocol::club::v1::StreamAdvanceViewTime* StreamAdvanceViewTimeNotification::mutable_view(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.view)
+  return view_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::StreamAdvanceViewTime* StreamAdvanceViewTimeNotification::add_view() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.view)
+  return view_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamAdvanceViewTime >&
+StreamAdvanceViewTimeNotification::view() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.view)
+  return view_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamAdvanceViewTime >*
+StreamAdvanceViewTimeNotification::mutable_view() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.StreamAdvanceViewTimeNotification.view)
+  return &view_;
+}
+
+// -------------------------------------------------------------------
+
+// ClubActivityNotification
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool ClubActivityNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubActivityNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubActivityNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubActivityNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& ClubActivityNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubActivityNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubActivityNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubActivityNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubActivityNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void ClubActivityNotification::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubActivityNotification.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId subscriber_id = 2;
+inline bool ClubActivityNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubActivityNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubActivityNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubActivityNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& ClubActivityNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubActivityNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubActivityNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubActivityNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* ClubActivityNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::club::v1::MemberId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void ClubActivityNotification::set_allocated_subscriber_id(::bgs::protocol::club::v1::MemberId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubActivityNotification.subscriber_id)
+}
+
+// optional uint64 club_id = 3;
+inline bool ClubActivityNotification::has_club_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubActivityNotification::set_has_club_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubActivityNotification::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubActivityNotification::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 ClubActivityNotification::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubActivityNotification.club_id)
+  return club_id_;
+}
+inline void ClubActivityNotification::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubActivityNotification.club_id)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5fnotification_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_range_set.pb.cc b/src/server/proto/Client/club_range_set.pb.cc
new file mode 100644
index 00000000000..a6e9bb83feb
--- /dev/null
+++ b/src/server/proto/Client/club_range_set.pb.cc
@@ -0,0 +1,2612 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_range_set.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_range_set.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ClubTypeRangeSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubTypeRangeSet_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubMemberRangeSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubMemberRangeSet_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubStreamRangeSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubStreamRangeSet_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubInvitationRangeSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubInvitationRangeSet_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubSuggestionRangeSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubSuggestionRangeSet_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubTicketRangeSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubTicketRangeSet_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubBanRangeSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubBanRangeSet_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5frange_5fset_2eproto() {
+  protobuf_AddDesc_club_5frange_5fset_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_range_set.proto");
+  GOOGLE_CHECK(file != NULL);
+  ClubTypeRangeSet_descriptor_ = file->message_type(0);
+  static const int ClubTypeRangeSet_offsets_[10] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, name_range_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, description_range_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, broadcast_range_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, short_name_range_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, member_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, stream_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, suggestion_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, ticket_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, ban_),
+  };
+  ClubTypeRangeSet_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubTypeRangeSet_descriptor_,
+      ClubTypeRangeSet::default_instance_,
+      ClubTypeRangeSet_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTypeRangeSet, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubTypeRangeSet));
+  ClubMemberRangeSet_descriptor_ = file->message_type(1);
+  static const int ClubMemberRangeSet_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMemberRangeSet, count_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMemberRangeSet, voice_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMemberRangeSet, stream_subscriptions_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMemberRangeSet, note_),
+  };
+  ClubMemberRangeSet_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubMemberRangeSet_descriptor_,
+      ClubMemberRangeSet::default_instance_,
+      ClubMemberRangeSet_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMemberRangeSet, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubMemberRangeSet, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubMemberRangeSet));
+  ClubStreamRangeSet_descriptor_ = file->message_type(2);
+  static const int ClubStreamRangeSet_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStreamRangeSet, count_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStreamRangeSet, name_range_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStreamRangeSet, subject_range_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStreamRangeSet, message_range_),
+  };
+  ClubStreamRangeSet_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubStreamRangeSet_descriptor_,
+      ClubStreamRangeSet::default_instance_,
+      ClubStreamRangeSet_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStreamRangeSet, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStreamRangeSet, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubStreamRangeSet));
+  ClubInvitationRangeSet_descriptor_ = file->message_type(3);
+  static const int ClubInvitationRangeSet_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitationRangeSet, count_),
+  };
+  ClubInvitationRangeSet_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubInvitationRangeSet_descriptor_,
+      ClubInvitationRangeSet::default_instance_,
+      ClubInvitationRangeSet_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitationRangeSet, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubInvitationRangeSet, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubInvitationRangeSet));
+  ClubSuggestionRangeSet_descriptor_ = file->message_type(4);
+  static const int ClubSuggestionRangeSet_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestionRangeSet, count_),
+  };
+  ClubSuggestionRangeSet_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubSuggestionRangeSet_descriptor_,
+      ClubSuggestionRangeSet::default_instance_,
+      ClubSuggestionRangeSet_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestionRangeSet, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubSuggestionRangeSet, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubSuggestionRangeSet));
+  ClubTicketRangeSet_descriptor_ = file->message_type(5);
+  static const int ClubTicketRangeSet_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicketRangeSet, count_),
+  };
+  ClubTicketRangeSet_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubTicketRangeSet_descriptor_,
+      ClubTicketRangeSet::default_instance_,
+      ClubTicketRangeSet_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicketRangeSet, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubTicketRangeSet, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubTicketRangeSet));
+  ClubBanRangeSet_descriptor_ = file->message_type(6);
+  static const int ClubBanRangeSet_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBanRangeSet, count_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBanRangeSet, reason_range_),
+  };
+  ClubBanRangeSet_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubBanRangeSet_descriptor_,
+      ClubBanRangeSet::default_instance_,
+      ClubBanRangeSet_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBanRangeSet, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubBanRangeSet, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubBanRangeSet));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5frange_5fset_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubTypeRangeSet_descriptor_, &ClubTypeRangeSet::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubMemberRangeSet_descriptor_, &ClubMemberRangeSet::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubStreamRangeSet_descriptor_, &ClubStreamRangeSet::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubInvitationRangeSet_descriptor_, &ClubInvitationRangeSet::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubSuggestionRangeSet_descriptor_, &ClubSuggestionRangeSet::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubTicketRangeSet_descriptor_, &ClubTicketRangeSet::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubBanRangeSet_descriptor_, &ClubBanRangeSet::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5frange_5fset_2eproto() {
+  delete ClubTypeRangeSet::default_instance_;
+  delete ClubTypeRangeSet_reflection_;
+  delete ClubMemberRangeSet::default_instance_;
+  delete ClubMemberRangeSet_reflection_;
+  delete ClubStreamRangeSet::default_instance_;
+  delete ClubStreamRangeSet_reflection_;
+  delete ClubInvitationRangeSet::default_instance_;
+  delete ClubInvitationRangeSet_reflection_;
+  delete ClubSuggestionRangeSet::default_instance_;
+  delete ClubSuggestionRangeSet_reflection_;
+  delete ClubTicketRangeSet::default_instance_;
+  delete ClubTicketRangeSet_reflection_;
+  delete ClubBanRangeSet::default_instance_;
+  delete ClubBanRangeSet_reflection_;
+}
+
+void protobuf_AddDesc_club_5frange_5fset_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\024club_range_set.proto\022\024bgs.protocol.clu"
+    "b.v1\032\035global_extensions/range.proto\"\332\004\n\020"
+    "ClubTypeRangeSet\0222\n\nname_range\030\002 \001(\0132\036.b"
+    "gs.protocol.UnsignedIntRange\0229\n\021descript"
+    "ion_range\030\003 \001(\0132\036.bgs.protocol.UnsignedI"
+    "ntRange\0227\n\017broadcast_range\030\004 \001(\0132\036.bgs.p"
+    "rotocol.UnsignedIntRange\0228\n\020short_name_r"
+    "ange\030\007 \001(\0132\036.bgs.protocol.UnsignedIntRan"
+    "ge\0228\n\006member\030\031 \001(\0132(.bgs.protocol.club.v"
+    "1.ClubMemberRangeSet\0228\n\006stream\030\032 \001(\0132(.b"
+    "gs.protocol.club.v1.ClubStreamRangeSet\022@"
+    "\n\ninvitation\030\033 \001(\0132,.bgs.protocol.club.v"
+    "1.ClubInvitationRangeSet\022@\n\nsuggestion\030\034"
+    " \001(\0132,.bgs.protocol.club.v1.ClubSuggesti"
+    "onRangeSet\0228\n\006ticket\030\035 \001(\0132(.bgs.protoco"
+    "l.club.v1.ClubTicketRangeSet\0222\n\003ban\030\036 \001("
+    "\0132%.bgs.protocol.club.v1.ClubBanRangeSet"
+    "\"\336\001\n\022ClubMemberRangeSet\022-\n\005count\030\001 \001(\0132\036"
+    ".bgs.protocol.UnsignedIntRange\022-\n\005voice\030"
+    "\003 \001(\0132\036.bgs.protocol.UnsignedIntRange\022<\n"
+    "\024stream_subscriptions\030\005 \001(\0132\036.bgs.protoc"
+    "ol.UnsignedIntRange\022,\n\004note\030\007 \001(\0132\036.bgs."
+    "protocol.UnsignedIntRange\"\345\001\n\022ClubStream"
+    "RangeSet\022-\n\005count\030\001 \001(\0132\036.bgs.protocol.U"
+    "nsignedIntRange\0222\n\nname_range\030\003 \001(\0132\036.bg"
+    "s.protocol.UnsignedIntRange\0225\n\rsubject_r"
+    "ange\030\004 \001(\0132\036.bgs.protocol.UnsignedIntRan"
+    "ge\0225\n\rmessage_range\030\005 \001(\0132\036.bgs.protocol"
+    ".UnsignedIntRange\"G\n\026ClubInvitationRange"
+    "Set\022-\n\005count\030\001 \001(\0132\036.bgs.protocol.Unsign"
+    "edIntRange\"G\n\026ClubSuggestionRangeSet\022-\n\005"
+    "count\030\001 \001(\0132\036.bgs.protocol.UnsignedIntRa"
+    "nge\"C\n\022ClubTicketRangeSet\022-\n\005count\030\001 \001(\013"
+    "2\036.bgs.protocol.UnsignedIntRange\"v\n\017Club"
+    "BanRangeSet\022-\n\005count\030\001 \001(\0132\036.bgs.protoco"
+    "l.UnsignedIntRange\0224\n\014reason_range\030\003 \001(\013"
+    "2\036.bgs.protocol.UnsignedIntRangeB\002H\001", 1476);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_range_set.proto", &protobuf_RegisterTypes);
+  ClubTypeRangeSet::default_instance_ = new ClubTypeRangeSet();
+  ClubMemberRangeSet::default_instance_ = new ClubMemberRangeSet();
+  ClubStreamRangeSet::default_instance_ = new ClubStreamRangeSet();
+  ClubInvitationRangeSet::default_instance_ = new ClubInvitationRangeSet();
+  ClubSuggestionRangeSet::default_instance_ = new ClubSuggestionRangeSet();
+  ClubTicketRangeSet::default_instance_ = new ClubTicketRangeSet();
+  ClubBanRangeSet::default_instance_ = new ClubBanRangeSet();
+  ClubTypeRangeSet::default_instance_->InitAsDefaultInstance();
+  ClubMemberRangeSet::default_instance_->InitAsDefaultInstance();
+  ClubStreamRangeSet::default_instance_->InitAsDefaultInstance();
+  ClubInvitationRangeSet::default_instance_->InitAsDefaultInstance();
+  ClubSuggestionRangeSet::default_instance_->InitAsDefaultInstance();
+  ClubTicketRangeSet::default_instance_->InitAsDefaultInstance();
+  ClubBanRangeSet::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5frange_5fset_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5frange_5fset_2eproto {
+  StaticDescriptorInitializer_club_5frange_5fset_2eproto() {
+    protobuf_AddDesc_club_5frange_5fset_2eproto();
+  }
+} static_descriptor_initializer_club_5frange_5fset_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubTypeRangeSet::kNameRangeFieldNumber;
+const int ClubTypeRangeSet::kDescriptionRangeFieldNumber;
+const int ClubTypeRangeSet::kBroadcastRangeFieldNumber;
+const int ClubTypeRangeSet::kShortNameRangeFieldNumber;
+const int ClubTypeRangeSet::kMemberFieldNumber;
+const int ClubTypeRangeSet::kStreamFieldNumber;
+const int ClubTypeRangeSet::kInvitationFieldNumber;
+const int ClubTypeRangeSet::kSuggestionFieldNumber;
+const int ClubTypeRangeSet::kTicketFieldNumber;
+const int ClubTypeRangeSet::kBanFieldNumber;
+#endif  // !_MSC_VER
+
+ClubTypeRangeSet::ClubTypeRangeSet()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubTypeRangeSet)
+}
+
+void ClubTypeRangeSet::InitAsDefaultInstance() {
+  name_range_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  description_range_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  broadcast_range_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  short_name_range_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  member_ = const_cast< ::bgs::protocol::club::v1::ClubMemberRangeSet*>(&::bgs::protocol::club::v1::ClubMemberRangeSet::default_instance());
+  stream_ = const_cast< ::bgs::protocol::club::v1::ClubStreamRangeSet*>(&::bgs::protocol::club::v1::ClubStreamRangeSet::default_instance());
+  invitation_ = const_cast< ::bgs::protocol::club::v1::ClubInvitationRangeSet*>(&::bgs::protocol::club::v1::ClubInvitationRangeSet::default_instance());
+  suggestion_ = const_cast< ::bgs::protocol::club::v1::ClubSuggestionRangeSet*>(&::bgs::protocol::club::v1::ClubSuggestionRangeSet::default_instance());
+  ticket_ = const_cast< ::bgs::protocol::club::v1::ClubTicketRangeSet*>(&::bgs::protocol::club::v1::ClubTicketRangeSet::default_instance());
+  ban_ = const_cast< ::bgs::protocol::club::v1::ClubBanRangeSet*>(&::bgs::protocol::club::v1::ClubBanRangeSet::default_instance());
+}
+
+ClubTypeRangeSet::ClubTypeRangeSet(const ClubTypeRangeSet& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubTypeRangeSet)
+}
+
+void ClubTypeRangeSet::SharedCtor() {
+  _cached_size_ = 0;
+  name_range_ = NULL;
+  description_range_ = NULL;
+  broadcast_range_ = NULL;
+  short_name_range_ = NULL;
+  member_ = NULL;
+  stream_ = NULL;
+  invitation_ = NULL;
+  suggestion_ = NULL;
+  ticket_ = NULL;
+  ban_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubTypeRangeSet::~ClubTypeRangeSet() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubTypeRangeSet)
+  SharedDtor();
+}
+
+void ClubTypeRangeSet::SharedDtor() {
+  if (this != default_instance_) {
+    delete name_range_;
+    delete description_range_;
+    delete broadcast_range_;
+    delete short_name_range_;
+    delete member_;
+    delete stream_;
+    delete invitation_;
+    delete suggestion_;
+    delete ticket_;
+    delete ban_;
+  }
+}
+
+void ClubTypeRangeSet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubTypeRangeSet::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubTypeRangeSet_descriptor_;
+}
+
+const ClubTypeRangeSet& ClubTypeRangeSet::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frange_5fset_2eproto();
+  return *default_instance_;
+}
+
+ClubTypeRangeSet* ClubTypeRangeSet::default_instance_ = NULL;
+
+ClubTypeRangeSet* ClubTypeRangeSet::New() const {
+  return new ClubTypeRangeSet;
+}
+
+void ClubTypeRangeSet::Clear() {
+  if (_has_bits_[0 / 32] & 255) {
+    if (has_name_range()) {
+      if (name_range_ != NULL) name_range_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_description_range()) {
+      if (description_range_ != NULL) description_range_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_broadcast_range()) {
+      if (broadcast_range_ != NULL) broadcast_range_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_short_name_range()) {
+      if (short_name_range_ != NULL) short_name_range_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_member()) {
+      if (member_ != NULL) member_->::bgs::protocol::club::v1::ClubMemberRangeSet::Clear();
+    }
+    if (has_stream()) {
+      if (stream_ != NULL) stream_->::bgs::protocol::club::v1::ClubStreamRangeSet::Clear();
+    }
+    if (has_invitation()) {
+      if (invitation_ != NULL) invitation_->::bgs::protocol::club::v1::ClubInvitationRangeSet::Clear();
+    }
+    if (has_suggestion()) {
+      if (suggestion_ != NULL) suggestion_->::bgs::protocol::club::v1::ClubSuggestionRangeSet::Clear();
+    }
+  }
+  if (_has_bits_[8 / 32] & 768) {
+    if (has_ticket()) {
+      if (ticket_ != NULL) ticket_->::bgs::protocol::club::v1::ClubTicketRangeSet::Clear();
+    }
+    if (has_ban()) {
+      if (ban_ != NULL) ban_->::bgs::protocol::club::v1::ClubBanRangeSet::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubTypeRangeSet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubTypeRangeSet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange name_range = 2;
+      case 2: {
+        if (tag == 18) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_name_range()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_description_range;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange description_range = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_description_range:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_description_range()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_broadcast_range;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange broadcast_range = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_broadcast_range:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_broadcast_range()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_short_name_range;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange short_name_range = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_short_name_range:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_short_name_range()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(202)) goto parse_member;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubMemberRangeSet member = 25;
+      case 25: {
+        if (tag == 202) {
+         parse_member:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(210)) goto parse_stream;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubStreamRangeSet stream = 26;
+      case 26: {
+        if (tag == 210) {
+         parse_stream:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_stream()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(218)) goto parse_invitation;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubInvitationRangeSet invitation = 27;
+      case 27: {
+        if (tag == 218) {
+         parse_invitation:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_invitation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(226)) goto parse_suggestion;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSuggestionRangeSet suggestion = 28;
+      case 28: {
+        if (tag == 226) {
+         parse_suggestion:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suggestion()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(234)) goto parse_ticket;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubTicketRangeSet ticket = 29;
+      case 29: {
+        if (tag == 234) {
+         parse_ticket:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_ticket()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(242)) goto parse_ban;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubBanRangeSet ban = 30;
+      case 30: {
+        if (tag == 242) {
+         parse_ban:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_ban()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubTypeRangeSet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubTypeRangeSet)
+  return false;
+#undef DO_
+}
+
+void ClubTypeRangeSet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubTypeRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange name_range = 2;
+  if (has_name_range()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->name_range(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange description_range = 3;
+  if (has_description_range()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->description_range(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange broadcast_range = 4;
+  if (has_broadcast_range()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->broadcast_range(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange short_name_range = 7;
+  if (has_short_name_range()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->short_name_range(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubMemberRangeSet member = 25;
+  if (has_member()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      25, this->member(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubStreamRangeSet stream = 26;
+  if (has_stream()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      26, this->stream(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubInvitationRangeSet invitation = 27;
+  if (has_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      27, this->invitation(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSuggestionRangeSet suggestion = 28;
+  if (has_suggestion()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      28, this->suggestion(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubTicketRangeSet ticket = 29;
+  if (has_ticket()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      29, this->ticket(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubBanRangeSet ban = 30;
+  if (has_ban()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      30, this->ban(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubTypeRangeSet)
+}
+
+::google::protobuf::uint8* ClubTypeRangeSet::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubTypeRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange name_range = 2;
+  if (has_name_range()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->name_range(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange description_range = 3;
+  if (has_description_range()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->description_range(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange broadcast_range = 4;
+  if (has_broadcast_range()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->broadcast_range(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange short_name_range = 7;
+  if (has_short_name_range()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->short_name_range(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubMemberRangeSet member = 25;
+  if (has_member()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        25, this->member(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubStreamRangeSet stream = 26;
+  if (has_stream()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        26, this->stream(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubInvitationRangeSet invitation = 27;
+  if (has_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        27, this->invitation(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSuggestionRangeSet suggestion = 28;
+  if (has_suggestion()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        28, this->suggestion(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubTicketRangeSet ticket = 29;
+  if (has_ticket()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        29, this->ticket(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubBanRangeSet ban = 30;
+  if (has_ban()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        30, this->ban(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubTypeRangeSet)
+  return target;
+}
+
+int ClubTypeRangeSet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange name_range = 2;
+    if (has_name_range()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->name_range());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange description_range = 3;
+    if (has_description_range()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->description_range());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange broadcast_range = 4;
+    if (has_broadcast_range()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->broadcast_range());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange short_name_range = 7;
+    if (has_short_name_range()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->short_name_range());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubMemberRangeSet member = 25;
+    if (has_member()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubStreamRangeSet stream = 26;
+    if (has_stream()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->stream());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubInvitationRangeSet invitation = 27;
+    if (has_invitation()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->invitation());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSuggestionRangeSet suggestion = 28;
+    if (has_suggestion()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suggestion());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubTicketRangeSet ticket = 29;
+    if (has_ticket()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->ticket());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubBanRangeSet ban = 30;
+    if (has_ban()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->ban());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubTypeRangeSet::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubTypeRangeSet* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubTypeRangeSet*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubTypeRangeSet::MergeFrom(const ClubTypeRangeSet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name_range()) {
+      mutable_name_range()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.name_range());
+    }
+    if (from.has_description_range()) {
+      mutable_description_range()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.description_range());
+    }
+    if (from.has_broadcast_range()) {
+      mutable_broadcast_range()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.broadcast_range());
+    }
+    if (from.has_short_name_range()) {
+      mutable_short_name_range()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.short_name_range());
+    }
+    if (from.has_member()) {
+      mutable_member()->::bgs::protocol::club::v1::ClubMemberRangeSet::MergeFrom(from.member());
+    }
+    if (from.has_stream()) {
+      mutable_stream()->::bgs::protocol::club::v1::ClubStreamRangeSet::MergeFrom(from.stream());
+    }
+    if (from.has_invitation()) {
+      mutable_invitation()->::bgs::protocol::club::v1::ClubInvitationRangeSet::MergeFrom(from.invitation());
+    }
+    if (from.has_suggestion()) {
+      mutable_suggestion()->::bgs::protocol::club::v1::ClubSuggestionRangeSet::MergeFrom(from.suggestion());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_ticket()) {
+      mutable_ticket()->::bgs::protocol::club::v1::ClubTicketRangeSet::MergeFrom(from.ticket());
+    }
+    if (from.has_ban()) {
+      mutable_ban()->::bgs::protocol::club::v1::ClubBanRangeSet::MergeFrom(from.ban());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubTypeRangeSet::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubTypeRangeSet::CopyFrom(const ClubTypeRangeSet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubTypeRangeSet::IsInitialized() const {
+
+  return true;
+}
+
+void ClubTypeRangeSet::Swap(ClubTypeRangeSet* other) {
+  if (other != this) {
+    std::swap(name_range_, other->name_range_);
+    std::swap(description_range_, other->description_range_);
+    std::swap(broadcast_range_, other->broadcast_range_);
+    std::swap(short_name_range_, other->short_name_range_);
+    std::swap(member_, other->member_);
+    std::swap(stream_, other->stream_);
+    std::swap(invitation_, other->invitation_);
+    std::swap(suggestion_, other->suggestion_);
+    std::swap(ticket_, other->ticket_);
+    std::swap(ban_, other->ban_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubTypeRangeSet::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubTypeRangeSet_descriptor_;
+  metadata.reflection = ClubTypeRangeSet_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubMemberRangeSet::kCountFieldNumber;
+const int ClubMemberRangeSet::kVoiceFieldNumber;
+const int ClubMemberRangeSet::kStreamSubscriptionsFieldNumber;
+const int ClubMemberRangeSet::kNoteFieldNumber;
+#endif  // !_MSC_VER
+
+ClubMemberRangeSet::ClubMemberRangeSet()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubMemberRangeSet)
+}
+
+void ClubMemberRangeSet::InitAsDefaultInstance() {
+  count_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  voice_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  stream_subscriptions_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  note_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+}
+
+ClubMemberRangeSet::ClubMemberRangeSet(const ClubMemberRangeSet& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubMemberRangeSet)
+}
+
+void ClubMemberRangeSet::SharedCtor() {
+  _cached_size_ = 0;
+  count_ = NULL;
+  voice_ = NULL;
+  stream_subscriptions_ = NULL;
+  note_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubMemberRangeSet::~ClubMemberRangeSet() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubMemberRangeSet)
+  SharedDtor();
+}
+
+void ClubMemberRangeSet::SharedDtor() {
+  if (this != default_instance_) {
+    delete count_;
+    delete voice_;
+    delete stream_subscriptions_;
+    delete note_;
+  }
+}
+
+void ClubMemberRangeSet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubMemberRangeSet::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubMemberRangeSet_descriptor_;
+}
+
+const ClubMemberRangeSet& ClubMemberRangeSet::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frange_5fset_2eproto();
+  return *default_instance_;
+}
+
+ClubMemberRangeSet* ClubMemberRangeSet::default_instance_ = NULL;
+
+ClubMemberRangeSet* ClubMemberRangeSet::New() const {
+  return new ClubMemberRangeSet;
+}
+
+void ClubMemberRangeSet::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_count()) {
+      if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_voice()) {
+      if (voice_ != NULL) voice_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_stream_subscriptions()) {
+      if (stream_subscriptions_ != NULL) stream_subscriptions_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_note()) {
+      if (note_ != NULL) note_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubMemberRangeSet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubMemberRangeSet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange count = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_count()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_voice;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange voice = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_voice:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_voice()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_stream_subscriptions;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange stream_subscriptions = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_stream_subscriptions:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_stream_subscriptions()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_note;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange note = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_note:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_note()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubMemberRangeSet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubMemberRangeSet)
+  return false;
+#undef DO_
+}
+
+void ClubMemberRangeSet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubMemberRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->count(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange voice = 3;
+  if (has_voice()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->voice(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange stream_subscriptions = 5;
+  if (has_stream_subscriptions()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->stream_subscriptions(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange note = 7;
+  if (has_note()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->note(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubMemberRangeSet)
+}
+
+::google::protobuf::uint8* ClubMemberRangeSet::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubMemberRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->count(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange voice = 3;
+  if (has_voice()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->voice(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange stream_subscriptions = 5;
+  if (has_stream_subscriptions()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->stream_subscriptions(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange note = 7;
+  if (has_note()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->note(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubMemberRangeSet)
+  return target;
+}
+
+int ClubMemberRangeSet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange count = 1;
+    if (has_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->count());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange voice = 3;
+    if (has_voice()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->voice());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange stream_subscriptions = 5;
+    if (has_stream_subscriptions()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->stream_subscriptions());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange note = 7;
+    if (has_note()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->note());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubMemberRangeSet::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubMemberRangeSet* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubMemberRangeSet*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubMemberRangeSet::MergeFrom(const ClubMemberRangeSet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_count()) {
+      mutable_count()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.count());
+    }
+    if (from.has_voice()) {
+      mutable_voice()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.voice());
+    }
+    if (from.has_stream_subscriptions()) {
+      mutable_stream_subscriptions()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.stream_subscriptions());
+    }
+    if (from.has_note()) {
+      mutable_note()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.note());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubMemberRangeSet::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubMemberRangeSet::CopyFrom(const ClubMemberRangeSet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubMemberRangeSet::IsInitialized() const {
+
+  return true;
+}
+
+void ClubMemberRangeSet::Swap(ClubMemberRangeSet* other) {
+  if (other != this) {
+    std::swap(count_, other->count_);
+    std::swap(voice_, other->voice_);
+    std::swap(stream_subscriptions_, other->stream_subscriptions_);
+    std::swap(note_, other->note_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubMemberRangeSet::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubMemberRangeSet_descriptor_;
+  metadata.reflection = ClubMemberRangeSet_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubStreamRangeSet::kCountFieldNumber;
+const int ClubStreamRangeSet::kNameRangeFieldNumber;
+const int ClubStreamRangeSet::kSubjectRangeFieldNumber;
+const int ClubStreamRangeSet::kMessageRangeFieldNumber;
+#endif  // !_MSC_VER
+
+ClubStreamRangeSet::ClubStreamRangeSet()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubStreamRangeSet)
+}
+
+void ClubStreamRangeSet::InitAsDefaultInstance() {
+  count_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  name_range_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  subject_range_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  message_range_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+}
+
+ClubStreamRangeSet::ClubStreamRangeSet(const ClubStreamRangeSet& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubStreamRangeSet)
+}
+
+void ClubStreamRangeSet::SharedCtor() {
+  _cached_size_ = 0;
+  count_ = NULL;
+  name_range_ = NULL;
+  subject_range_ = NULL;
+  message_range_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubStreamRangeSet::~ClubStreamRangeSet() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubStreamRangeSet)
+  SharedDtor();
+}
+
+void ClubStreamRangeSet::SharedDtor() {
+  if (this != default_instance_) {
+    delete count_;
+    delete name_range_;
+    delete subject_range_;
+    delete message_range_;
+  }
+}
+
+void ClubStreamRangeSet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubStreamRangeSet::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubStreamRangeSet_descriptor_;
+}
+
+const ClubStreamRangeSet& ClubStreamRangeSet::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frange_5fset_2eproto();
+  return *default_instance_;
+}
+
+ClubStreamRangeSet* ClubStreamRangeSet::default_instance_ = NULL;
+
+ClubStreamRangeSet* ClubStreamRangeSet::New() const {
+  return new ClubStreamRangeSet;
+}
+
+void ClubStreamRangeSet::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_count()) {
+      if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_name_range()) {
+      if (name_range_ != NULL) name_range_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_subject_range()) {
+      if (subject_range_ != NULL) subject_range_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_message_range()) {
+      if (message_range_ != NULL) message_range_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubStreamRangeSet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubStreamRangeSet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange count = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_count()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_name_range;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange name_range = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_name_range:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_name_range()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_subject_range;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange subject_range = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_subject_range:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subject_range()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_message_range;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange message_range = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_message_range:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message_range()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubStreamRangeSet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubStreamRangeSet)
+  return false;
+#undef DO_
+}
+
+void ClubStreamRangeSet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubStreamRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->count(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange name_range = 3;
+  if (has_name_range()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->name_range(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange subject_range = 4;
+  if (has_subject_range()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->subject_range(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange message_range = 5;
+  if (has_message_range()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->message_range(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubStreamRangeSet)
+}
+
+::google::protobuf::uint8* ClubStreamRangeSet::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubStreamRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->count(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange name_range = 3;
+  if (has_name_range()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->name_range(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange subject_range = 4;
+  if (has_subject_range()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->subject_range(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange message_range = 5;
+  if (has_message_range()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->message_range(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubStreamRangeSet)
+  return target;
+}
+
+int ClubStreamRangeSet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange count = 1;
+    if (has_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->count());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange name_range = 3;
+    if (has_name_range()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->name_range());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange subject_range = 4;
+    if (has_subject_range()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subject_range());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange message_range = 5;
+    if (has_message_range()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message_range());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubStreamRangeSet::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubStreamRangeSet* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubStreamRangeSet*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubStreamRangeSet::MergeFrom(const ClubStreamRangeSet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_count()) {
+      mutable_count()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.count());
+    }
+    if (from.has_name_range()) {
+      mutable_name_range()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.name_range());
+    }
+    if (from.has_subject_range()) {
+      mutable_subject_range()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.subject_range());
+    }
+    if (from.has_message_range()) {
+      mutable_message_range()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.message_range());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubStreamRangeSet::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubStreamRangeSet::CopyFrom(const ClubStreamRangeSet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubStreamRangeSet::IsInitialized() const {
+
+  return true;
+}
+
+void ClubStreamRangeSet::Swap(ClubStreamRangeSet* other) {
+  if (other != this) {
+    std::swap(count_, other->count_);
+    std::swap(name_range_, other->name_range_);
+    std::swap(subject_range_, other->subject_range_);
+    std::swap(message_range_, other->message_range_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubStreamRangeSet::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubStreamRangeSet_descriptor_;
+  metadata.reflection = ClubStreamRangeSet_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubInvitationRangeSet::kCountFieldNumber;
+#endif  // !_MSC_VER
+
+ClubInvitationRangeSet::ClubInvitationRangeSet()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubInvitationRangeSet)
+}
+
+void ClubInvitationRangeSet::InitAsDefaultInstance() {
+  count_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+}
+
+ClubInvitationRangeSet::ClubInvitationRangeSet(const ClubInvitationRangeSet& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubInvitationRangeSet)
+}
+
+void ClubInvitationRangeSet::SharedCtor() {
+  _cached_size_ = 0;
+  count_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubInvitationRangeSet::~ClubInvitationRangeSet() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubInvitationRangeSet)
+  SharedDtor();
+}
+
+void ClubInvitationRangeSet::SharedDtor() {
+  if (this != default_instance_) {
+    delete count_;
+  }
+}
+
+void ClubInvitationRangeSet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubInvitationRangeSet::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubInvitationRangeSet_descriptor_;
+}
+
+const ClubInvitationRangeSet& ClubInvitationRangeSet::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frange_5fset_2eproto();
+  return *default_instance_;
+}
+
+ClubInvitationRangeSet* ClubInvitationRangeSet::default_instance_ = NULL;
+
+ClubInvitationRangeSet* ClubInvitationRangeSet::New() const {
+  return new ClubInvitationRangeSet;
+}
+
+void ClubInvitationRangeSet::Clear() {
+  if (has_count()) {
+    if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubInvitationRangeSet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubInvitationRangeSet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange count = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_count()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubInvitationRangeSet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubInvitationRangeSet)
+  return false;
+#undef DO_
+}
+
+void ClubInvitationRangeSet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubInvitationRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->count(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubInvitationRangeSet)
+}
+
+::google::protobuf::uint8* ClubInvitationRangeSet::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubInvitationRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->count(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubInvitationRangeSet)
+  return target;
+}
+
+int ClubInvitationRangeSet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange count = 1;
+    if (has_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->count());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubInvitationRangeSet::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubInvitationRangeSet* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubInvitationRangeSet*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubInvitationRangeSet::MergeFrom(const ClubInvitationRangeSet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_count()) {
+      mutable_count()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.count());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubInvitationRangeSet::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubInvitationRangeSet::CopyFrom(const ClubInvitationRangeSet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubInvitationRangeSet::IsInitialized() const {
+
+  return true;
+}
+
+void ClubInvitationRangeSet::Swap(ClubInvitationRangeSet* other) {
+  if (other != this) {
+    std::swap(count_, other->count_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubInvitationRangeSet::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubInvitationRangeSet_descriptor_;
+  metadata.reflection = ClubInvitationRangeSet_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubSuggestionRangeSet::kCountFieldNumber;
+#endif  // !_MSC_VER
+
+ClubSuggestionRangeSet::ClubSuggestionRangeSet()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+}
+
+void ClubSuggestionRangeSet::InitAsDefaultInstance() {
+  count_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+}
+
+ClubSuggestionRangeSet::ClubSuggestionRangeSet(const ClubSuggestionRangeSet& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+}
+
+void ClubSuggestionRangeSet::SharedCtor() {
+  _cached_size_ = 0;
+  count_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubSuggestionRangeSet::~ClubSuggestionRangeSet() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+  SharedDtor();
+}
+
+void ClubSuggestionRangeSet::SharedDtor() {
+  if (this != default_instance_) {
+    delete count_;
+  }
+}
+
+void ClubSuggestionRangeSet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubSuggestionRangeSet::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubSuggestionRangeSet_descriptor_;
+}
+
+const ClubSuggestionRangeSet& ClubSuggestionRangeSet::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frange_5fset_2eproto();
+  return *default_instance_;
+}
+
+ClubSuggestionRangeSet* ClubSuggestionRangeSet::default_instance_ = NULL;
+
+ClubSuggestionRangeSet* ClubSuggestionRangeSet::New() const {
+  return new ClubSuggestionRangeSet;
+}
+
+void ClubSuggestionRangeSet::Clear() {
+  if (has_count()) {
+    if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubSuggestionRangeSet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange count = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_count()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+  return false;
+#undef DO_
+}
+
+void ClubSuggestionRangeSet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->count(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+}
+
+::google::protobuf::uint8* ClubSuggestionRangeSet::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->count(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+  return target;
+}
+
+int ClubSuggestionRangeSet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange count = 1;
+    if (has_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->count());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubSuggestionRangeSet::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubSuggestionRangeSet* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubSuggestionRangeSet*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubSuggestionRangeSet::MergeFrom(const ClubSuggestionRangeSet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_count()) {
+      mutable_count()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.count());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubSuggestionRangeSet::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubSuggestionRangeSet::CopyFrom(const ClubSuggestionRangeSet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubSuggestionRangeSet::IsInitialized() const {
+
+  return true;
+}
+
+void ClubSuggestionRangeSet::Swap(ClubSuggestionRangeSet* other) {
+  if (other != this) {
+    std::swap(count_, other->count_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubSuggestionRangeSet::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubSuggestionRangeSet_descriptor_;
+  metadata.reflection = ClubSuggestionRangeSet_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubTicketRangeSet::kCountFieldNumber;
+#endif  // !_MSC_VER
+
+ClubTicketRangeSet::ClubTicketRangeSet()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubTicketRangeSet)
+}
+
+void ClubTicketRangeSet::InitAsDefaultInstance() {
+  count_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+}
+
+ClubTicketRangeSet::ClubTicketRangeSet(const ClubTicketRangeSet& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubTicketRangeSet)
+}
+
+void ClubTicketRangeSet::SharedCtor() {
+  _cached_size_ = 0;
+  count_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubTicketRangeSet::~ClubTicketRangeSet() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubTicketRangeSet)
+  SharedDtor();
+}
+
+void ClubTicketRangeSet::SharedDtor() {
+  if (this != default_instance_) {
+    delete count_;
+  }
+}
+
+void ClubTicketRangeSet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubTicketRangeSet::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubTicketRangeSet_descriptor_;
+}
+
+const ClubTicketRangeSet& ClubTicketRangeSet::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frange_5fset_2eproto();
+  return *default_instance_;
+}
+
+ClubTicketRangeSet* ClubTicketRangeSet::default_instance_ = NULL;
+
+ClubTicketRangeSet* ClubTicketRangeSet::New() const {
+  return new ClubTicketRangeSet;
+}
+
+void ClubTicketRangeSet::Clear() {
+  if (has_count()) {
+    if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubTicketRangeSet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubTicketRangeSet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange count = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_count()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubTicketRangeSet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubTicketRangeSet)
+  return false;
+#undef DO_
+}
+
+void ClubTicketRangeSet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubTicketRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->count(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubTicketRangeSet)
+}
+
+::google::protobuf::uint8* ClubTicketRangeSet::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubTicketRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->count(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubTicketRangeSet)
+  return target;
+}
+
+int ClubTicketRangeSet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange count = 1;
+    if (has_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->count());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubTicketRangeSet::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubTicketRangeSet* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubTicketRangeSet*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubTicketRangeSet::MergeFrom(const ClubTicketRangeSet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_count()) {
+      mutable_count()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.count());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubTicketRangeSet::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubTicketRangeSet::CopyFrom(const ClubTicketRangeSet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubTicketRangeSet::IsInitialized() const {
+
+  return true;
+}
+
+void ClubTicketRangeSet::Swap(ClubTicketRangeSet* other) {
+  if (other != this) {
+    std::swap(count_, other->count_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubTicketRangeSet::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubTicketRangeSet_descriptor_;
+  metadata.reflection = ClubTicketRangeSet_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubBanRangeSet::kCountFieldNumber;
+const int ClubBanRangeSet::kReasonRangeFieldNumber;
+#endif  // !_MSC_VER
+
+ClubBanRangeSet::ClubBanRangeSet()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubBanRangeSet)
+}
+
+void ClubBanRangeSet::InitAsDefaultInstance() {
+  count_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  reason_range_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+}
+
+ClubBanRangeSet::ClubBanRangeSet(const ClubBanRangeSet& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubBanRangeSet)
+}
+
+void ClubBanRangeSet::SharedCtor() {
+  _cached_size_ = 0;
+  count_ = NULL;
+  reason_range_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubBanRangeSet::~ClubBanRangeSet() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubBanRangeSet)
+  SharedDtor();
+}
+
+void ClubBanRangeSet::SharedDtor() {
+  if (this != default_instance_) {
+    delete count_;
+    delete reason_range_;
+  }
+}
+
+void ClubBanRangeSet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubBanRangeSet::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubBanRangeSet_descriptor_;
+}
+
+const ClubBanRangeSet& ClubBanRangeSet::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frange_5fset_2eproto();
+  return *default_instance_;
+}
+
+ClubBanRangeSet* ClubBanRangeSet::default_instance_ = NULL;
+
+ClubBanRangeSet* ClubBanRangeSet::New() const {
+  return new ClubBanRangeSet;
+}
+
+void ClubBanRangeSet::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_count()) {
+      if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    if (has_reason_range()) {
+      if (reason_range_ != NULL) reason_range_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubBanRangeSet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubBanRangeSet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange count = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_count()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_reason_range;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedIntRange reason_range = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_reason_range:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_reason_range()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubBanRangeSet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubBanRangeSet)
+  return false;
+#undef DO_
+}
+
+void ClubBanRangeSet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubBanRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->count(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange reason_range = 3;
+  if (has_reason_range()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->reason_range(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubBanRangeSet)
+}
+
+::google::protobuf::uint8* ClubBanRangeSet::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubBanRangeSet)
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  if (has_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->count(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedIntRange reason_range = 3;
+  if (has_reason_range()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->reason_range(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubBanRangeSet)
+  return target;
+}
+
+int ClubBanRangeSet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange count = 1;
+    if (has_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->count());
+    }
+
+    // optional .bgs.protocol.UnsignedIntRange reason_range = 3;
+    if (has_reason_range()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->reason_range());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubBanRangeSet::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubBanRangeSet* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubBanRangeSet*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubBanRangeSet::MergeFrom(const ClubBanRangeSet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_count()) {
+      mutable_count()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.count());
+    }
+    if (from.has_reason_range()) {
+      mutable_reason_range()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.reason_range());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubBanRangeSet::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubBanRangeSet::CopyFrom(const ClubBanRangeSet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubBanRangeSet::IsInitialized() const {
+
+  return true;
+}
+
+void ClubBanRangeSet::Swap(ClubBanRangeSet* other) {
+  if (other != this) {
+    std::swap(count_, other->count_);
+    std::swap(reason_range_, other->reason_range_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubBanRangeSet::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubBanRangeSet_descriptor_;
+  metadata.reflection = ClubBanRangeSet_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_range_set.pb.h b/src/server/proto/Client/club_range_set.pb.h
new file mode 100644
index 00000000000..5f54a9418b8
--- /dev/null
+++ b/src/server/proto/Client/club_range_set.pb.h
@@ -0,0 +1,1804 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_range_set.proto
+
+#ifndef PROTOBUF_club_5frange_5fset_2eproto__INCLUDED
+#define PROTOBUF_club_5frange_5fset_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "global_extensions/range.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5frange_5fset_2eproto();
+void protobuf_AssignDesc_club_5frange_5fset_2eproto();
+void protobuf_ShutdownFile_club_5frange_5fset_2eproto();
+
+class ClubTypeRangeSet;
+class ClubMemberRangeSet;
+class ClubStreamRangeSet;
+class ClubInvitationRangeSet;
+class ClubSuggestionRangeSet;
+class ClubTicketRangeSet;
+class ClubBanRangeSet;
+
+// ===================================================================
+
+class TC_PROTO_API ClubTypeRangeSet : public ::google::protobuf::Message {
+ public:
+  ClubTypeRangeSet();
+  virtual ~ClubTypeRangeSet();
+
+  ClubTypeRangeSet(const ClubTypeRangeSet& from);
+
+  inline ClubTypeRangeSet& operator=(const ClubTypeRangeSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubTypeRangeSet& default_instance();
+
+  void Swap(ClubTypeRangeSet* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubTypeRangeSet* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubTypeRangeSet& from);
+  void MergeFrom(const ClubTypeRangeSet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange name_range = 2;
+  inline bool has_name_range() const;
+  inline void clear_name_range();
+  static const int kNameRangeFieldNumber = 2;
+  inline const ::bgs::protocol::UnsignedIntRange& name_range() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_name_range();
+  inline ::bgs::protocol::UnsignedIntRange* release_name_range();
+  inline void set_allocated_name_range(::bgs::protocol::UnsignedIntRange* name_range);
+
+  // optional .bgs.protocol.UnsignedIntRange description_range = 3;
+  inline bool has_description_range() const;
+  inline void clear_description_range();
+  static const int kDescriptionRangeFieldNumber = 3;
+  inline const ::bgs::protocol::UnsignedIntRange& description_range() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_description_range();
+  inline ::bgs::protocol::UnsignedIntRange* release_description_range();
+  inline void set_allocated_description_range(::bgs::protocol::UnsignedIntRange* description_range);
+
+  // optional .bgs.protocol.UnsignedIntRange broadcast_range = 4;
+  inline bool has_broadcast_range() const;
+  inline void clear_broadcast_range();
+  static const int kBroadcastRangeFieldNumber = 4;
+  inline const ::bgs::protocol::UnsignedIntRange& broadcast_range() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_broadcast_range();
+  inline ::bgs::protocol::UnsignedIntRange* release_broadcast_range();
+  inline void set_allocated_broadcast_range(::bgs::protocol::UnsignedIntRange* broadcast_range);
+
+  // optional .bgs.protocol.UnsignedIntRange short_name_range = 7;
+  inline bool has_short_name_range() const;
+  inline void clear_short_name_range();
+  static const int kShortNameRangeFieldNumber = 7;
+  inline const ::bgs::protocol::UnsignedIntRange& short_name_range() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_short_name_range();
+  inline ::bgs::protocol::UnsignedIntRange* release_short_name_range();
+  inline void set_allocated_short_name_range(::bgs::protocol::UnsignedIntRange* short_name_range);
+
+  // optional .bgs.protocol.club.v1.ClubMemberRangeSet member = 25;
+  inline bool has_member() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 25;
+  inline const ::bgs::protocol::club::v1::ClubMemberRangeSet& member() const;
+  inline ::bgs::protocol::club::v1::ClubMemberRangeSet* mutable_member();
+  inline ::bgs::protocol::club::v1::ClubMemberRangeSet* release_member();
+  inline void set_allocated_member(::bgs::protocol::club::v1::ClubMemberRangeSet* member);
+
+  // optional .bgs.protocol.club.v1.ClubStreamRangeSet stream = 26;
+  inline bool has_stream() const;
+  inline void clear_stream();
+  static const int kStreamFieldNumber = 26;
+  inline const ::bgs::protocol::club::v1::ClubStreamRangeSet& stream() const;
+  inline ::bgs::protocol::club::v1::ClubStreamRangeSet* mutable_stream();
+  inline ::bgs::protocol::club::v1::ClubStreamRangeSet* release_stream();
+  inline void set_allocated_stream(::bgs::protocol::club::v1::ClubStreamRangeSet* stream);
+
+  // optional .bgs.protocol.club.v1.ClubInvitationRangeSet invitation = 27;
+  inline bool has_invitation() const;
+  inline void clear_invitation();
+  static const int kInvitationFieldNumber = 27;
+  inline const ::bgs::protocol::club::v1::ClubInvitationRangeSet& invitation() const;
+  inline ::bgs::protocol::club::v1::ClubInvitationRangeSet* mutable_invitation();
+  inline ::bgs::protocol::club::v1::ClubInvitationRangeSet* release_invitation();
+  inline void set_allocated_invitation(::bgs::protocol::club::v1::ClubInvitationRangeSet* invitation);
+
+  // optional .bgs.protocol.club.v1.ClubSuggestionRangeSet suggestion = 28;
+  inline bool has_suggestion() const;
+  inline void clear_suggestion();
+  static const int kSuggestionFieldNumber = 28;
+  inline const ::bgs::protocol::club::v1::ClubSuggestionRangeSet& suggestion() const;
+  inline ::bgs::protocol::club::v1::ClubSuggestionRangeSet* mutable_suggestion();
+  inline ::bgs::protocol::club::v1::ClubSuggestionRangeSet* release_suggestion();
+  inline void set_allocated_suggestion(::bgs::protocol::club::v1::ClubSuggestionRangeSet* suggestion);
+
+  // optional .bgs.protocol.club.v1.ClubTicketRangeSet ticket = 29;
+  inline bool has_ticket() const;
+  inline void clear_ticket();
+  static const int kTicketFieldNumber = 29;
+  inline const ::bgs::protocol::club::v1::ClubTicketRangeSet& ticket() const;
+  inline ::bgs::protocol::club::v1::ClubTicketRangeSet* mutable_ticket();
+  inline ::bgs::protocol::club::v1::ClubTicketRangeSet* release_ticket();
+  inline void set_allocated_ticket(::bgs::protocol::club::v1::ClubTicketRangeSet* ticket);
+
+  // optional .bgs.protocol.club.v1.ClubBanRangeSet ban = 30;
+  inline bool has_ban() const;
+  inline void clear_ban();
+  static const int kBanFieldNumber = 30;
+  inline const ::bgs::protocol::club::v1::ClubBanRangeSet& ban() const;
+  inline ::bgs::protocol::club::v1::ClubBanRangeSet* mutable_ban();
+  inline ::bgs::protocol::club::v1::ClubBanRangeSet* release_ban();
+  inline void set_allocated_ban(::bgs::protocol::club::v1::ClubBanRangeSet* ban);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubTypeRangeSet)
+ private:
+  inline void set_has_name_range();
+  inline void clear_has_name_range();
+  inline void set_has_description_range();
+  inline void clear_has_description_range();
+  inline void set_has_broadcast_range();
+  inline void clear_has_broadcast_range();
+  inline void set_has_short_name_range();
+  inline void clear_has_short_name_range();
+  inline void set_has_member();
+  inline void clear_has_member();
+  inline void set_has_stream();
+  inline void clear_has_stream();
+  inline void set_has_invitation();
+  inline void clear_has_invitation();
+  inline void set_has_suggestion();
+  inline void clear_has_suggestion();
+  inline void set_has_ticket();
+  inline void clear_has_ticket();
+  inline void set_has_ban();
+  inline void clear_has_ban();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* name_range_;
+  ::bgs::protocol::UnsignedIntRange* description_range_;
+  ::bgs::protocol::UnsignedIntRange* broadcast_range_;
+  ::bgs::protocol::UnsignedIntRange* short_name_range_;
+  ::bgs::protocol::club::v1::ClubMemberRangeSet* member_;
+  ::bgs::protocol::club::v1::ClubStreamRangeSet* stream_;
+  ::bgs::protocol::club::v1::ClubInvitationRangeSet* invitation_;
+  ::bgs::protocol::club::v1::ClubSuggestionRangeSet* suggestion_;
+  ::bgs::protocol::club::v1::ClubTicketRangeSet* ticket_;
+  ::bgs::protocol::club::v1::ClubBanRangeSet* ban_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_AssignDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_ShutdownFile_club_5frange_5fset_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubTypeRangeSet* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubMemberRangeSet : public ::google::protobuf::Message {
+ public:
+  ClubMemberRangeSet();
+  virtual ~ClubMemberRangeSet();
+
+  ClubMemberRangeSet(const ClubMemberRangeSet& from);
+
+  inline ClubMemberRangeSet& operator=(const ClubMemberRangeSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubMemberRangeSet& default_instance();
+
+  void Swap(ClubMemberRangeSet* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubMemberRangeSet* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubMemberRangeSet& from);
+  void MergeFrom(const ClubMemberRangeSet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  inline bool has_count() const;
+  inline void clear_count();
+  static const int kCountFieldNumber = 1;
+  inline const ::bgs::protocol::UnsignedIntRange& count() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_count();
+  inline ::bgs::protocol::UnsignedIntRange* release_count();
+  inline void set_allocated_count(::bgs::protocol::UnsignedIntRange* count);
+
+  // optional .bgs.protocol.UnsignedIntRange voice = 3;
+  inline bool has_voice() const;
+  inline void clear_voice();
+  static const int kVoiceFieldNumber = 3;
+  inline const ::bgs::protocol::UnsignedIntRange& voice() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_voice();
+  inline ::bgs::protocol::UnsignedIntRange* release_voice();
+  inline void set_allocated_voice(::bgs::protocol::UnsignedIntRange* voice);
+
+  // optional .bgs.protocol.UnsignedIntRange stream_subscriptions = 5;
+  inline bool has_stream_subscriptions() const;
+  inline void clear_stream_subscriptions();
+  static const int kStreamSubscriptionsFieldNumber = 5;
+  inline const ::bgs::protocol::UnsignedIntRange& stream_subscriptions() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_stream_subscriptions();
+  inline ::bgs::protocol::UnsignedIntRange* release_stream_subscriptions();
+  inline void set_allocated_stream_subscriptions(::bgs::protocol::UnsignedIntRange* stream_subscriptions);
+
+  // optional .bgs.protocol.UnsignedIntRange note = 7;
+  inline bool has_note() const;
+  inline void clear_note();
+  static const int kNoteFieldNumber = 7;
+  inline const ::bgs::protocol::UnsignedIntRange& note() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_note();
+  inline ::bgs::protocol::UnsignedIntRange* release_note();
+  inline void set_allocated_note(::bgs::protocol::UnsignedIntRange* note);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubMemberRangeSet)
+ private:
+  inline void set_has_count();
+  inline void clear_has_count();
+  inline void set_has_voice();
+  inline void clear_has_voice();
+  inline void set_has_stream_subscriptions();
+  inline void clear_has_stream_subscriptions();
+  inline void set_has_note();
+  inline void clear_has_note();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* count_;
+  ::bgs::protocol::UnsignedIntRange* voice_;
+  ::bgs::protocol::UnsignedIntRange* stream_subscriptions_;
+  ::bgs::protocol::UnsignedIntRange* note_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_AssignDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_ShutdownFile_club_5frange_5fset_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubMemberRangeSet* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubStreamRangeSet : public ::google::protobuf::Message {
+ public:
+  ClubStreamRangeSet();
+  virtual ~ClubStreamRangeSet();
+
+  ClubStreamRangeSet(const ClubStreamRangeSet& from);
+
+  inline ClubStreamRangeSet& operator=(const ClubStreamRangeSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubStreamRangeSet& default_instance();
+
+  void Swap(ClubStreamRangeSet* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubStreamRangeSet* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubStreamRangeSet& from);
+  void MergeFrom(const ClubStreamRangeSet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  inline bool has_count() const;
+  inline void clear_count();
+  static const int kCountFieldNumber = 1;
+  inline const ::bgs::protocol::UnsignedIntRange& count() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_count();
+  inline ::bgs::protocol::UnsignedIntRange* release_count();
+  inline void set_allocated_count(::bgs::protocol::UnsignedIntRange* count);
+
+  // optional .bgs.protocol.UnsignedIntRange name_range = 3;
+  inline bool has_name_range() const;
+  inline void clear_name_range();
+  static const int kNameRangeFieldNumber = 3;
+  inline const ::bgs::protocol::UnsignedIntRange& name_range() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_name_range();
+  inline ::bgs::protocol::UnsignedIntRange* release_name_range();
+  inline void set_allocated_name_range(::bgs::protocol::UnsignedIntRange* name_range);
+
+  // optional .bgs.protocol.UnsignedIntRange subject_range = 4;
+  inline bool has_subject_range() const;
+  inline void clear_subject_range();
+  static const int kSubjectRangeFieldNumber = 4;
+  inline const ::bgs::protocol::UnsignedIntRange& subject_range() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_subject_range();
+  inline ::bgs::protocol::UnsignedIntRange* release_subject_range();
+  inline void set_allocated_subject_range(::bgs::protocol::UnsignedIntRange* subject_range);
+
+  // optional .bgs.protocol.UnsignedIntRange message_range = 5;
+  inline bool has_message_range() const;
+  inline void clear_message_range();
+  static const int kMessageRangeFieldNumber = 5;
+  inline const ::bgs::protocol::UnsignedIntRange& message_range() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_message_range();
+  inline ::bgs::protocol::UnsignedIntRange* release_message_range();
+  inline void set_allocated_message_range(::bgs::protocol::UnsignedIntRange* message_range);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubStreamRangeSet)
+ private:
+  inline void set_has_count();
+  inline void clear_has_count();
+  inline void set_has_name_range();
+  inline void clear_has_name_range();
+  inline void set_has_subject_range();
+  inline void clear_has_subject_range();
+  inline void set_has_message_range();
+  inline void clear_has_message_range();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* count_;
+  ::bgs::protocol::UnsignedIntRange* name_range_;
+  ::bgs::protocol::UnsignedIntRange* subject_range_;
+  ::bgs::protocol::UnsignedIntRange* message_range_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_AssignDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_ShutdownFile_club_5frange_5fset_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubStreamRangeSet* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubInvitationRangeSet : public ::google::protobuf::Message {
+ public:
+  ClubInvitationRangeSet();
+  virtual ~ClubInvitationRangeSet();
+
+  ClubInvitationRangeSet(const ClubInvitationRangeSet& from);
+
+  inline ClubInvitationRangeSet& operator=(const ClubInvitationRangeSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubInvitationRangeSet& default_instance();
+
+  void Swap(ClubInvitationRangeSet* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubInvitationRangeSet* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubInvitationRangeSet& from);
+  void MergeFrom(const ClubInvitationRangeSet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  inline bool has_count() const;
+  inline void clear_count();
+  static const int kCountFieldNumber = 1;
+  inline const ::bgs::protocol::UnsignedIntRange& count() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_count();
+  inline ::bgs::protocol::UnsignedIntRange* release_count();
+  inline void set_allocated_count(::bgs::protocol::UnsignedIntRange* count);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubInvitationRangeSet)
+ private:
+  inline void set_has_count();
+  inline void clear_has_count();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* count_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_AssignDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_ShutdownFile_club_5frange_5fset_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubInvitationRangeSet* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubSuggestionRangeSet : public ::google::protobuf::Message {
+ public:
+  ClubSuggestionRangeSet();
+  virtual ~ClubSuggestionRangeSet();
+
+  ClubSuggestionRangeSet(const ClubSuggestionRangeSet& from);
+
+  inline ClubSuggestionRangeSet& operator=(const ClubSuggestionRangeSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubSuggestionRangeSet& default_instance();
+
+  void Swap(ClubSuggestionRangeSet* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubSuggestionRangeSet* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubSuggestionRangeSet& from);
+  void MergeFrom(const ClubSuggestionRangeSet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  inline bool has_count() const;
+  inline void clear_count();
+  static const int kCountFieldNumber = 1;
+  inline const ::bgs::protocol::UnsignedIntRange& count() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_count();
+  inline ::bgs::protocol::UnsignedIntRange* release_count();
+  inline void set_allocated_count(::bgs::protocol::UnsignedIntRange* count);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubSuggestionRangeSet)
+ private:
+  inline void set_has_count();
+  inline void clear_has_count();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* count_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_AssignDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_ShutdownFile_club_5frange_5fset_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubSuggestionRangeSet* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubTicketRangeSet : public ::google::protobuf::Message {
+ public:
+  ClubTicketRangeSet();
+  virtual ~ClubTicketRangeSet();
+
+  ClubTicketRangeSet(const ClubTicketRangeSet& from);
+
+  inline ClubTicketRangeSet& operator=(const ClubTicketRangeSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubTicketRangeSet& default_instance();
+
+  void Swap(ClubTicketRangeSet* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubTicketRangeSet* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubTicketRangeSet& from);
+  void MergeFrom(const ClubTicketRangeSet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  inline bool has_count() const;
+  inline void clear_count();
+  static const int kCountFieldNumber = 1;
+  inline const ::bgs::protocol::UnsignedIntRange& count() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_count();
+  inline ::bgs::protocol::UnsignedIntRange* release_count();
+  inline void set_allocated_count(::bgs::protocol::UnsignedIntRange* count);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubTicketRangeSet)
+ private:
+  inline void set_has_count();
+  inline void clear_has_count();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* count_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_AssignDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_ShutdownFile_club_5frange_5fset_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubTicketRangeSet* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubBanRangeSet : public ::google::protobuf::Message {
+ public:
+  ClubBanRangeSet();
+  virtual ~ClubBanRangeSet();
+
+  ClubBanRangeSet(const ClubBanRangeSet& from);
+
+  inline ClubBanRangeSet& operator=(const ClubBanRangeSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubBanRangeSet& default_instance();
+
+  void Swap(ClubBanRangeSet* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubBanRangeSet* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubBanRangeSet& from);
+  void MergeFrom(const ClubBanRangeSet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange count = 1;
+  inline bool has_count() const;
+  inline void clear_count();
+  static const int kCountFieldNumber = 1;
+  inline const ::bgs::protocol::UnsignedIntRange& count() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_count();
+  inline ::bgs::protocol::UnsignedIntRange* release_count();
+  inline void set_allocated_count(::bgs::protocol::UnsignedIntRange* count);
+
+  // optional .bgs.protocol.UnsignedIntRange reason_range = 3;
+  inline bool has_reason_range() const;
+  inline void clear_reason_range();
+  static const int kReasonRangeFieldNumber = 3;
+  inline const ::bgs::protocol::UnsignedIntRange& reason_range() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_reason_range();
+  inline ::bgs::protocol::UnsignedIntRange* release_reason_range();
+  inline void set_allocated_reason_range(::bgs::protocol::UnsignedIntRange* reason_range);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubBanRangeSet)
+ private:
+  inline void set_has_count();
+  inline void clear_has_count();
+  inline void set_has_reason_range();
+  inline void clear_has_reason_range();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* count_;
+  ::bgs::protocol::UnsignedIntRange* reason_range_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_AssignDesc_club_5frange_5fset_2eproto();
+  friend void protobuf_ShutdownFile_club_5frange_5fset_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubBanRangeSet* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ClubTypeRangeSet
+
+// optional .bgs.protocol.UnsignedIntRange name_range = 2;
+inline bool ClubTypeRangeSet::has_name_range() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_name_range() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubTypeRangeSet::clear_has_name_range() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubTypeRangeSet::clear_name_range() {
+  if (name_range_ != NULL) name_range_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_name_range();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubTypeRangeSet::name_range() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.name_range)
+  return name_range_ != NULL ? *name_range_ : *default_instance_->name_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTypeRangeSet::mutable_name_range() {
+  set_has_name_range();
+  if (name_range_ == NULL) name_range_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.name_range)
+  return name_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTypeRangeSet::release_name_range() {
+  clear_has_name_range();
+  ::bgs::protocol::UnsignedIntRange* temp = name_range_;
+  name_range_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_name_range(::bgs::protocol::UnsignedIntRange* name_range) {
+  delete name_range_;
+  name_range_ = name_range;
+  if (name_range) {
+    set_has_name_range();
+  } else {
+    clear_has_name_range();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.name_range)
+}
+
+// optional .bgs.protocol.UnsignedIntRange description_range = 3;
+inline bool ClubTypeRangeSet::has_description_range() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_description_range() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubTypeRangeSet::clear_has_description_range() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubTypeRangeSet::clear_description_range() {
+  if (description_range_ != NULL) description_range_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_description_range();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubTypeRangeSet::description_range() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.description_range)
+  return description_range_ != NULL ? *description_range_ : *default_instance_->description_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTypeRangeSet::mutable_description_range() {
+  set_has_description_range();
+  if (description_range_ == NULL) description_range_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.description_range)
+  return description_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTypeRangeSet::release_description_range() {
+  clear_has_description_range();
+  ::bgs::protocol::UnsignedIntRange* temp = description_range_;
+  description_range_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_description_range(::bgs::protocol::UnsignedIntRange* description_range) {
+  delete description_range_;
+  description_range_ = description_range;
+  if (description_range) {
+    set_has_description_range();
+  } else {
+    clear_has_description_range();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.description_range)
+}
+
+// optional .bgs.protocol.UnsignedIntRange broadcast_range = 4;
+inline bool ClubTypeRangeSet::has_broadcast_range() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_broadcast_range() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubTypeRangeSet::clear_has_broadcast_range() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubTypeRangeSet::clear_broadcast_range() {
+  if (broadcast_range_ != NULL) broadcast_range_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_broadcast_range();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubTypeRangeSet::broadcast_range() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.broadcast_range)
+  return broadcast_range_ != NULL ? *broadcast_range_ : *default_instance_->broadcast_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTypeRangeSet::mutable_broadcast_range() {
+  set_has_broadcast_range();
+  if (broadcast_range_ == NULL) broadcast_range_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.broadcast_range)
+  return broadcast_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTypeRangeSet::release_broadcast_range() {
+  clear_has_broadcast_range();
+  ::bgs::protocol::UnsignedIntRange* temp = broadcast_range_;
+  broadcast_range_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_broadcast_range(::bgs::protocol::UnsignedIntRange* broadcast_range) {
+  delete broadcast_range_;
+  broadcast_range_ = broadcast_range;
+  if (broadcast_range) {
+    set_has_broadcast_range();
+  } else {
+    clear_has_broadcast_range();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.broadcast_range)
+}
+
+// optional .bgs.protocol.UnsignedIntRange short_name_range = 7;
+inline bool ClubTypeRangeSet::has_short_name_range() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_short_name_range() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubTypeRangeSet::clear_has_short_name_range() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubTypeRangeSet::clear_short_name_range() {
+  if (short_name_range_ != NULL) short_name_range_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_short_name_range();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubTypeRangeSet::short_name_range() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.short_name_range)
+  return short_name_range_ != NULL ? *short_name_range_ : *default_instance_->short_name_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTypeRangeSet::mutable_short_name_range() {
+  set_has_short_name_range();
+  if (short_name_range_ == NULL) short_name_range_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.short_name_range)
+  return short_name_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTypeRangeSet::release_short_name_range() {
+  clear_has_short_name_range();
+  ::bgs::protocol::UnsignedIntRange* temp = short_name_range_;
+  short_name_range_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_short_name_range(::bgs::protocol::UnsignedIntRange* short_name_range) {
+  delete short_name_range_;
+  short_name_range_ = short_name_range;
+  if (short_name_range) {
+    set_has_short_name_range();
+  } else {
+    clear_has_short_name_range();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.short_name_range)
+}
+
+// optional .bgs.protocol.club.v1.ClubMemberRangeSet member = 25;
+inline bool ClubTypeRangeSet::has_member() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_member() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubTypeRangeSet::clear_has_member() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubTypeRangeSet::clear_member() {
+  if (member_ != NULL) member_->::bgs::protocol::club::v1::ClubMemberRangeSet::Clear();
+  clear_has_member();
+}
+inline const ::bgs::protocol::club::v1::ClubMemberRangeSet& ClubTypeRangeSet::member() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.member)
+  return member_ != NULL ? *member_ : *default_instance_->member_;
+}
+inline ::bgs::protocol::club::v1::ClubMemberRangeSet* ClubTypeRangeSet::mutable_member() {
+  set_has_member();
+  if (member_ == NULL) member_ = new ::bgs::protocol::club::v1::ClubMemberRangeSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.member)
+  return member_;
+}
+inline ::bgs::protocol::club::v1::ClubMemberRangeSet* ClubTypeRangeSet::release_member() {
+  clear_has_member();
+  ::bgs::protocol::club::v1::ClubMemberRangeSet* temp = member_;
+  member_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_member(::bgs::protocol::club::v1::ClubMemberRangeSet* member) {
+  delete member_;
+  member_ = member;
+  if (member) {
+    set_has_member();
+  } else {
+    clear_has_member();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.member)
+}
+
+// optional .bgs.protocol.club.v1.ClubStreamRangeSet stream = 26;
+inline bool ClubTypeRangeSet::has_stream() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_stream() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClubTypeRangeSet::clear_has_stream() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClubTypeRangeSet::clear_stream() {
+  if (stream_ != NULL) stream_->::bgs::protocol::club::v1::ClubStreamRangeSet::Clear();
+  clear_has_stream();
+}
+inline const ::bgs::protocol::club::v1::ClubStreamRangeSet& ClubTypeRangeSet::stream() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.stream)
+  return stream_ != NULL ? *stream_ : *default_instance_->stream_;
+}
+inline ::bgs::protocol::club::v1::ClubStreamRangeSet* ClubTypeRangeSet::mutable_stream() {
+  set_has_stream();
+  if (stream_ == NULL) stream_ = new ::bgs::protocol::club::v1::ClubStreamRangeSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.stream)
+  return stream_;
+}
+inline ::bgs::protocol::club::v1::ClubStreamRangeSet* ClubTypeRangeSet::release_stream() {
+  clear_has_stream();
+  ::bgs::protocol::club::v1::ClubStreamRangeSet* temp = stream_;
+  stream_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_stream(::bgs::protocol::club::v1::ClubStreamRangeSet* stream) {
+  delete stream_;
+  stream_ = stream;
+  if (stream) {
+    set_has_stream();
+  } else {
+    clear_has_stream();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.stream)
+}
+
+// optional .bgs.protocol.club.v1.ClubInvitationRangeSet invitation = 27;
+inline bool ClubTypeRangeSet::has_invitation() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_invitation() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClubTypeRangeSet::clear_has_invitation() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClubTypeRangeSet::clear_invitation() {
+  if (invitation_ != NULL) invitation_->::bgs::protocol::club::v1::ClubInvitationRangeSet::Clear();
+  clear_has_invitation();
+}
+inline const ::bgs::protocol::club::v1::ClubInvitationRangeSet& ClubTypeRangeSet::invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.invitation)
+  return invitation_ != NULL ? *invitation_ : *default_instance_->invitation_;
+}
+inline ::bgs::protocol::club::v1::ClubInvitationRangeSet* ClubTypeRangeSet::mutable_invitation() {
+  set_has_invitation();
+  if (invitation_ == NULL) invitation_ = new ::bgs::protocol::club::v1::ClubInvitationRangeSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.invitation)
+  return invitation_;
+}
+inline ::bgs::protocol::club::v1::ClubInvitationRangeSet* ClubTypeRangeSet::release_invitation() {
+  clear_has_invitation();
+  ::bgs::protocol::club::v1::ClubInvitationRangeSet* temp = invitation_;
+  invitation_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_invitation(::bgs::protocol::club::v1::ClubInvitationRangeSet* invitation) {
+  delete invitation_;
+  invitation_ = invitation;
+  if (invitation) {
+    set_has_invitation();
+  } else {
+    clear_has_invitation();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.invitation)
+}
+
+// optional .bgs.protocol.club.v1.ClubSuggestionRangeSet suggestion = 28;
+inline bool ClubTypeRangeSet::has_suggestion() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_suggestion() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClubTypeRangeSet::clear_has_suggestion() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClubTypeRangeSet::clear_suggestion() {
+  if (suggestion_ != NULL) suggestion_->::bgs::protocol::club::v1::ClubSuggestionRangeSet::Clear();
+  clear_has_suggestion();
+}
+inline const ::bgs::protocol::club::v1::ClubSuggestionRangeSet& ClubTypeRangeSet::suggestion() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.suggestion)
+  return suggestion_ != NULL ? *suggestion_ : *default_instance_->suggestion_;
+}
+inline ::bgs::protocol::club::v1::ClubSuggestionRangeSet* ClubTypeRangeSet::mutable_suggestion() {
+  set_has_suggestion();
+  if (suggestion_ == NULL) suggestion_ = new ::bgs::protocol::club::v1::ClubSuggestionRangeSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.suggestion)
+  return suggestion_;
+}
+inline ::bgs::protocol::club::v1::ClubSuggestionRangeSet* ClubTypeRangeSet::release_suggestion() {
+  clear_has_suggestion();
+  ::bgs::protocol::club::v1::ClubSuggestionRangeSet* temp = suggestion_;
+  suggestion_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_suggestion(::bgs::protocol::club::v1::ClubSuggestionRangeSet* suggestion) {
+  delete suggestion_;
+  suggestion_ = suggestion;
+  if (suggestion) {
+    set_has_suggestion();
+  } else {
+    clear_has_suggestion();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.suggestion)
+}
+
+// optional .bgs.protocol.club.v1.ClubTicketRangeSet ticket = 29;
+inline bool ClubTypeRangeSet::has_ticket() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_ticket() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ClubTypeRangeSet::clear_has_ticket() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ClubTypeRangeSet::clear_ticket() {
+  if (ticket_ != NULL) ticket_->::bgs::protocol::club::v1::ClubTicketRangeSet::Clear();
+  clear_has_ticket();
+}
+inline const ::bgs::protocol::club::v1::ClubTicketRangeSet& ClubTypeRangeSet::ticket() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.ticket)
+  return ticket_ != NULL ? *ticket_ : *default_instance_->ticket_;
+}
+inline ::bgs::protocol::club::v1::ClubTicketRangeSet* ClubTypeRangeSet::mutable_ticket() {
+  set_has_ticket();
+  if (ticket_ == NULL) ticket_ = new ::bgs::protocol::club::v1::ClubTicketRangeSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.ticket)
+  return ticket_;
+}
+inline ::bgs::protocol::club::v1::ClubTicketRangeSet* ClubTypeRangeSet::release_ticket() {
+  clear_has_ticket();
+  ::bgs::protocol::club::v1::ClubTicketRangeSet* temp = ticket_;
+  ticket_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_ticket(::bgs::protocol::club::v1::ClubTicketRangeSet* ticket) {
+  delete ticket_;
+  ticket_ = ticket;
+  if (ticket) {
+    set_has_ticket();
+  } else {
+    clear_has_ticket();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.ticket)
+}
+
+// optional .bgs.protocol.club.v1.ClubBanRangeSet ban = 30;
+inline bool ClubTypeRangeSet::has_ban() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ClubTypeRangeSet::set_has_ban() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ClubTypeRangeSet::clear_has_ban() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ClubTypeRangeSet::clear_ban() {
+  if (ban_ != NULL) ban_->::bgs::protocol::club::v1::ClubBanRangeSet::Clear();
+  clear_has_ban();
+}
+inline const ::bgs::protocol::club::v1::ClubBanRangeSet& ClubTypeRangeSet::ban() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTypeRangeSet.ban)
+  return ban_ != NULL ? *ban_ : *default_instance_->ban_;
+}
+inline ::bgs::protocol::club::v1::ClubBanRangeSet* ClubTypeRangeSet::mutable_ban() {
+  set_has_ban();
+  if (ban_ == NULL) ban_ = new ::bgs::protocol::club::v1::ClubBanRangeSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTypeRangeSet.ban)
+  return ban_;
+}
+inline ::bgs::protocol::club::v1::ClubBanRangeSet* ClubTypeRangeSet::release_ban() {
+  clear_has_ban();
+  ::bgs::protocol::club::v1::ClubBanRangeSet* temp = ban_;
+  ban_ = NULL;
+  return temp;
+}
+inline void ClubTypeRangeSet::set_allocated_ban(::bgs::protocol::club::v1::ClubBanRangeSet* ban) {
+  delete ban_;
+  ban_ = ban;
+  if (ban) {
+    set_has_ban();
+  } else {
+    clear_has_ban();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTypeRangeSet.ban)
+}
+
+// -------------------------------------------------------------------
+
+// ClubMemberRangeSet
+
+// optional .bgs.protocol.UnsignedIntRange count = 1;
+inline bool ClubMemberRangeSet::has_count() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubMemberRangeSet::set_has_count() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubMemberRangeSet::clear_has_count() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubMemberRangeSet::clear_count() {
+  if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_count();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubMemberRangeSet::count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMemberRangeSet.count)
+  return count_ != NULL ? *count_ : *default_instance_->count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubMemberRangeSet::mutable_count() {
+  set_has_count();
+  if (count_ == NULL) count_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMemberRangeSet.count)
+  return count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubMemberRangeSet::release_count() {
+  clear_has_count();
+  ::bgs::protocol::UnsignedIntRange* temp = count_;
+  count_ = NULL;
+  return temp;
+}
+inline void ClubMemberRangeSet::set_allocated_count(::bgs::protocol::UnsignedIntRange* count) {
+  delete count_;
+  count_ = count;
+  if (count) {
+    set_has_count();
+  } else {
+    clear_has_count();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubMemberRangeSet.count)
+}
+
+// optional .bgs.protocol.UnsignedIntRange voice = 3;
+inline bool ClubMemberRangeSet::has_voice() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubMemberRangeSet::set_has_voice() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubMemberRangeSet::clear_has_voice() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubMemberRangeSet::clear_voice() {
+  if (voice_ != NULL) voice_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_voice();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubMemberRangeSet::voice() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMemberRangeSet.voice)
+  return voice_ != NULL ? *voice_ : *default_instance_->voice_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubMemberRangeSet::mutable_voice() {
+  set_has_voice();
+  if (voice_ == NULL) voice_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMemberRangeSet.voice)
+  return voice_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubMemberRangeSet::release_voice() {
+  clear_has_voice();
+  ::bgs::protocol::UnsignedIntRange* temp = voice_;
+  voice_ = NULL;
+  return temp;
+}
+inline void ClubMemberRangeSet::set_allocated_voice(::bgs::protocol::UnsignedIntRange* voice) {
+  delete voice_;
+  voice_ = voice;
+  if (voice) {
+    set_has_voice();
+  } else {
+    clear_has_voice();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubMemberRangeSet.voice)
+}
+
+// optional .bgs.protocol.UnsignedIntRange stream_subscriptions = 5;
+inline bool ClubMemberRangeSet::has_stream_subscriptions() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubMemberRangeSet::set_has_stream_subscriptions() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubMemberRangeSet::clear_has_stream_subscriptions() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubMemberRangeSet::clear_stream_subscriptions() {
+  if (stream_subscriptions_ != NULL) stream_subscriptions_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_stream_subscriptions();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubMemberRangeSet::stream_subscriptions() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMemberRangeSet.stream_subscriptions)
+  return stream_subscriptions_ != NULL ? *stream_subscriptions_ : *default_instance_->stream_subscriptions_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubMemberRangeSet::mutable_stream_subscriptions() {
+  set_has_stream_subscriptions();
+  if (stream_subscriptions_ == NULL) stream_subscriptions_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMemberRangeSet.stream_subscriptions)
+  return stream_subscriptions_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubMemberRangeSet::release_stream_subscriptions() {
+  clear_has_stream_subscriptions();
+  ::bgs::protocol::UnsignedIntRange* temp = stream_subscriptions_;
+  stream_subscriptions_ = NULL;
+  return temp;
+}
+inline void ClubMemberRangeSet::set_allocated_stream_subscriptions(::bgs::protocol::UnsignedIntRange* stream_subscriptions) {
+  delete stream_subscriptions_;
+  stream_subscriptions_ = stream_subscriptions;
+  if (stream_subscriptions) {
+    set_has_stream_subscriptions();
+  } else {
+    clear_has_stream_subscriptions();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubMemberRangeSet.stream_subscriptions)
+}
+
+// optional .bgs.protocol.UnsignedIntRange note = 7;
+inline bool ClubMemberRangeSet::has_note() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubMemberRangeSet::set_has_note() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubMemberRangeSet::clear_has_note() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubMemberRangeSet::clear_note() {
+  if (note_ != NULL) note_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_note();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubMemberRangeSet::note() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubMemberRangeSet.note)
+  return note_ != NULL ? *note_ : *default_instance_->note_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubMemberRangeSet::mutable_note() {
+  set_has_note();
+  if (note_ == NULL) note_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubMemberRangeSet.note)
+  return note_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubMemberRangeSet::release_note() {
+  clear_has_note();
+  ::bgs::protocol::UnsignedIntRange* temp = note_;
+  note_ = NULL;
+  return temp;
+}
+inline void ClubMemberRangeSet::set_allocated_note(::bgs::protocol::UnsignedIntRange* note) {
+  delete note_;
+  note_ = note;
+  if (note) {
+    set_has_note();
+  } else {
+    clear_has_note();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubMemberRangeSet.note)
+}
+
+// -------------------------------------------------------------------
+
+// ClubStreamRangeSet
+
+// optional .bgs.protocol.UnsignedIntRange count = 1;
+inline bool ClubStreamRangeSet::has_count() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubStreamRangeSet::set_has_count() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubStreamRangeSet::clear_has_count() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubStreamRangeSet::clear_count() {
+  if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_count();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubStreamRangeSet::count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStreamRangeSet.count)
+  return count_ != NULL ? *count_ : *default_instance_->count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubStreamRangeSet::mutable_count() {
+  set_has_count();
+  if (count_ == NULL) count_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStreamRangeSet.count)
+  return count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubStreamRangeSet::release_count() {
+  clear_has_count();
+  ::bgs::protocol::UnsignedIntRange* temp = count_;
+  count_ = NULL;
+  return temp;
+}
+inline void ClubStreamRangeSet::set_allocated_count(::bgs::protocol::UnsignedIntRange* count) {
+  delete count_;
+  count_ = count;
+  if (count) {
+    set_has_count();
+  } else {
+    clear_has_count();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStreamRangeSet.count)
+}
+
+// optional .bgs.protocol.UnsignedIntRange name_range = 3;
+inline bool ClubStreamRangeSet::has_name_range() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubStreamRangeSet::set_has_name_range() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubStreamRangeSet::clear_has_name_range() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubStreamRangeSet::clear_name_range() {
+  if (name_range_ != NULL) name_range_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_name_range();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubStreamRangeSet::name_range() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStreamRangeSet.name_range)
+  return name_range_ != NULL ? *name_range_ : *default_instance_->name_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubStreamRangeSet::mutable_name_range() {
+  set_has_name_range();
+  if (name_range_ == NULL) name_range_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStreamRangeSet.name_range)
+  return name_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubStreamRangeSet::release_name_range() {
+  clear_has_name_range();
+  ::bgs::protocol::UnsignedIntRange* temp = name_range_;
+  name_range_ = NULL;
+  return temp;
+}
+inline void ClubStreamRangeSet::set_allocated_name_range(::bgs::protocol::UnsignedIntRange* name_range) {
+  delete name_range_;
+  name_range_ = name_range;
+  if (name_range) {
+    set_has_name_range();
+  } else {
+    clear_has_name_range();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStreamRangeSet.name_range)
+}
+
+// optional .bgs.protocol.UnsignedIntRange subject_range = 4;
+inline bool ClubStreamRangeSet::has_subject_range() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubStreamRangeSet::set_has_subject_range() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubStreamRangeSet::clear_has_subject_range() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubStreamRangeSet::clear_subject_range() {
+  if (subject_range_ != NULL) subject_range_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_subject_range();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubStreamRangeSet::subject_range() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStreamRangeSet.subject_range)
+  return subject_range_ != NULL ? *subject_range_ : *default_instance_->subject_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubStreamRangeSet::mutable_subject_range() {
+  set_has_subject_range();
+  if (subject_range_ == NULL) subject_range_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStreamRangeSet.subject_range)
+  return subject_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubStreamRangeSet::release_subject_range() {
+  clear_has_subject_range();
+  ::bgs::protocol::UnsignedIntRange* temp = subject_range_;
+  subject_range_ = NULL;
+  return temp;
+}
+inline void ClubStreamRangeSet::set_allocated_subject_range(::bgs::protocol::UnsignedIntRange* subject_range) {
+  delete subject_range_;
+  subject_range_ = subject_range;
+  if (subject_range) {
+    set_has_subject_range();
+  } else {
+    clear_has_subject_range();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStreamRangeSet.subject_range)
+}
+
+// optional .bgs.protocol.UnsignedIntRange message_range = 5;
+inline bool ClubStreamRangeSet::has_message_range() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubStreamRangeSet::set_has_message_range() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubStreamRangeSet::clear_has_message_range() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubStreamRangeSet::clear_message_range() {
+  if (message_range_ != NULL) message_range_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_message_range();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubStreamRangeSet::message_range() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStreamRangeSet.message_range)
+  return message_range_ != NULL ? *message_range_ : *default_instance_->message_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubStreamRangeSet::mutable_message_range() {
+  set_has_message_range();
+  if (message_range_ == NULL) message_range_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStreamRangeSet.message_range)
+  return message_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubStreamRangeSet::release_message_range() {
+  clear_has_message_range();
+  ::bgs::protocol::UnsignedIntRange* temp = message_range_;
+  message_range_ = NULL;
+  return temp;
+}
+inline void ClubStreamRangeSet::set_allocated_message_range(::bgs::protocol::UnsignedIntRange* message_range) {
+  delete message_range_;
+  message_range_ = message_range;
+  if (message_range) {
+    set_has_message_range();
+  } else {
+    clear_has_message_range();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubStreamRangeSet.message_range)
+}
+
+// -------------------------------------------------------------------
+
+// ClubInvitationRangeSet
+
+// optional .bgs.protocol.UnsignedIntRange count = 1;
+inline bool ClubInvitationRangeSet::has_count() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubInvitationRangeSet::set_has_count() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubInvitationRangeSet::clear_has_count() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubInvitationRangeSet::clear_count() {
+  if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_count();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubInvitationRangeSet::count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubInvitationRangeSet.count)
+  return count_ != NULL ? *count_ : *default_instance_->count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubInvitationRangeSet::mutable_count() {
+  set_has_count();
+  if (count_ == NULL) count_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubInvitationRangeSet.count)
+  return count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubInvitationRangeSet::release_count() {
+  clear_has_count();
+  ::bgs::protocol::UnsignedIntRange* temp = count_;
+  count_ = NULL;
+  return temp;
+}
+inline void ClubInvitationRangeSet::set_allocated_count(::bgs::protocol::UnsignedIntRange* count) {
+  delete count_;
+  count_ = count;
+  if (count) {
+    set_has_count();
+  } else {
+    clear_has_count();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubInvitationRangeSet.count)
+}
+
+// -------------------------------------------------------------------
+
+// ClubSuggestionRangeSet
+
+// optional .bgs.protocol.UnsignedIntRange count = 1;
+inline bool ClubSuggestionRangeSet::has_count() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubSuggestionRangeSet::set_has_count() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubSuggestionRangeSet::clear_has_count() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubSuggestionRangeSet::clear_count() {
+  if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_count();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubSuggestionRangeSet::count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubSuggestionRangeSet.count)
+  return count_ != NULL ? *count_ : *default_instance_->count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubSuggestionRangeSet::mutable_count() {
+  set_has_count();
+  if (count_ == NULL) count_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubSuggestionRangeSet.count)
+  return count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubSuggestionRangeSet::release_count() {
+  clear_has_count();
+  ::bgs::protocol::UnsignedIntRange* temp = count_;
+  count_ = NULL;
+  return temp;
+}
+inline void ClubSuggestionRangeSet::set_allocated_count(::bgs::protocol::UnsignedIntRange* count) {
+  delete count_;
+  count_ = count;
+  if (count) {
+    set_has_count();
+  } else {
+    clear_has_count();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubSuggestionRangeSet.count)
+}
+
+// -------------------------------------------------------------------
+
+// ClubTicketRangeSet
+
+// optional .bgs.protocol.UnsignedIntRange count = 1;
+inline bool ClubTicketRangeSet::has_count() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubTicketRangeSet::set_has_count() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubTicketRangeSet::clear_has_count() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubTicketRangeSet::clear_count() {
+  if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_count();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubTicketRangeSet::count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubTicketRangeSet.count)
+  return count_ != NULL ? *count_ : *default_instance_->count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTicketRangeSet::mutable_count() {
+  set_has_count();
+  if (count_ == NULL) count_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubTicketRangeSet.count)
+  return count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubTicketRangeSet::release_count() {
+  clear_has_count();
+  ::bgs::protocol::UnsignedIntRange* temp = count_;
+  count_ = NULL;
+  return temp;
+}
+inline void ClubTicketRangeSet::set_allocated_count(::bgs::protocol::UnsignedIntRange* count) {
+  delete count_;
+  count_ = count;
+  if (count) {
+    set_has_count();
+  } else {
+    clear_has_count();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubTicketRangeSet.count)
+}
+
+// -------------------------------------------------------------------
+
+// ClubBanRangeSet
+
+// optional .bgs.protocol.UnsignedIntRange count = 1;
+inline bool ClubBanRangeSet::has_count() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubBanRangeSet::set_has_count() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubBanRangeSet::clear_has_count() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubBanRangeSet::clear_count() {
+  if (count_ != NULL) count_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_count();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubBanRangeSet::count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubBanRangeSet.count)
+  return count_ != NULL ? *count_ : *default_instance_->count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubBanRangeSet::mutable_count() {
+  set_has_count();
+  if (count_ == NULL) count_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubBanRangeSet.count)
+  return count_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubBanRangeSet::release_count() {
+  clear_has_count();
+  ::bgs::protocol::UnsignedIntRange* temp = count_;
+  count_ = NULL;
+  return temp;
+}
+inline void ClubBanRangeSet::set_allocated_count(::bgs::protocol::UnsignedIntRange* count) {
+  delete count_;
+  count_ = count;
+  if (count) {
+    set_has_count();
+  } else {
+    clear_has_count();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubBanRangeSet.count)
+}
+
+// optional .bgs.protocol.UnsignedIntRange reason_range = 3;
+inline bool ClubBanRangeSet::has_reason_range() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubBanRangeSet::set_has_reason_range() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubBanRangeSet::clear_has_reason_range() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubBanRangeSet::clear_reason_range() {
+  if (reason_range_ != NULL) reason_range_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_reason_range();
+}
+inline const ::bgs::protocol::UnsignedIntRange& ClubBanRangeSet::reason_range() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubBanRangeSet.reason_range)
+  return reason_range_ != NULL ? *reason_range_ : *default_instance_->reason_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubBanRangeSet::mutable_reason_range() {
+  set_has_reason_range();
+  if (reason_range_ == NULL) reason_range_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubBanRangeSet.reason_range)
+  return reason_range_;
+}
+inline ::bgs::protocol::UnsignedIntRange* ClubBanRangeSet::release_reason_range() {
+  clear_has_reason_range();
+  ::bgs::protocol::UnsignedIntRange* temp = reason_range_;
+  reason_range_ = NULL;
+  return temp;
+}
+inline void ClubBanRangeSet::set_allocated_reason_range(::bgs::protocol::UnsignedIntRange* reason_range) {
+  delete reason_range_;
+  reason_range_ = reason_range;
+  if (reason_range) {
+    set_has_reason_range();
+  } else {
+    clear_has_reason_range();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubBanRangeSet.reason_range)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5frange_5fset_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_request.pb.cc b/src/server/proto/Client/club_request.pb.cc
new file mode 100644
index 00000000000..6e4a77acf58
--- /dev/null
+++ b/src/server/proto/Client/club_request.pb.cc
@@ -0,0 +1,26125 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_request.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_request.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* SubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnsubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DestroyRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DestroyRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetDescriptionRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetDescriptionRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetDescriptionResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetDescriptionResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetClubTypeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetClubTypeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetClubTypeResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetClubTypeResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateClubStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateClubStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateClubSettingsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateClubSettingsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* JoinRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  JoinRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* LeaveRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  LeaveRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* KickRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  KickRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetMemberRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetMemberRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetMemberResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetMemberResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetMembersRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetMembersRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetMembersResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetMembersResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateMemberStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateMemberStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateSubscriberStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateSubscriberStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AssignRoleRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AssignRoleRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnassignRoleRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnassignRoleRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AcceptInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AcceptInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DeclineInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DeclineInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RevokeInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RevokeInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetInvitationResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetInvitationResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetInvitationsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetInvitationsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetInvitationsResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetInvitationsResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendSuggestionRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendSuggestionRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AcceptSuggestionRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AcceptSuggestionRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DeclineSuggestionRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DeclineSuggestionRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetSuggestionRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetSuggestionRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetSuggestionResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetSuggestionResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetSuggestionsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetSuggestionsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetSuggestionsResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetSuggestionsResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateTicketRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateTicketRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateTicketResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateTicketResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DestroyTicketRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DestroyTicketRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RedeemTicketRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RedeemTicketRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetTicketRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetTicketRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetTicketResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetTicketResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetTicketsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetTicketsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetTicketsResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetTicketsResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AddBanRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AddBanRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RemoveBanRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RemoveBanRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetBanRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetBanRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetBanResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetBanResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetBansRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetBansRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetBansResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetBansResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscribeStreamRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeStreamRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnsubscribeStreamRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsubscribeStreamRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateStreamRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateStreamRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DestroyStreamRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DestroyStreamRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamsResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamsResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateStreamStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateStreamStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SetStreamFocusRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SetStreamFocusRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateMessageRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateMessageRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateMessageResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateMessageResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DestroyMessageRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DestroyMessageRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DestroyMessageResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DestroyMessageResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* EditMessageRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  EditMessageRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* EditMessageResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  EditMessageResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SetMessagePinnedRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SetMessagePinnedRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SetTypingIndicatorRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SetTypingIndicatorRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AdvanceStreamViewTimeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AdvanceStreamViewTimeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AdvanceStreamMentionViewTimeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AdvanceStreamMentionViewTimeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AdvanceActivityViewTimeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AdvanceActivityViewTimeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamHistoryRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamHistoryRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamHistoryResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamHistoryResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetClubActivityRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetClubActivityRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetClubActivityResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetClubActivityResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamVoiceTokenRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamVoiceTokenRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetStreamVoiceTokenResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetStreamVoiceTokenResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* KickFromStreamVoiceRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  KickFromStreamVoiceRequest_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5frequest_2eproto() {
+  protobuf_AddDesc_club_5frequest_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_request.proto");
+  GOOGLE_CHECK(file != NULL);
+  SubscribeRequest_descriptor_ = file->message_type(0);
+  static const int SubscribeRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, club_id_),
+  };
+  SubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeRequest_descriptor_,
+      SubscribeRequest::default_instance_,
+      SubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeRequest));
+  UnsubscribeRequest_descriptor_ = file->message_type(1);
+  static const int UnsubscribeRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, club_id_),
+  };
+  UnsubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsubscribeRequest_descriptor_,
+      UnsubscribeRequest::default_instance_,
+      UnsubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsubscribeRequest));
+  CreateRequest_descriptor_ = file->message_type(2);
+  static const int CreateRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateRequest, options_),
+  };
+  CreateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateRequest_descriptor_,
+      CreateRequest::default_instance_,
+      CreateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateRequest));
+  CreateResponse_descriptor_ = file->message_type(3);
+  static const int CreateResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateResponse, club_id_),
+  };
+  CreateResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateResponse_descriptor_,
+      CreateResponse::default_instance_,
+      CreateResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateResponse));
+  DestroyRequest_descriptor_ = file->message_type(4);
+  static const int DestroyRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyRequest, club_id_),
+  };
+  DestroyRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DestroyRequest_descriptor_,
+      DestroyRequest::default_instance_,
+      DestroyRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DestroyRequest));
+  GetDescriptionRequest_descriptor_ = file->message_type(5);
+  static const int GetDescriptionRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetDescriptionRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetDescriptionRequest, club_id_),
+  };
+  GetDescriptionRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetDescriptionRequest_descriptor_,
+      GetDescriptionRequest::default_instance_,
+      GetDescriptionRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetDescriptionRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetDescriptionRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetDescriptionRequest));
+  GetDescriptionResponse_descriptor_ = file->message_type(6);
+  static const int GetDescriptionResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetDescriptionResponse, club_),
+  };
+  GetDescriptionResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetDescriptionResponse_descriptor_,
+      GetDescriptionResponse::default_instance_,
+      GetDescriptionResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetDescriptionResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetDescriptionResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetDescriptionResponse));
+  GetClubTypeRequest_descriptor_ = file->message_type(7);
+  static const int GetClubTypeRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubTypeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubTypeRequest, type_),
+  };
+  GetClubTypeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetClubTypeRequest_descriptor_,
+      GetClubTypeRequest::default_instance_,
+      GetClubTypeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubTypeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubTypeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetClubTypeRequest));
+  GetClubTypeResponse_descriptor_ = file->message_type(8);
+  static const int GetClubTypeResponse_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubTypeResponse, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubTypeResponse, role_set_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubTypeResponse, range_set_),
+  };
+  GetClubTypeResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetClubTypeResponse_descriptor_,
+      GetClubTypeResponse::default_instance_,
+      GetClubTypeResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubTypeResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubTypeResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetClubTypeResponse));
+  UpdateClubStateRequest_descriptor_ = file->message_type(9);
+  static const int UpdateClubStateRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubStateRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubStateRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubStateRequest, options_),
+  };
+  UpdateClubStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateClubStateRequest_descriptor_,
+      UpdateClubStateRequest::default_instance_,
+      UpdateClubStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateClubStateRequest));
+  UpdateClubSettingsRequest_descriptor_ = file->message_type(10);
+  static const int UpdateClubSettingsRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubSettingsRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubSettingsRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubSettingsRequest, options_),
+  };
+  UpdateClubSettingsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateClubSettingsRequest_descriptor_,
+      UpdateClubSettingsRequest::default_instance_,
+      UpdateClubSettingsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubSettingsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateClubSettingsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateClubSettingsRequest));
+  JoinRequest_descriptor_ = file->message_type(11);
+  static const int JoinRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinRequest, options_),
+  };
+  JoinRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      JoinRequest_descriptor_,
+      JoinRequest::default_instance_,
+      JoinRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(JoinRequest));
+  LeaveRequest_descriptor_ = file->message_type(12);
+  static const int LeaveRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveRequest, club_id_),
+  };
+  LeaveRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      LeaveRequest_descriptor_,
+      LeaveRequest::default_instance_,
+      LeaveRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(LeaveRequest));
+  KickRequest_descriptor_ = file->message_type(13);
+  static const int KickRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickRequest, target_id_),
+  };
+  KickRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      KickRequest_descriptor_,
+      KickRequest::default_instance_,
+      KickRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(KickRequest));
+  GetMemberRequest_descriptor_ = file->message_type(14);
+  static const int GetMemberRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMemberRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMemberRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMemberRequest, member_id_),
+  };
+  GetMemberRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetMemberRequest_descriptor_,
+      GetMemberRequest::default_instance_,
+      GetMemberRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMemberRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMemberRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetMemberRequest));
+  GetMemberResponse_descriptor_ = file->message_type(15);
+  static const int GetMemberResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMemberResponse, member_),
+  };
+  GetMemberResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetMemberResponse_descriptor_,
+      GetMemberResponse::default_instance_,
+      GetMemberResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMemberResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMemberResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetMemberResponse));
+  GetMembersRequest_descriptor_ = file->message_type(16);
+  static const int GetMembersRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMembersRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMembersRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMembersRequest, continuation_),
+  };
+  GetMembersRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetMembersRequest_descriptor_,
+      GetMembersRequest::default_instance_,
+      GetMembersRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMembersRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMembersRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetMembersRequest));
+  GetMembersResponse_descriptor_ = file->message_type(17);
+  static const int GetMembersResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMembersResponse, member_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMembersResponse, continuation_),
+  };
+  GetMembersResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetMembersResponse_descriptor_,
+      GetMembersResponse::default_instance_,
+      GetMembersResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMembersResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetMembersResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetMembersResponse));
+  UpdateMemberStateRequest_descriptor_ = file->message_type(18);
+  static const int UpdateMemberStateRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, options_),
+  };
+  UpdateMemberStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateMemberStateRequest_descriptor_,
+      UpdateMemberStateRequest::default_instance_,
+      UpdateMemberStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateMemberStateRequest));
+  UpdateSubscriberStateRequest_descriptor_ = file->message_type(19);
+  static const int UpdateSubscriberStateRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateSubscriberStateRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateSubscriberStateRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateSubscriberStateRequest, options_),
+  };
+  UpdateSubscriberStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateSubscriberStateRequest_descriptor_,
+      UpdateSubscriberStateRequest::default_instance_,
+      UpdateSubscriberStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateSubscriberStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateSubscriberStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateSubscriberStateRequest));
+  AssignRoleRequest_descriptor_ = file->message_type(20);
+  static const int AssignRoleRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, assignment_),
+  };
+  AssignRoleRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AssignRoleRequest_descriptor_,
+      AssignRoleRequest::default_instance_,
+      AssignRoleRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AssignRoleRequest));
+  UnassignRoleRequest_descriptor_ = file->message_type(21);
+  static const int UnassignRoleRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnassignRoleRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnassignRoleRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnassignRoleRequest, assignment_),
+  };
+  UnassignRoleRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnassignRoleRequest_descriptor_,
+      UnassignRoleRequest::default_instance_,
+      UnassignRoleRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnassignRoleRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnassignRoleRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnassignRoleRequest));
+  SendInvitationRequest_descriptor_ = file->message_type(22);
+  static const int SendInvitationRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, options_),
+  };
+  SendInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendInvitationRequest_descriptor_,
+      SendInvitationRequest::default_instance_,
+      SendInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendInvitationRequest));
+  AcceptInvitationRequest_descriptor_ = file->message_type(23);
+  static const int AcceptInvitationRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, invitation_id_),
+  };
+  AcceptInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AcceptInvitationRequest_descriptor_,
+      AcceptInvitationRequest::default_instance_,
+      AcceptInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AcceptInvitationRequest));
+  DeclineInvitationRequest_descriptor_ = file->message_type(24);
+  static const int DeclineInvitationRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineInvitationRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineInvitationRequest, invitation_id_),
+  };
+  DeclineInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DeclineInvitationRequest_descriptor_,
+      DeclineInvitationRequest::default_instance_,
+      DeclineInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DeclineInvitationRequest));
+  RevokeInvitationRequest_descriptor_ = file->message_type(25);
+  static const int RevokeInvitationRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeInvitationRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeInvitationRequest, invitation_id_),
+  };
+  RevokeInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RevokeInvitationRequest_descriptor_,
+      RevokeInvitationRequest::default_instance_,
+      RevokeInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RevokeInvitationRequest));
+  GetInvitationRequest_descriptor_ = file->message_type(26);
+  static const int GetInvitationRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationRequest, invitation_id_),
+  };
+  GetInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetInvitationRequest_descriptor_,
+      GetInvitationRequest::default_instance_,
+      GetInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetInvitationRequest));
+  GetInvitationResponse_descriptor_ = file->message_type(27);
+  static const int GetInvitationResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationResponse, invitation_),
+  };
+  GetInvitationResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetInvitationResponse_descriptor_,
+      GetInvitationResponse::default_instance_,
+      GetInvitationResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetInvitationResponse));
+  GetInvitationsRequest_descriptor_ = file->message_type(28);
+  static const int GetInvitationsRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationsRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationsRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationsRequest, continuation_),
+  };
+  GetInvitationsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetInvitationsRequest_descriptor_,
+      GetInvitationsRequest::default_instance_,
+      GetInvitationsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetInvitationsRequest));
+  GetInvitationsResponse_descriptor_ = file->message_type(29);
+  static const int GetInvitationsResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationsResponse, invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationsResponse, continuation_),
+  };
+  GetInvitationsResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetInvitationsResponse_descriptor_,
+      GetInvitationsResponse::default_instance_,
+      GetInvitationsResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationsResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetInvitationsResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetInvitationsResponse));
+  SendSuggestionRequest_descriptor_ = file->message_type(30);
+  static const int SendSuggestionRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionRequest, options_),
+  };
+  SendSuggestionRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendSuggestionRequest_descriptor_,
+      SendSuggestionRequest::default_instance_,
+      SendSuggestionRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendSuggestionRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendSuggestionRequest));
+  AcceptSuggestionRequest_descriptor_ = file->message_type(31);
+  static const int AcceptSuggestionRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptSuggestionRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptSuggestionRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptSuggestionRequest, suggestion_id_),
+  };
+  AcceptSuggestionRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AcceptSuggestionRequest_descriptor_,
+      AcceptSuggestionRequest::default_instance_,
+      AcceptSuggestionRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptSuggestionRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptSuggestionRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AcceptSuggestionRequest));
+  DeclineSuggestionRequest_descriptor_ = file->message_type(32);
+  static const int DeclineSuggestionRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineSuggestionRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineSuggestionRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineSuggestionRequest, suggestion_id_),
+  };
+  DeclineSuggestionRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DeclineSuggestionRequest_descriptor_,
+      DeclineSuggestionRequest::default_instance_,
+      DeclineSuggestionRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineSuggestionRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineSuggestionRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DeclineSuggestionRequest));
+  GetSuggestionRequest_descriptor_ = file->message_type(33);
+  static const int GetSuggestionRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionRequest, suggestion_id_),
+  };
+  GetSuggestionRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetSuggestionRequest_descriptor_,
+      GetSuggestionRequest::default_instance_,
+      GetSuggestionRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetSuggestionRequest));
+  GetSuggestionResponse_descriptor_ = file->message_type(34);
+  static const int GetSuggestionResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionResponse, suggestion_),
+  };
+  GetSuggestionResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetSuggestionResponse_descriptor_,
+      GetSuggestionResponse::default_instance_,
+      GetSuggestionResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetSuggestionResponse));
+  GetSuggestionsRequest_descriptor_ = file->message_type(35);
+  static const int GetSuggestionsRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionsRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionsRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionsRequest, continuation_),
+  };
+  GetSuggestionsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetSuggestionsRequest_descriptor_,
+      GetSuggestionsRequest::default_instance_,
+      GetSuggestionsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetSuggestionsRequest));
+  GetSuggestionsResponse_descriptor_ = file->message_type(36);
+  static const int GetSuggestionsResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionsResponse, suggestion_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionsResponse, continuation_),
+  };
+  GetSuggestionsResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetSuggestionsResponse_descriptor_,
+      GetSuggestionsResponse::default_instance_,
+      GetSuggestionsResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionsResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetSuggestionsResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetSuggestionsResponse));
+  CreateTicketRequest_descriptor_ = file->message_type(37);
+  static const int CreateTicketRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketRequest, options_),
+  };
+  CreateTicketRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateTicketRequest_descriptor_,
+      CreateTicketRequest::default_instance_,
+      CreateTicketRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateTicketRequest));
+  CreateTicketResponse_descriptor_ = file->message_type(38);
+  static const int CreateTicketResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketResponse, ticket_),
+  };
+  CreateTicketResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateTicketResponse_descriptor_,
+      CreateTicketResponse::default_instance_,
+      CreateTicketResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTicketResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateTicketResponse));
+  DestroyTicketRequest_descriptor_ = file->message_type(39);
+  static const int DestroyTicketRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyTicketRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyTicketRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyTicketRequest, ticket_id_),
+  };
+  DestroyTicketRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DestroyTicketRequest_descriptor_,
+      DestroyTicketRequest::default_instance_,
+      DestroyTicketRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyTicketRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyTicketRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DestroyTicketRequest));
+  RedeemTicketRequest_descriptor_ = file->message_type(40);
+  static const int RedeemTicketRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RedeemTicketRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RedeemTicketRequest, ticket_id_),
+  };
+  RedeemTicketRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RedeemTicketRequest_descriptor_,
+      RedeemTicketRequest::default_instance_,
+      RedeemTicketRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RedeemTicketRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RedeemTicketRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RedeemTicketRequest));
+  GetTicketRequest_descriptor_ = file->message_type(41);
+  static const int GetTicketRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketRequest, ticket_id_),
+  };
+  GetTicketRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetTicketRequest_descriptor_,
+      GetTicketRequest::default_instance_,
+      GetTicketRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetTicketRequest));
+  GetTicketResponse_descriptor_ = file->message_type(42);
+  static const int GetTicketResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketResponse, ticket_),
+  };
+  GetTicketResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetTicketResponse_descriptor_,
+      GetTicketResponse::default_instance_,
+      GetTicketResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetTicketResponse));
+  GetTicketsRequest_descriptor_ = file->message_type(43);
+  static const int GetTicketsRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketsRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketsRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketsRequest, continuation_),
+  };
+  GetTicketsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetTicketsRequest_descriptor_,
+      GetTicketsRequest::default_instance_,
+      GetTicketsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetTicketsRequest));
+  GetTicketsResponse_descriptor_ = file->message_type(44);
+  static const int GetTicketsResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketsResponse, ticket_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketsResponse, continuation_),
+  };
+  GetTicketsResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetTicketsResponse_descriptor_,
+      GetTicketsResponse::default_instance_,
+      GetTicketsResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketsResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetTicketsResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetTicketsResponse));
+  AddBanRequest_descriptor_ = file->message_type(45);
+  static const int AddBanRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanRequest, options_),
+  };
+  AddBanRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AddBanRequest_descriptor_,
+      AddBanRequest::default_instance_,
+      AddBanRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddBanRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AddBanRequest));
+  RemoveBanRequest_descriptor_ = file->message_type(46);
+  static const int RemoveBanRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveBanRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveBanRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveBanRequest, target_id_),
+  };
+  RemoveBanRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RemoveBanRequest_descriptor_,
+      RemoveBanRequest::default_instance_,
+      RemoveBanRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveBanRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveBanRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RemoveBanRequest));
+  GetBanRequest_descriptor_ = file->message_type(47);
+  static const int GetBanRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBanRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBanRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBanRequest, target_id_),
+  };
+  GetBanRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetBanRequest_descriptor_,
+      GetBanRequest::default_instance_,
+      GetBanRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBanRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBanRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetBanRequest));
+  GetBanResponse_descriptor_ = file->message_type(48);
+  static const int GetBanResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBanResponse, ban_),
+  };
+  GetBanResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetBanResponse_descriptor_,
+      GetBanResponse::default_instance_,
+      GetBanResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBanResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBanResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetBanResponse));
+  GetBansRequest_descriptor_ = file->message_type(49);
+  static const int GetBansRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBansRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBansRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBansRequest, continuation_),
+  };
+  GetBansRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetBansRequest_descriptor_,
+      GetBansRequest::default_instance_,
+      GetBansRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBansRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBansRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetBansRequest));
+  GetBansResponse_descriptor_ = file->message_type(50);
+  static const int GetBansResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBansResponse, ban_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBansResponse, continuation_),
+  };
+  GetBansResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetBansResponse_descriptor_,
+      GetBansResponse::default_instance_,
+      GetBansResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBansResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetBansResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetBansResponse));
+  SubscribeStreamRequest_descriptor_ = file->message_type(51);
+  static const int SubscribeStreamRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeStreamRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeStreamRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeStreamRequest, stream_id_),
+  };
+  SubscribeStreamRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeStreamRequest_descriptor_,
+      SubscribeStreamRequest::default_instance_,
+      SubscribeStreamRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeStreamRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeStreamRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeStreamRequest));
+  UnsubscribeStreamRequest_descriptor_ = file->message_type(52);
+  static const int UnsubscribeStreamRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeStreamRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeStreamRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeStreamRequest, stream_id_),
+  };
+  UnsubscribeStreamRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsubscribeStreamRequest_descriptor_,
+      UnsubscribeStreamRequest::default_instance_,
+      UnsubscribeStreamRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeStreamRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeStreamRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsubscribeStreamRequest));
+  CreateStreamRequest_descriptor_ = file->message_type(53);
+  static const int CreateStreamRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamRequest, options_),
+  };
+  CreateStreamRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateStreamRequest_descriptor_,
+      CreateStreamRequest::default_instance_,
+      CreateStreamRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateStreamRequest));
+  DestroyStreamRequest_descriptor_ = file->message_type(54);
+  static const int DestroyStreamRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyStreamRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyStreamRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyStreamRequest, stream_id_),
+  };
+  DestroyStreamRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DestroyStreamRequest_descriptor_,
+      DestroyStreamRequest::default_instance_,
+      DestroyStreamRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyStreamRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyStreamRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DestroyStreamRequest));
+  GetStreamRequest_descriptor_ = file->message_type(55);
+  static const int GetStreamRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamRequest, stream_id_),
+  };
+  GetStreamRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamRequest_descriptor_,
+      GetStreamRequest::default_instance_,
+      GetStreamRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamRequest));
+  GetStreamResponse_descriptor_ = file->message_type(56);
+  static const int GetStreamResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamResponse, stream_),
+  };
+  GetStreamResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamResponse_descriptor_,
+      GetStreamResponse::default_instance_,
+      GetStreamResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamResponse));
+  GetStreamsRequest_descriptor_ = file->message_type(57);
+  static const int GetStreamsRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsRequest, continuation_),
+  };
+  GetStreamsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamsRequest_descriptor_,
+      GetStreamsRequest::default_instance_,
+      GetStreamsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamsRequest));
+  GetStreamsResponse_descriptor_ = file->message_type(58);
+  static const int GetStreamsResponse_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsResponse, stream_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsResponse, view_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsResponse, continuation_),
+  };
+  GetStreamsResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamsResponse_descriptor_,
+      GetStreamsResponse::default_instance_,
+      GetStreamsResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamsResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamsResponse));
+  UpdateStreamStateRequest_descriptor_ = file->message_type(59);
+  static const int UpdateStreamStateRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateStreamStateRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateStreamStateRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateStreamStateRequest, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateStreamStateRequest, options_),
+  };
+  UpdateStreamStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateStreamStateRequest_descriptor_,
+      UpdateStreamStateRequest::default_instance_,
+      UpdateStreamStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateStreamStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateStreamStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateStreamStateRequest));
+  SetStreamFocusRequest_descriptor_ = file->message_type(60);
+  static const int SetStreamFocusRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetStreamFocusRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetStreamFocusRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetStreamFocusRequest, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetStreamFocusRequest, focus_),
+  };
+  SetStreamFocusRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SetStreamFocusRequest_descriptor_,
+      SetStreamFocusRequest::default_instance_,
+      SetStreamFocusRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetStreamFocusRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetStreamFocusRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SetStreamFocusRequest));
+  CreateMessageRequest_descriptor_ = file->message_type(61);
+  static const int CreateMessageRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageRequest, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageRequest, options_),
+  };
+  CreateMessageRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateMessageRequest_descriptor_,
+      CreateMessageRequest::default_instance_,
+      CreateMessageRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateMessageRequest));
+  CreateMessageResponse_descriptor_ = file->message_type(62);
+  static const int CreateMessageResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageResponse, message_),
+  };
+  CreateMessageResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateMessageResponse_descriptor_,
+      CreateMessageResponse::default_instance_,
+      CreateMessageResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateMessageResponse));
+  DestroyMessageRequest_descriptor_ = file->message_type(63);
+  static const int DestroyMessageRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyMessageRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyMessageRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyMessageRequest, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyMessageRequest, message_id_),
+  };
+  DestroyMessageRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DestroyMessageRequest_descriptor_,
+      DestroyMessageRequest::default_instance_,
+      DestroyMessageRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyMessageRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyMessageRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DestroyMessageRequest));
+  DestroyMessageResponse_descriptor_ = file->message_type(64);
+  static const int DestroyMessageResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyMessageResponse, message_),
+  };
+  DestroyMessageResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DestroyMessageResponse_descriptor_,
+      DestroyMessageResponse::default_instance_,
+      DestroyMessageResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyMessageResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DestroyMessageResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DestroyMessageResponse));
+  EditMessageRequest_descriptor_ = file->message_type(65);
+  static const int EditMessageRequest_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageRequest, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageRequest, message_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageRequest, options_),
+  };
+  EditMessageRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      EditMessageRequest_descriptor_,
+      EditMessageRequest::default_instance_,
+      EditMessageRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(EditMessageRequest));
+  EditMessageResponse_descriptor_ = file->message_type(66);
+  static const int EditMessageResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageResponse, message_),
+  };
+  EditMessageResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      EditMessageResponse_descriptor_,
+      EditMessageResponse::default_instance_,
+      EditMessageResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EditMessageResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(EditMessageResponse));
+  SetMessagePinnedRequest_descriptor_ = file->message_type(67);
+  static const int SetMessagePinnedRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetMessagePinnedRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetMessagePinnedRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetMessagePinnedRequest, stream_id_),
+  };
+  SetMessagePinnedRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SetMessagePinnedRequest_descriptor_,
+      SetMessagePinnedRequest::default_instance_,
+      SetMessagePinnedRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetMessagePinnedRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetMessagePinnedRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SetMessagePinnedRequest));
+  SetTypingIndicatorRequest_descriptor_ = file->message_type(68);
+  static const int SetTypingIndicatorRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetTypingIndicatorRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetTypingIndicatorRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetTypingIndicatorRequest, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetTypingIndicatorRequest, indicator_),
+  };
+  SetTypingIndicatorRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SetTypingIndicatorRequest_descriptor_,
+      SetTypingIndicatorRequest::default_instance_,
+      SetTypingIndicatorRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetTypingIndicatorRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetTypingIndicatorRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SetTypingIndicatorRequest));
+  AdvanceStreamViewTimeRequest_descriptor_ = file->message_type(69);
+  static const int AdvanceStreamViewTimeRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamViewTimeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamViewTimeRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamViewTimeRequest, stream_id_deprecated_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamViewTimeRequest, stream_id_),
+  };
+  AdvanceStreamViewTimeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AdvanceStreamViewTimeRequest_descriptor_,
+      AdvanceStreamViewTimeRequest::default_instance_,
+      AdvanceStreamViewTimeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamViewTimeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamViewTimeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AdvanceStreamViewTimeRequest));
+  AdvanceStreamMentionViewTimeRequest_descriptor_ = file->message_type(70);
+  static const int AdvanceStreamMentionViewTimeRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamMentionViewTimeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamMentionViewTimeRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamMentionViewTimeRequest, stream_id_),
+  };
+  AdvanceStreamMentionViewTimeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AdvanceStreamMentionViewTimeRequest_descriptor_,
+      AdvanceStreamMentionViewTimeRequest::default_instance_,
+      AdvanceStreamMentionViewTimeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamMentionViewTimeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceStreamMentionViewTimeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AdvanceStreamMentionViewTimeRequest));
+  AdvanceActivityViewTimeRequest_descriptor_ = file->message_type(71);
+  static const int AdvanceActivityViewTimeRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceActivityViewTimeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceActivityViewTimeRequest, club_id_),
+  };
+  AdvanceActivityViewTimeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AdvanceActivityViewTimeRequest_descriptor_,
+      AdvanceActivityViewTimeRequest::default_instance_,
+      AdvanceActivityViewTimeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceActivityViewTimeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AdvanceActivityViewTimeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AdvanceActivityViewTimeRequest));
+  GetStreamHistoryRequest_descriptor_ = file->message_type(72);
+  static const int GetStreamHistoryRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryRequest, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryRequest, options_),
+  };
+  GetStreamHistoryRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamHistoryRequest_descriptor_,
+      GetStreamHistoryRequest::default_instance_,
+      GetStreamHistoryRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamHistoryRequest));
+  GetStreamHistoryResponse_descriptor_ = file->message_type(73);
+  static const int GetStreamHistoryResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryResponse, message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryResponse, continuation_),
+  };
+  GetStreamHistoryResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamHistoryResponse_descriptor_,
+      GetStreamHistoryResponse::default_instance_,
+      GetStreamHistoryResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamHistoryResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamHistoryResponse));
+  GetClubActivityRequest_descriptor_ = file->message_type(74);
+  static const int GetClubActivityRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubActivityRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubActivityRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubActivityRequest, options_),
+  };
+  GetClubActivityRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetClubActivityRequest_descriptor_,
+      GetClubActivityRequest::default_instance_,
+      GetClubActivityRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubActivityRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubActivityRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetClubActivityRequest));
+  GetClubActivityResponse_descriptor_ = file->message_type(75);
+  static const int GetClubActivityResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubActivityResponse, continuation_),
+  };
+  GetClubActivityResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetClubActivityResponse_descriptor_,
+      GetClubActivityResponse::default_instance_,
+      GetClubActivityResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubActivityResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetClubActivityResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetClubActivityResponse));
+  GetStreamVoiceTokenRequest_descriptor_ = file->message_type(76);
+  static const int GetStreamVoiceTokenRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamVoiceTokenRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamVoiceTokenRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamVoiceTokenRequest, stream_id_),
+  };
+  GetStreamVoiceTokenRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamVoiceTokenRequest_descriptor_,
+      GetStreamVoiceTokenRequest::default_instance_,
+      GetStreamVoiceTokenRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamVoiceTokenRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamVoiceTokenRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamVoiceTokenRequest));
+  GetStreamVoiceTokenResponse_descriptor_ = file->message_type(77);
+  static const int GetStreamVoiceTokenResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamVoiceTokenResponse, channel_uri_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamVoiceTokenResponse, credentials_),
+  };
+  GetStreamVoiceTokenResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetStreamVoiceTokenResponse_descriptor_,
+      GetStreamVoiceTokenResponse::default_instance_,
+      GetStreamVoiceTokenResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamVoiceTokenResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetStreamVoiceTokenResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetStreamVoiceTokenResponse));
+  KickFromStreamVoiceRequest_descriptor_ = file->message_type(78);
+  static const int KickFromStreamVoiceRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickFromStreamVoiceRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickFromStreamVoiceRequest, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickFromStreamVoiceRequest, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickFromStreamVoiceRequest, target_id_),
+  };
+  KickFromStreamVoiceRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      KickFromStreamVoiceRequest_descriptor_,
+      KickFromStreamVoiceRequest::default_instance_,
+      KickFromStreamVoiceRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickFromStreamVoiceRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KickFromStreamVoiceRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(KickFromStreamVoiceRequest));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5frequest_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeRequest_descriptor_, &SubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsubscribeRequest_descriptor_, &UnsubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateRequest_descriptor_, &CreateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateResponse_descriptor_, &CreateResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DestroyRequest_descriptor_, &DestroyRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetDescriptionRequest_descriptor_, &GetDescriptionRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetDescriptionResponse_descriptor_, &GetDescriptionResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetClubTypeRequest_descriptor_, &GetClubTypeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetClubTypeResponse_descriptor_, &GetClubTypeResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateClubStateRequest_descriptor_, &UpdateClubStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateClubSettingsRequest_descriptor_, &UpdateClubSettingsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    JoinRequest_descriptor_, &JoinRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    LeaveRequest_descriptor_, &LeaveRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    KickRequest_descriptor_, &KickRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetMemberRequest_descriptor_, &GetMemberRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetMemberResponse_descriptor_, &GetMemberResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetMembersRequest_descriptor_, &GetMembersRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetMembersResponse_descriptor_, &GetMembersResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateMemberStateRequest_descriptor_, &UpdateMemberStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateSubscriberStateRequest_descriptor_, &UpdateSubscriberStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AssignRoleRequest_descriptor_, &AssignRoleRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnassignRoleRequest_descriptor_, &UnassignRoleRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendInvitationRequest_descriptor_, &SendInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AcceptInvitationRequest_descriptor_, &AcceptInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DeclineInvitationRequest_descriptor_, &DeclineInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RevokeInvitationRequest_descriptor_, &RevokeInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetInvitationRequest_descriptor_, &GetInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetInvitationResponse_descriptor_, &GetInvitationResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetInvitationsRequest_descriptor_, &GetInvitationsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetInvitationsResponse_descriptor_, &GetInvitationsResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendSuggestionRequest_descriptor_, &SendSuggestionRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AcceptSuggestionRequest_descriptor_, &AcceptSuggestionRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DeclineSuggestionRequest_descriptor_, &DeclineSuggestionRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetSuggestionRequest_descriptor_, &GetSuggestionRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetSuggestionResponse_descriptor_, &GetSuggestionResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetSuggestionsRequest_descriptor_, &GetSuggestionsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetSuggestionsResponse_descriptor_, &GetSuggestionsResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateTicketRequest_descriptor_, &CreateTicketRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateTicketResponse_descriptor_, &CreateTicketResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DestroyTicketRequest_descriptor_, &DestroyTicketRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RedeemTicketRequest_descriptor_, &RedeemTicketRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetTicketRequest_descriptor_, &GetTicketRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetTicketResponse_descriptor_, &GetTicketResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetTicketsRequest_descriptor_, &GetTicketsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetTicketsResponse_descriptor_, &GetTicketsResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AddBanRequest_descriptor_, &AddBanRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RemoveBanRequest_descriptor_, &RemoveBanRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetBanRequest_descriptor_, &GetBanRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetBanResponse_descriptor_, &GetBanResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetBansRequest_descriptor_, &GetBansRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetBansResponse_descriptor_, &GetBansResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeStreamRequest_descriptor_, &SubscribeStreamRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsubscribeStreamRequest_descriptor_, &UnsubscribeStreamRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateStreamRequest_descriptor_, &CreateStreamRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DestroyStreamRequest_descriptor_, &DestroyStreamRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamRequest_descriptor_, &GetStreamRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamResponse_descriptor_, &GetStreamResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamsRequest_descriptor_, &GetStreamsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamsResponse_descriptor_, &GetStreamsResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateStreamStateRequest_descriptor_, &UpdateStreamStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SetStreamFocusRequest_descriptor_, &SetStreamFocusRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateMessageRequest_descriptor_, &CreateMessageRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateMessageResponse_descriptor_, &CreateMessageResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DestroyMessageRequest_descriptor_, &DestroyMessageRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DestroyMessageResponse_descriptor_, &DestroyMessageResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    EditMessageRequest_descriptor_, &EditMessageRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    EditMessageResponse_descriptor_, &EditMessageResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SetMessagePinnedRequest_descriptor_, &SetMessagePinnedRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SetTypingIndicatorRequest_descriptor_, &SetTypingIndicatorRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AdvanceStreamViewTimeRequest_descriptor_, &AdvanceStreamViewTimeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AdvanceStreamMentionViewTimeRequest_descriptor_, &AdvanceStreamMentionViewTimeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AdvanceActivityViewTimeRequest_descriptor_, &AdvanceActivityViewTimeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamHistoryRequest_descriptor_, &GetStreamHistoryRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamHistoryResponse_descriptor_, &GetStreamHistoryResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetClubActivityRequest_descriptor_, &GetClubActivityRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetClubActivityResponse_descriptor_, &GetClubActivityResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamVoiceTokenRequest_descriptor_, &GetStreamVoiceTokenRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetStreamVoiceTokenResponse_descriptor_, &GetStreamVoiceTokenResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    KickFromStreamVoiceRequest_descriptor_, &KickFromStreamVoiceRequest::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5frequest_2eproto() {
+  delete SubscribeRequest::default_instance_;
+  delete SubscribeRequest_reflection_;
+  delete UnsubscribeRequest::default_instance_;
+  delete UnsubscribeRequest_reflection_;
+  delete CreateRequest::default_instance_;
+  delete CreateRequest_reflection_;
+  delete CreateResponse::default_instance_;
+  delete CreateResponse_reflection_;
+  delete DestroyRequest::default_instance_;
+  delete DestroyRequest_reflection_;
+  delete GetDescriptionRequest::default_instance_;
+  delete GetDescriptionRequest_reflection_;
+  delete GetDescriptionResponse::default_instance_;
+  delete GetDescriptionResponse_reflection_;
+  delete GetClubTypeRequest::default_instance_;
+  delete GetClubTypeRequest_reflection_;
+  delete GetClubTypeResponse::default_instance_;
+  delete GetClubTypeResponse_reflection_;
+  delete UpdateClubStateRequest::default_instance_;
+  delete UpdateClubStateRequest_reflection_;
+  delete UpdateClubSettingsRequest::default_instance_;
+  delete UpdateClubSettingsRequest_reflection_;
+  delete JoinRequest::default_instance_;
+  delete JoinRequest_reflection_;
+  delete LeaveRequest::default_instance_;
+  delete LeaveRequest_reflection_;
+  delete KickRequest::default_instance_;
+  delete KickRequest_reflection_;
+  delete GetMemberRequest::default_instance_;
+  delete GetMemberRequest_reflection_;
+  delete GetMemberResponse::default_instance_;
+  delete GetMemberResponse_reflection_;
+  delete GetMembersRequest::default_instance_;
+  delete GetMembersRequest_reflection_;
+  delete GetMembersResponse::default_instance_;
+  delete GetMembersResponse_reflection_;
+  delete UpdateMemberStateRequest::default_instance_;
+  delete UpdateMemberStateRequest_reflection_;
+  delete UpdateSubscriberStateRequest::default_instance_;
+  delete UpdateSubscriberStateRequest_reflection_;
+  delete AssignRoleRequest::default_instance_;
+  delete AssignRoleRequest_reflection_;
+  delete UnassignRoleRequest::default_instance_;
+  delete UnassignRoleRequest_reflection_;
+  delete SendInvitationRequest::default_instance_;
+  delete SendInvitationRequest_reflection_;
+  delete AcceptInvitationRequest::default_instance_;
+  delete AcceptInvitationRequest_reflection_;
+  delete DeclineInvitationRequest::default_instance_;
+  delete DeclineInvitationRequest_reflection_;
+  delete RevokeInvitationRequest::default_instance_;
+  delete RevokeInvitationRequest_reflection_;
+  delete GetInvitationRequest::default_instance_;
+  delete GetInvitationRequest_reflection_;
+  delete GetInvitationResponse::default_instance_;
+  delete GetInvitationResponse_reflection_;
+  delete GetInvitationsRequest::default_instance_;
+  delete GetInvitationsRequest_reflection_;
+  delete GetInvitationsResponse::default_instance_;
+  delete GetInvitationsResponse_reflection_;
+  delete SendSuggestionRequest::default_instance_;
+  delete SendSuggestionRequest_reflection_;
+  delete AcceptSuggestionRequest::default_instance_;
+  delete AcceptSuggestionRequest_reflection_;
+  delete DeclineSuggestionRequest::default_instance_;
+  delete DeclineSuggestionRequest_reflection_;
+  delete GetSuggestionRequest::default_instance_;
+  delete GetSuggestionRequest_reflection_;
+  delete GetSuggestionResponse::default_instance_;
+  delete GetSuggestionResponse_reflection_;
+  delete GetSuggestionsRequest::default_instance_;
+  delete GetSuggestionsRequest_reflection_;
+  delete GetSuggestionsResponse::default_instance_;
+  delete GetSuggestionsResponse_reflection_;
+  delete CreateTicketRequest::default_instance_;
+  delete CreateTicketRequest_reflection_;
+  delete CreateTicketResponse::default_instance_;
+  delete CreateTicketResponse_reflection_;
+  delete DestroyTicketRequest::default_instance_;
+  delete DestroyTicketRequest_reflection_;
+  delete RedeemTicketRequest::default_instance_;
+  delete RedeemTicketRequest_reflection_;
+  delete GetTicketRequest::default_instance_;
+  delete GetTicketRequest_reflection_;
+  delete GetTicketResponse::default_instance_;
+  delete GetTicketResponse_reflection_;
+  delete GetTicketsRequest::default_instance_;
+  delete GetTicketsRequest_reflection_;
+  delete GetTicketsResponse::default_instance_;
+  delete GetTicketsResponse_reflection_;
+  delete AddBanRequest::default_instance_;
+  delete AddBanRequest_reflection_;
+  delete RemoveBanRequest::default_instance_;
+  delete RemoveBanRequest_reflection_;
+  delete GetBanRequest::default_instance_;
+  delete GetBanRequest_reflection_;
+  delete GetBanResponse::default_instance_;
+  delete GetBanResponse_reflection_;
+  delete GetBansRequest::default_instance_;
+  delete GetBansRequest_reflection_;
+  delete GetBansResponse::default_instance_;
+  delete GetBansResponse_reflection_;
+  delete SubscribeStreamRequest::default_instance_;
+  delete SubscribeStreamRequest_reflection_;
+  delete UnsubscribeStreamRequest::default_instance_;
+  delete UnsubscribeStreamRequest_reflection_;
+  delete CreateStreamRequest::default_instance_;
+  delete CreateStreamRequest_reflection_;
+  delete DestroyStreamRequest::default_instance_;
+  delete DestroyStreamRequest_reflection_;
+  delete GetStreamRequest::default_instance_;
+  delete GetStreamRequest_reflection_;
+  delete GetStreamResponse::default_instance_;
+  delete GetStreamResponse_reflection_;
+  delete GetStreamsRequest::default_instance_;
+  delete GetStreamsRequest_reflection_;
+  delete GetStreamsResponse::default_instance_;
+  delete GetStreamsResponse_reflection_;
+  delete UpdateStreamStateRequest::default_instance_;
+  delete UpdateStreamStateRequest_reflection_;
+  delete SetStreamFocusRequest::default_instance_;
+  delete SetStreamFocusRequest_reflection_;
+  delete CreateMessageRequest::default_instance_;
+  delete CreateMessageRequest_reflection_;
+  delete CreateMessageResponse::default_instance_;
+  delete CreateMessageResponse_reflection_;
+  delete DestroyMessageRequest::default_instance_;
+  delete DestroyMessageRequest_reflection_;
+  delete DestroyMessageResponse::default_instance_;
+  delete DestroyMessageResponse_reflection_;
+  delete EditMessageRequest::default_instance_;
+  delete EditMessageRequest_reflection_;
+  delete EditMessageResponse::default_instance_;
+  delete EditMessageResponse_reflection_;
+  delete SetMessagePinnedRequest::default_instance_;
+  delete SetMessagePinnedRequest_reflection_;
+  delete SetTypingIndicatorRequest::default_instance_;
+  delete SetTypingIndicatorRequest_reflection_;
+  delete AdvanceStreamViewTimeRequest::default_instance_;
+  delete AdvanceStreamViewTimeRequest_reflection_;
+  delete AdvanceStreamMentionViewTimeRequest::default_instance_;
+  delete AdvanceStreamMentionViewTimeRequest_reflection_;
+  delete AdvanceActivityViewTimeRequest::default_instance_;
+  delete AdvanceActivityViewTimeRequest_reflection_;
+  delete GetStreamHistoryRequest::default_instance_;
+  delete GetStreamHistoryRequest_reflection_;
+  delete GetStreamHistoryResponse::default_instance_;
+  delete GetStreamHistoryResponse_reflection_;
+  delete GetClubActivityRequest::default_instance_;
+  delete GetClubActivityRequest_reflection_;
+  delete GetClubActivityResponse::default_instance_;
+  delete GetClubActivityResponse_reflection_;
+  delete GetStreamVoiceTokenRequest::default_instance_;
+  delete GetStreamVoiceTokenRequest_reflection_;
+  delete GetStreamVoiceTokenResponse::default_instance_;
+  delete GetStreamVoiceTokenResponse_reflection_;
+  delete KickFromStreamVoiceRequest::default_instance_;
+  delete KickFromStreamVoiceRequest_reflection_;
+}
+
+void protobuf_AddDesc_club_5frequest_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\022club_request.proto\022\024bgs.protocol.club."
+    "v1\032\020club_types.proto\"U\n\020SubscribeRequest"
+    "\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v"
+    "1.MemberId\022\017\n\007club_id\030\002 \001(\004\"W\n\022Unsubscri"
+    "beRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protoc"
+    "ol.club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\"{\n\r"
+    "CreateRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.pr"
+    "otocol.club.v1.MemberId\0228\n\007options\030\002 \001(\013"
+    "2\'.bgs.protocol.club.v1.ClubCreateOption"
+    "s\"!\n\016CreateResponse\022\017\n\007club_id\030\001 \001(\004\"S\n\016"
+    "DestroyRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.p"
+    "rotocol.club.v1.MemberId\022\017\n\007club_id\030\002 \001("
+    "\004\"Z\n\025GetDescriptionRequest\0220\n\010agent_id\030\001"
+    " \001(\0132\036.bgs.protocol.club.v1.MemberId\022\017\n\007"
+    "club_id\030\002 \001(\004\"M\n\026GetDescriptionResponse\022"
+    "3\n\004club\030\001 \001(\0132%.bgs.protocol.club.v1.Clu"
+    "bDescription\"z\n\022GetClubTypeRequest\0220\n\010ag"
+    "ent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Memb"
+    "erId\0222\n\004type\030\002 \001(\0132$.bgs.protocol.club.v"
+    "1.UniqueClubType\"\271\001\n\023GetClubTypeResponse"
+    "\0222\n\004type\030\001 \001(\0132$.bgs.protocol.club.v1.Un"
+    "iqueClubType\0223\n\010role_set\030\002 \001(\0132!.bgs.pro"
+    "tocol.club.v1.ClubRoleSet\0229\n\trange_set\030\003"
+    " \001(\0132&.bgs.protocol.club.v1.ClubTypeRang"
+    "eSet\"\224\001\n\026UpdateClubStateRequest\0220\n\010agent"
+    "_id\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberI"
+    "d\022\017\n\007club_id\030\002 \001(\004\0227\n\007options\030\003 \001(\0132&.bg"
+    "s.protocol.club.v1.ClubStateOptions\"\232\001\n\031"
+    "UpdateClubSettingsRequest\0220\n\010agent_id\030\001 "
+    "\001(\0132\036.bgs.protocol.club.v1.MemberId\022\017\n\007c"
+    "lub_id\030\002 \001(\004\022:\n\007options\030\003 \001(\0132).bgs.prot"
+    "ocol.club.v1.ClubSettingsOptions\"\214\001\n\013Joi"
+    "nRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protoco"
+    "l.club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022:\n\007o"
+    "ptions\030\003 \001(\0132).bgs.protocol.club.v1.Crea"
+    "teMemberOptions\"Q\n\014LeaveRequest\0220\n\010agent"
+    "_id\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberI"
+    "d\022\017\n\007club_id\030\002 \001(\004\"\203\001\n\013KickRequest\0220\n\010ag"
+    "ent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Memb"
+    "erId\022\017\n\007club_id\030\002 \001(\004\0221\n\ttarget_id\030\003 \001(\013"
+    "2\036.bgs.protocol.club.v1.MemberId\"\210\001\n\020Get"
+    "MemberRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.pr"
+    "otocol.club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004"
+    "\0221\n\tmember_id\030\003 \001(\0132\036.bgs.protocol.club."
+    "v1.MemberId\"A\n\021GetMemberResponse\022,\n\006memb"
+    "er\030\001 \001(\0132\034.bgs.protocol.club.v1.Member\"l"
+    "\n\021GetMembersRequest\0220\n\010agent_id\030\001 \001(\0132\036."
+    "bgs.protocol.club.v1.MemberId\022\017\n\007club_id"
+    "\030\002 \001(\004\022\024\n\014continuation\030\004 \001(\004\"X\n\022GetMembe"
+    "rsResponse\022,\n\006member\030\001 \003(\0132\034.bgs.protoco"
+    "l.club.v1.Member\022\024\n\014continuation\030\002 \001(\004\"\313"
+    "\001\n\030UpdateMemberStateRequest\0220\n\010agent_id\030"
+    "\001 \001(\0132\036.bgs.protocol.club.v1.MemberId\022\017\n"
+    "\007club_id\030\002 \001(\004\0221\n\tmember_id\030\003 \001(\0132\036.bgs."
+    "protocol.club.v1.MemberId\0229\n\007options\030\005 \001"
+    "(\0132(.bgs.protocol.club.v1.MemberStateOpt"
+    "ions\"\240\001\n\034UpdateSubscriberStateRequest\0220\n"
+    "\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.M"
+    "emberId\022\017\n\007club_id\030\002 \001(\004\022=\n\007options\030\003 \001("
+    "\0132,.bgs.protocol.club.v1.SubscriberState"
+    "Options\"\220\001\n\021AssignRoleRequest\0220\n\010agent_i"
+    "d\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId\022"
+    "\017\n\007club_id\030\002 \001(\004\0228\n\nassignment\030\003 \001(\0132$.b"
+    "gs.protocol.club.v1.RoleAssignment\"\222\001\n\023U"
+    "nassignRoleRequest\0220\n\010agent_id\030\001 \001(\0132\036.b"
+    "gs.protocol.club.v1.MemberId\022\017\n\007club_id\030"
+    "\002 \001(\004\0228\n\nassignment\030\003 \001(\0132$.bgs.protocol"
+    ".club.v1.RoleAssignment\"\230\001\n\025SendInvitati"
+    "onRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protoc"
+    "ol.club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022<\n\007"
+    "options\030\003 \001(\0132+.bgs.protocol.club.v1.Sen"
+    "dInvitationOptions\"s\n\027AcceptInvitationRe"
+    "quest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.c"
+    "lub.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\025\n\rinvi"
+    "tation_id\030\003 \001(\006\"t\n\030DeclineInvitationRequ"
+    "est\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.clu"
+    "b.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\025\n\rinvita"
+    "tion_id\030\003 \001(\006\"s\n\027RevokeInvitationRequest"
+    "\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v"
+    "1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\025\n\rinvitatio"
+    "n_id\030\003 \001(\006\"p\n\024GetInvitationRequest\0220\n\010ag"
+    "ent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Memb"
+    "erId\022\017\n\007club_id\030\002 \001(\004\022\025\n\rinvitation_id\030\003"
+    " \001(\006\"Q\n\025GetInvitationResponse\0228\n\ninvitat"
+    "ion\030\001 \001(\0132$.bgs.protocol.club.v1.ClubInv"
+    "itation\"p\n\025GetInvitationsRequest\0220\n\010agen"
+    "t_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Member"
+    "Id\022\017\n\007club_id\030\002 \001(\004\022\024\n\014continuation\030\003 \001("
+    "\004\"h\n\026GetInvitationsResponse\0228\n\ninvitatio"
+    "n\030\001 \003(\0132$.bgs.protocol.club.v1.ClubInvit"
+    "ation\022\024\n\014continuation\030\002 \001(\004\"\230\001\n\025SendSugg"
+    "estionRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.pr"
+    "otocol.club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004"
+    "\022<\n\007options\030\003 \001(\0132+.bgs.protocol.club.v1"
+    ".SendSuggestionOptions\"s\n\027AcceptSuggesti"
+    "onRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protoc"
+    "ol.club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\025\n\r"
+    "suggestion_id\030\003 \001(\006\"t\n\030DeclineSuggestion"
+    "Request\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol"
+    ".club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\025\n\rsu"
+    "ggestion_id\030\003 \001(\006\"p\n\024GetSuggestionReques"
+    "t\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club."
+    "v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\025\n\rsuggesti"
+    "on_id\030\003 \001(\006\"Q\n\025GetSuggestionResponse\0228\n\n"
+    "suggestion\030\001 \001(\0132$.bgs.protocol.club.v1."
+    "ClubSuggestion\"p\n\025GetSuggestionsRequest\022"
+    "0\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1"
+    ".MemberId\022\017\n\007club_id\030\002 \001(\004\022\024\n\014continuati"
+    "on\030\003 \001(\004\"h\n\026GetSuggestionsResponse\0228\n\nsu"
+    "ggestion\030\001 \003(\0132$.bgs.protocol.club.v1.Cl"
+    "ubSuggestion\022\024\n\014continuation\030\002 \001(\004\"\224\001\n\023C"
+    "reateTicketRequest\0220\n\010agent_id\030\001 \001(\0132\036.b"
+    "gs.protocol.club.v1.MemberId\022\017\n\007club_id\030"
+    "\002 \001(\004\022:\n\007options\030\003 \001(\0132).bgs.protocol.cl"
+    "ub.v1.CreateTicketOptions\"H\n\024CreateTicke"
+    "tResponse\0220\n\006ticket\030\001 \001(\0132 .bgs.protocol"
+    ".club.v1.ClubTicket\"l\n\024DestroyTicketRequ"
+    "est\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.clu"
+    "b.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\021\n\tticket"
+    "_id\030\003 \001(\t\"Z\n\023RedeemTicketRequest\0220\n\010agen"
+    "t_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Member"
+    "Id\022\021\n\tticket_id\030\003 \001(\t\"W\n\020GetTicketReques"
+    "t\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club."
+    "v1.MemberId\022\021\n\tticket_id\030\003 \001(\t\"E\n\021GetTic"
+    "ketResponse\0220\n\006ticket\030\001 \001(\0132 .bgs.protoc"
+    "ol.club.v1.ClubTicket\"l\n\021GetTicketsReque"
+    "st\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club"
+    ".v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\024\n\014continu"
+    "ation\030\003 \001(\004\"\\\n\022GetTicketsResponse\0220\n\006tic"
+    "ket\030\001 \003(\0132 .bgs.protocol.club.v1.ClubTic"
+    "ket\022\024\n\014continuation\030\002 \001(\004\"\210\001\n\rAddBanRequ"
+    "est\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.clu"
+    "b.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\0224\n\007option"
+    "s\030\003 \001(\0132#.bgs.protocol.club.v1.AddBanOpt"
+    "ions\"\210\001\n\020RemoveBanRequest\0220\n\010agent_id\030\001 "
+    "\001(\0132\036.bgs.protocol.club.v1.MemberId\022\017\n\007c"
+    "lub_id\030\002 \001(\004\0221\n\ttarget_id\030\003 \001(\0132\036.bgs.pr"
+    "otocol.club.v1.MemberId\"\205\001\n\rGetBanReques"
+    "t\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club."
+    "v1.MemberId\022\017\n\007club_id\030\002 \001(\004\0221\n\ttarget_i"
+    "d\030\003 \001(\0132\036.bgs.protocol.club.v1.MemberId\""
+    "<\n\016GetBanResponse\022*\n\003ban\030\001 \001(\0132\035.bgs.pro"
+    "tocol.club.v1.ClubBan\"i\n\016GetBansRequest\022"
+    "0\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1"
+    ".MemberId\022\017\n\007club_id\030\002 \001(\004\022\024\n\014continuati"
+    "on\030\003 \001(\004\"S\n\017GetBansResponse\022*\n\003ban\030\001 \003(\013"
+    "2\035.bgs.protocol.club.v1.ClubBan\022\024\n\014conti"
+    "nuation\030\002 \001(\004\"n\n\026SubscribeStreamRequest\022"
+    "0\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1"
+    ".MemberId\022\017\n\007club_id\030\002 \001(\004\022\021\n\tstream_id\030"
+    "\003 \003(\004\"p\n\030UnsubscribeStreamRequest\0220\n\010age"
+    "nt_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Membe"
+    "rId\022\017\n\007club_id\030\002 \001(\004\022\021\n\tstream_id\030\003 \003(\004\""
+    "\224\001\n\023CreateStreamRequest\0220\n\010agent_id\030\001 \001("
+    "\0132\036.bgs.protocol.club.v1.MemberId\022\017\n\007clu"
+    "b_id\030\002 \001(\004\022:\n\007options\030\003 \001(\0132).bgs.protoc"
+    "ol.club.v1.CreateStreamOptions\"l\n\024Destro"
+    "yStreamRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.p"
+    "rotocol.club.v1.MemberId\022\017\n\007club_id\030\002 \001("
+    "\004\022\021\n\tstream_id\030\003 \001(\004\"h\n\020GetStreamRequest"
+    "\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v"
+    "1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\021\n\tstream_id"
+    "\030\003 \001(\004\"A\n\021GetStreamResponse\022,\n\006stream\030\001 "
+    "\001(\0132\034.bgs.protocol.club.v1.Stream\"l\n\021Get"
+    "StreamsRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.p"
+    "rotocol.club.v1.MemberId\022\017\n\007club_id\030\002 \001("
+    "\004\022\024\n\014continuation\030\003 \001(\004\"\210\001\n\022GetStreamsRe"
+    "sponse\022,\n\006stream\030\001 \003(\0132\034.bgs.protocol.cl"
+    "ub.v1.Stream\022.\n\004view\030\002 \003(\0132 .bgs.protoco"
+    "l.club.v1.StreamView\022\024\n\014continuation\030\003 \001"
+    "(\004\"\253\001\n\030UpdateStreamStateRequest\0220\n\010agent"
+    "_id\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberI"
+    "d\022\017\n\007club_id\030\002 \001(\004\022\021\n\tstream_id\030\003 \001(\004\0229\n"
+    "\007options\030\005 \001(\0132(.bgs.protocol.club.v1.St"
+    "reamStateOptions\"|\n\025SetStreamFocusReques"
+    "t\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol.club."
+    "v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\021\n\tstream_i"
+    "d\030\003 \001(\004\022\r\n\005focus\030\004 \001(\010\"\251\001\n\024CreateMessage"
+    "Request\0220\n\010agent_id\030\001 \001(\0132\036.bgs.protocol"
+    ".club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022\021\n\tst"
+    "ream_id\030\003 \001(\004\022;\n\007options\030\004 \001(\0132*.bgs.pro"
+    "tocol.club.v1.CreateMessageOptions\"M\n\025Cr"
+    "eateMessageResponse\0224\n\007message\030\001 \001(\0132#.b"
+    "gs.protocol.club.v1.StreamMessage\"\232\001\n\025De"
+    "stroyMessageRequest\0220\n\010agent_id\030\001 \001(\0132\036."
+    "bgs.protocol.club.v1.MemberId\022\017\n\007club_id"
+    "\030\002 \001(\004\022\021\n\tstream_id\030\003 \001(\004\022+\n\nmessage_id\030"
+    "\004 \001(\0132\027.bgs.protocol.MessageId\"N\n\026Destro"
+    "yMessageResponse\0224\n\007message\030\001 \001(\0132#.bgs."
+    "protocol.club.v1.StreamMessage\"\324\001\n\022EditM"
+    "essageRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.pr"
+    "otocol.club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004"
+    "\022\021\n\tstream_id\030\003 \001(\004\022+\n\nmessage_id\030\004 \001(\0132"
+    "\027.bgs.protocol.MessageId\022;\n\007options\030\005 \001("
+    "\0132*.bgs.protocol.club.v1.CreateMessageOp"
+    "tions\"K\n\023EditMessageResponse\0224\n\007message\030"
+    "\001 \001(\0132#.bgs.protocol.club.v1.StreamMessa"
+    "ge\"o\n\027SetMessagePinnedRequest\0220\n\010agent_i"
+    "d\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberId\022"
+    "\017\n\007club_id\030\002 \001(\004\022\021\n\tstream_id\030\003 \001(\004\"\243\001\n\031"
+    "SetTypingIndicatorRequest\0220\n\010agent_id\030\001 "
+    "\001(\0132\036.bgs.protocol.club.v1.MemberId\022\017\n\007c"
+    "lub_id\030\002 \001(\004\022\021\n\tstream_id\030\003 \001(\004\0220\n\tindic"
+    "ator\030\004 \001(\0162\035.bgs.protocol.TypingIndicato"
+    "r\"\232\001\n\034AdvanceStreamViewTimeRequest\0220\n\010ag"
+    "ent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Memb"
+    "erId\022\017\n\007club_id\030\002 \001(\004\022 \n\024stream_id_depre"
+    "cated\030\003 \001(\004B\002\030\001\022\025\n\tstream_id\030\004 \003(\004B\002\020\001\"{"
+    "\n#AdvanceStreamMentionViewTimeRequest\0220\n"
+    "\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.M"
+    "emberId\022\017\n\007club_id\030\002 \001(\004\022\021\n\tstream_id\030\003 "
+    "\001(\004\"c\n\036AdvanceActivityViewTimeRequest\0220\n"
+    "\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.M"
+    "emberId\022\017\n\007club_id\030\002 \001(\004\"\237\001\n\027GetStreamHi"
+    "storyRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.pro"
+    "tocol.club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004\022"
+    "\021\n\tstream_id\030\003 \001(\004\022.\n\007options\030\004 \001(\0132\035.bg"
+    "s.protocol.GetEventOptions\"f\n\030GetStreamH"
+    "istoryResponse\0224\n\007message\030\001 \003(\0132#.bgs.pr"
+    "otocol.club.v1.StreamMessage\022\024\n\014continua"
+    "tion\030\002 \001(\004\"\213\001\n\026GetClubActivityRequest\0220\n"
+    "\010agent_id\030\001 \001(\0132\036.bgs.protocol.club.v1.M"
+    "emberId\022\017\n\007club_id\030\002 \001(\004\022.\n\007options\030\003 \001("
+    "\0132\035.bgs.protocol.GetEventOptions\"/\n\027GetC"
+    "lubActivityResponse\022\024\n\014continuation\030\002 \001("
+    "\004\"r\n\032GetStreamVoiceTokenRequest\0220\n\010agent"
+    "_id\030\001 \001(\0132\036.bgs.protocol.club.v1.MemberI"
+    "d\022\017\n\007club_id\030\002 \001(\004\022\021\n\tstream_id\030\003 \001(\004\"g\n"
+    "\033GetStreamVoiceTokenResponse\022\023\n\013channel_"
+    "uri\030\001 \001(\t\0223\n\013credentials\030\002 \001(\0132\036.bgs.pro"
+    "tocol.VoiceCredentials\"\245\001\n\032KickFromStrea"
+    "mVoiceRequest\0220\n\010agent_id\030\001 \001(\0132\036.bgs.pr"
+    "otocol.club.v1.MemberId\022\017\n\007club_id\030\002 \001(\004"
+    "\022\021\n\tstream_id\030\003 \001(\004\0221\n\ttarget_id\030\004 \001(\0132\036"
+    ".bgs.protocol.club.v1.MemberIdB\002H\001P\000", 9396);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_request.proto", &protobuf_RegisterTypes);
+  SubscribeRequest::default_instance_ = new SubscribeRequest();
+  UnsubscribeRequest::default_instance_ = new UnsubscribeRequest();
+  CreateRequest::default_instance_ = new CreateRequest();
+  CreateResponse::default_instance_ = new CreateResponse();
+  DestroyRequest::default_instance_ = new DestroyRequest();
+  GetDescriptionRequest::default_instance_ = new GetDescriptionRequest();
+  GetDescriptionResponse::default_instance_ = new GetDescriptionResponse();
+  GetClubTypeRequest::default_instance_ = new GetClubTypeRequest();
+  GetClubTypeResponse::default_instance_ = new GetClubTypeResponse();
+  UpdateClubStateRequest::default_instance_ = new UpdateClubStateRequest();
+  UpdateClubSettingsRequest::default_instance_ = new UpdateClubSettingsRequest();
+  JoinRequest::default_instance_ = new JoinRequest();
+  LeaveRequest::default_instance_ = new LeaveRequest();
+  KickRequest::default_instance_ = new KickRequest();
+  GetMemberRequest::default_instance_ = new GetMemberRequest();
+  GetMemberResponse::default_instance_ = new GetMemberResponse();
+  GetMembersRequest::default_instance_ = new GetMembersRequest();
+  GetMembersResponse::default_instance_ = new GetMembersResponse();
+  UpdateMemberStateRequest::default_instance_ = new UpdateMemberStateRequest();
+  UpdateSubscriberStateRequest::default_instance_ = new UpdateSubscriberStateRequest();
+  AssignRoleRequest::default_instance_ = new AssignRoleRequest();
+  UnassignRoleRequest::default_instance_ = new UnassignRoleRequest();
+  SendInvitationRequest::default_instance_ = new SendInvitationRequest();
+  AcceptInvitationRequest::default_instance_ = new AcceptInvitationRequest();
+  DeclineInvitationRequest::default_instance_ = new DeclineInvitationRequest();
+  RevokeInvitationRequest::default_instance_ = new RevokeInvitationRequest();
+  GetInvitationRequest::default_instance_ = new GetInvitationRequest();
+  GetInvitationResponse::default_instance_ = new GetInvitationResponse();
+  GetInvitationsRequest::default_instance_ = new GetInvitationsRequest();
+  GetInvitationsResponse::default_instance_ = new GetInvitationsResponse();
+  SendSuggestionRequest::default_instance_ = new SendSuggestionRequest();
+  AcceptSuggestionRequest::default_instance_ = new AcceptSuggestionRequest();
+  DeclineSuggestionRequest::default_instance_ = new DeclineSuggestionRequest();
+  GetSuggestionRequest::default_instance_ = new GetSuggestionRequest();
+  GetSuggestionResponse::default_instance_ = new GetSuggestionResponse();
+  GetSuggestionsRequest::default_instance_ = new GetSuggestionsRequest();
+  GetSuggestionsResponse::default_instance_ = new GetSuggestionsResponse();
+  CreateTicketRequest::default_instance_ = new CreateTicketRequest();
+  CreateTicketResponse::default_instance_ = new CreateTicketResponse();
+  DestroyTicketRequest::default_instance_ = new DestroyTicketRequest();
+  RedeemTicketRequest::default_instance_ = new RedeemTicketRequest();
+  GetTicketRequest::default_instance_ = new GetTicketRequest();
+  GetTicketResponse::default_instance_ = new GetTicketResponse();
+  GetTicketsRequest::default_instance_ = new GetTicketsRequest();
+  GetTicketsResponse::default_instance_ = new GetTicketsResponse();
+  AddBanRequest::default_instance_ = new AddBanRequest();
+  RemoveBanRequest::default_instance_ = new RemoveBanRequest();
+  GetBanRequest::default_instance_ = new GetBanRequest();
+  GetBanResponse::default_instance_ = new GetBanResponse();
+  GetBansRequest::default_instance_ = new GetBansRequest();
+  GetBansResponse::default_instance_ = new GetBansResponse();
+  SubscribeStreamRequest::default_instance_ = new SubscribeStreamRequest();
+  UnsubscribeStreamRequest::default_instance_ = new UnsubscribeStreamRequest();
+  CreateStreamRequest::default_instance_ = new CreateStreamRequest();
+  DestroyStreamRequest::default_instance_ = new DestroyStreamRequest();
+  GetStreamRequest::default_instance_ = new GetStreamRequest();
+  GetStreamResponse::default_instance_ = new GetStreamResponse();
+  GetStreamsRequest::default_instance_ = new GetStreamsRequest();
+  GetStreamsResponse::default_instance_ = new GetStreamsResponse();
+  UpdateStreamStateRequest::default_instance_ = new UpdateStreamStateRequest();
+  SetStreamFocusRequest::default_instance_ = new SetStreamFocusRequest();
+  CreateMessageRequest::default_instance_ = new CreateMessageRequest();
+  CreateMessageResponse::default_instance_ = new CreateMessageResponse();
+  DestroyMessageRequest::default_instance_ = new DestroyMessageRequest();
+  DestroyMessageResponse::default_instance_ = new DestroyMessageResponse();
+  EditMessageRequest::default_instance_ = new EditMessageRequest();
+  EditMessageResponse::default_instance_ = new EditMessageResponse();
+  SetMessagePinnedRequest::default_instance_ = new SetMessagePinnedRequest();
+  SetTypingIndicatorRequest::default_instance_ = new SetTypingIndicatorRequest();
+  AdvanceStreamViewTimeRequest::default_instance_ = new AdvanceStreamViewTimeRequest();
+  AdvanceStreamMentionViewTimeRequest::default_instance_ = new AdvanceStreamMentionViewTimeRequest();
+  AdvanceActivityViewTimeRequest::default_instance_ = new AdvanceActivityViewTimeRequest();
+  GetStreamHistoryRequest::default_instance_ = new GetStreamHistoryRequest();
+  GetStreamHistoryResponse::default_instance_ = new GetStreamHistoryResponse();
+  GetClubActivityRequest::default_instance_ = new GetClubActivityRequest();
+  GetClubActivityResponse::default_instance_ = new GetClubActivityResponse();
+  GetStreamVoiceTokenRequest::default_instance_ = new GetStreamVoiceTokenRequest();
+  GetStreamVoiceTokenResponse::default_instance_ = new GetStreamVoiceTokenResponse();
+  KickFromStreamVoiceRequest::default_instance_ = new KickFromStreamVoiceRequest();
+  SubscribeRequest::default_instance_->InitAsDefaultInstance();
+  UnsubscribeRequest::default_instance_->InitAsDefaultInstance();
+  CreateRequest::default_instance_->InitAsDefaultInstance();
+  CreateResponse::default_instance_->InitAsDefaultInstance();
+  DestroyRequest::default_instance_->InitAsDefaultInstance();
+  GetDescriptionRequest::default_instance_->InitAsDefaultInstance();
+  GetDescriptionResponse::default_instance_->InitAsDefaultInstance();
+  GetClubTypeRequest::default_instance_->InitAsDefaultInstance();
+  GetClubTypeResponse::default_instance_->InitAsDefaultInstance();
+  UpdateClubStateRequest::default_instance_->InitAsDefaultInstance();
+  UpdateClubSettingsRequest::default_instance_->InitAsDefaultInstance();
+  JoinRequest::default_instance_->InitAsDefaultInstance();
+  LeaveRequest::default_instance_->InitAsDefaultInstance();
+  KickRequest::default_instance_->InitAsDefaultInstance();
+  GetMemberRequest::default_instance_->InitAsDefaultInstance();
+  GetMemberResponse::default_instance_->InitAsDefaultInstance();
+  GetMembersRequest::default_instance_->InitAsDefaultInstance();
+  GetMembersResponse::default_instance_->InitAsDefaultInstance();
+  UpdateMemberStateRequest::default_instance_->InitAsDefaultInstance();
+  UpdateSubscriberStateRequest::default_instance_->InitAsDefaultInstance();
+  AssignRoleRequest::default_instance_->InitAsDefaultInstance();
+  UnassignRoleRequest::default_instance_->InitAsDefaultInstance();
+  SendInvitationRequest::default_instance_->InitAsDefaultInstance();
+  AcceptInvitationRequest::default_instance_->InitAsDefaultInstance();
+  DeclineInvitationRequest::default_instance_->InitAsDefaultInstance();
+  RevokeInvitationRequest::default_instance_->InitAsDefaultInstance();
+  GetInvitationRequest::default_instance_->InitAsDefaultInstance();
+  GetInvitationResponse::default_instance_->InitAsDefaultInstance();
+  GetInvitationsRequest::default_instance_->InitAsDefaultInstance();
+  GetInvitationsResponse::default_instance_->InitAsDefaultInstance();
+  SendSuggestionRequest::default_instance_->InitAsDefaultInstance();
+  AcceptSuggestionRequest::default_instance_->InitAsDefaultInstance();
+  DeclineSuggestionRequest::default_instance_->InitAsDefaultInstance();
+  GetSuggestionRequest::default_instance_->InitAsDefaultInstance();
+  GetSuggestionResponse::default_instance_->InitAsDefaultInstance();
+  GetSuggestionsRequest::default_instance_->InitAsDefaultInstance();
+  GetSuggestionsResponse::default_instance_->InitAsDefaultInstance();
+  CreateTicketRequest::default_instance_->InitAsDefaultInstance();
+  CreateTicketResponse::default_instance_->InitAsDefaultInstance();
+  DestroyTicketRequest::default_instance_->InitAsDefaultInstance();
+  RedeemTicketRequest::default_instance_->InitAsDefaultInstance();
+  GetTicketRequest::default_instance_->InitAsDefaultInstance();
+  GetTicketResponse::default_instance_->InitAsDefaultInstance();
+  GetTicketsRequest::default_instance_->InitAsDefaultInstance();
+  GetTicketsResponse::default_instance_->InitAsDefaultInstance();
+  AddBanRequest::default_instance_->InitAsDefaultInstance();
+  RemoveBanRequest::default_instance_->InitAsDefaultInstance();
+  GetBanRequest::default_instance_->InitAsDefaultInstance();
+  GetBanResponse::default_instance_->InitAsDefaultInstance();
+  GetBansRequest::default_instance_->InitAsDefaultInstance();
+  GetBansResponse::default_instance_->InitAsDefaultInstance();
+  SubscribeStreamRequest::default_instance_->InitAsDefaultInstance();
+  UnsubscribeStreamRequest::default_instance_->InitAsDefaultInstance();
+  CreateStreamRequest::default_instance_->InitAsDefaultInstance();
+  DestroyStreamRequest::default_instance_->InitAsDefaultInstance();
+  GetStreamRequest::default_instance_->InitAsDefaultInstance();
+  GetStreamResponse::default_instance_->InitAsDefaultInstance();
+  GetStreamsRequest::default_instance_->InitAsDefaultInstance();
+  GetStreamsResponse::default_instance_->InitAsDefaultInstance();
+  UpdateStreamStateRequest::default_instance_->InitAsDefaultInstance();
+  SetStreamFocusRequest::default_instance_->InitAsDefaultInstance();
+  CreateMessageRequest::default_instance_->InitAsDefaultInstance();
+  CreateMessageResponse::default_instance_->InitAsDefaultInstance();
+  DestroyMessageRequest::default_instance_->InitAsDefaultInstance();
+  DestroyMessageResponse::default_instance_->InitAsDefaultInstance();
+  EditMessageRequest::default_instance_->InitAsDefaultInstance();
+  EditMessageResponse::default_instance_->InitAsDefaultInstance();
+  SetMessagePinnedRequest::default_instance_->InitAsDefaultInstance();
+  SetTypingIndicatorRequest::default_instance_->InitAsDefaultInstance();
+  AdvanceStreamViewTimeRequest::default_instance_->InitAsDefaultInstance();
+  AdvanceStreamMentionViewTimeRequest::default_instance_->InitAsDefaultInstance();
+  AdvanceActivityViewTimeRequest::default_instance_->InitAsDefaultInstance();
+  GetStreamHistoryRequest::default_instance_->InitAsDefaultInstance();
+  GetStreamHistoryResponse::default_instance_->InitAsDefaultInstance();
+  GetClubActivityRequest::default_instance_->InitAsDefaultInstance();
+  GetClubActivityResponse::default_instance_->InitAsDefaultInstance();
+  GetStreamVoiceTokenRequest::default_instance_->InitAsDefaultInstance();
+  GetStreamVoiceTokenResponse::default_instance_->InitAsDefaultInstance();
+  KickFromStreamVoiceRequest::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5frequest_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5frequest_2eproto {
+  StaticDescriptorInitializer_club_5frequest_2eproto() {
+    protobuf_AddDesc_club_5frequest_2eproto();
+  }
+} static_descriptor_initializer_club_5frequest_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeRequest::kAgentIdFieldNumber;
+const int SubscribeRequest::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeRequest::SubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SubscribeRequest)
+}
+
+void SubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+SubscribeRequest::SubscribeRequest(const SubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SubscribeRequest)
+}
+
+void SubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeRequest::~SubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SubscribeRequest)
+  SharedDtor();
+}
+
+void SubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeRequest_descriptor_;
+}
+
+const SubscribeRequest& SubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+SubscribeRequest* SubscribeRequest::default_instance_ = NULL;
+
+SubscribeRequest* SubscribeRequest::New() const {
+  return new SubscribeRequest;
+}
+
+void SubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void SubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SubscribeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SubscribeRequest)
+}
+
+::google::protobuf::uint8* SubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SubscribeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SubscribeRequest)
+  return target;
+}
+
+int SubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeRequest::MergeFrom(const SubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeRequest::CopyFrom(const SubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscribeRequest::Swap(SubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeRequest_descriptor_;
+  metadata.reflection = SubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsubscribeRequest::kAgentIdFieldNumber;
+const int UnsubscribeRequest::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+UnsubscribeRequest::UnsubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+UnsubscribeRequest::UnsubscribeRequest(const UnsubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsubscribeRequest::~UnsubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UnsubscribeRequest)
+  SharedDtor();
+}
+
+void UnsubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void UnsubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsubscribeRequest_descriptor_;
+}
+
+const UnsubscribeRequest& UnsubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+UnsubscribeRequest* UnsubscribeRequest::default_instance_ = NULL;
+
+UnsubscribeRequest* UnsubscribeRequest::New() const {
+  return new UnsubscribeRequest;
+}
+
+void UnsubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UnsubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UnsubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UnsubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void UnsubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UnsubscribeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UnsubscribeRequest)
+}
+
+::google::protobuf::uint8* UnsubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UnsubscribeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UnsubscribeRequest)
+  return target;
+}
+
+int UnsubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsubscribeRequest::MergeFrom(const UnsubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsubscribeRequest::CopyFrom(const UnsubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsubscribeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnsubscribeRequest::Swap(UnsubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsubscribeRequest_descriptor_;
+  metadata.reflection = UnsubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateRequest::kAgentIdFieldNumber;
+const int CreateRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+CreateRequest::CreateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateRequest)
+}
+
+void CreateRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::ClubCreateOptions*>(&::bgs::protocol::club::v1::ClubCreateOptions::default_instance());
+}
+
+CreateRequest::CreateRequest(const CreateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateRequest)
+}
+
+void CreateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateRequest::~CreateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateRequest)
+  SharedDtor();
+}
+
+void CreateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void CreateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateRequest_descriptor_;
+}
+
+const CreateRequest& CreateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+CreateRequest* CreateRequest::default_instance_ = NULL;
+
+CreateRequest* CreateRequest::New() const {
+  return new CreateRequest;
+}
+
+void CreateRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::ClubCreateOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubCreateOptions options = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateRequest)
+  return false;
+#undef DO_
+}
+
+void CreateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubCreateOptions options = 2;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateRequest)
+}
+
+::google::protobuf::uint8* CreateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubCreateOptions options = 2;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateRequest)
+  return target;
+}
+
+int CreateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubCreateOptions options = 2;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateRequest::MergeFrom(const CreateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::ClubCreateOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateRequest::CopyFrom(const CreateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_options()) {
+    if (!this->options().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CreateRequest::Swap(CreateRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateRequest_descriptor_;
+  metadata.reflection = CreateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateResponse::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+CreateResponse::CreateResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateResponse)
+}
+
+void CreateResponse::InitAsDefaultInstance() {
+}
+
+CreateResponse::CreateResponse(const CreateResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateResponse)
+}
+
+void CreateResponse::SharedCtor() {
+  _cached_size_ = 0;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateResponse::~CreateResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateResponse)
+  SharedDtor();
+}
+
+void CreateResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void CreateResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateResponse_descriptor_;
+}
+
+const CreateResponse& CreateResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+CreateResponse* CreateResponse::default_instance_ = NULL;
+
+CreateResponse* CreateResponse::New() const {
+  return new CreateResponse;
+}
+
+void CreateResponse::Clear() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 club_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateResponse)
+  return false;
+#undef DO_
+}
+
+void CreateResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateResponse)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->club_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateResponse)
+}
+
+::google::protobuf::uint8* CreateResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateResponse)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->club_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateResponse)
+  return target;
+}
+
+int CreateResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 club_id = 1;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateResponse::MergeFrom(const CreateResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateResponse::CopyFrom(const CreateResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateResponse::IsInitialized() const {
+
+  return true;
+}
+
+void CreateResponse::Swap(CreateResponse* other) {
+  if (other != this) {
+    std::swap(club_id_, other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateResponse_descriptor_;
+  metadata.reflection = CreateResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DestroyRequest::kAgentIdFieldNumber;
+const int DestroyRequest::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+DestroyRequest::DestroyRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.DestroyRequest)
+}
+
+void DestroyRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+DestroyRequest::DestroyRequest(const DestroyRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.DestroyRequest)
+}
+
+void DestroyRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DestroyRequest::~DestroyRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.DestroyRequest)
+  SharedDtor();
+}
+
+void DestroyRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void DestroyRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DestroyRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DestroyRequest_descriptor_;
+}
+
+const DestroyRequest& DestroyRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+DestroyRequest* DestroyRequest::default_instance_ = NULL;
+
+DestroyRequest* DestroyRequest::New() const {
+  return new DestroyRequest;
+}
+
+void DestroyRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DestroyRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.DestroyRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.DestroyRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.DestroyRequest)
+  return false;
+#undef DO_
+}
+
+void DestroyRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.DestroyRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.DestroyRequest)
+}
+
+::google::protobuf::uint8* DestroyRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.DestroyRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.DestroyRequest)
+  return target;
+}
+
+int DestroyRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DestroyRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DestroyRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DestroyRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DestroyRequest::MergeFrom(const DestroyRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DestroyRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DestroyRequest::CopyFrom(const DestroyRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DestroyRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DestroyRequest::Swap(DestroyRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DestroyRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DestroyRequest_descriptor_;
+  metadata.reflection = DestroyRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetDescriptionRequest::kAgentIdFieldNumber;
+const int GetDescriptionRequest::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetDescriptionRequest::GetDescriptionRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetDescriptionRequest)
+}
+
+void GetDescriptionRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetDescriptionRequest::GetDescriptionRequest(const GetDescriptionRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetDescriptionRequest)
+}
+
+void GetDescriptionRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetDescriptionRequest::~GetDescriptionRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetDescriptionRequest)
+  SharedDtor();
+}
+
+void GetDescriptionRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetDescriptionRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetDescriptionRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetDescriptionRequest_descriptor_;
+}
+
+const GetDescriptionRequest& GetDescriptionRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetDescriptionRequest* GetDescriptionRequest::default_instance_ = NULL;
+
+GetDescriptionRequest* GetDescriptionRequest::New() const {
+  return new GetDescriptionRequest;
+}
+
+void GetDescriptionRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetDescriptionRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetDescriptionRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetDescriptionRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetDescriptionRequest)
+  return false;
+#undef DO_
+}
+
+void GetDescriptionRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetDescriptionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetDescriptionRequest)
+}
+
+::google::protobuf::uint8* GetDescriptionRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetDescriptionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetDescriptionRequest)
+  return target;
+}
+
+int GetDescriptionRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetDescriptionRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetDescriptionRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetDescriptionRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetDescriptionRequest::MergeFrom(const GetDescriptionRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetDescriptionRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetDescriptionRequest::CopyFrom(const GetDescriptionRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetDescriptionRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetDescriptionRequest::Swap(GetDescriptionRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetDescriptionRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetDescriptionRequest_descriptor_;
+  metadata.reflection = GetDescriptionRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetDescriptionResponse::kClubFieldNumber;
+#endif  // !_MSC_VER
+
+GetDescriptionResponse::GetDescriptionResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetDescriptionResponse)
+}
+
+void GetDescriptionResponse::InitAsDefaultInstance() {
+  club_ = const_cast< ::bgs::protocol::club::v1::ClubDescription*>(&::bgs::protocol::club::v1::ClubDescription::default_instance());
+}
+
+GetDescriptionResponse::GetDescriptionResponse(const GetDescriptionResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetDescriptionResponse)
+}
+
+void GetDescriptionResponse::SharedCtor() {
+  _cached_size_ = 0;
+  club_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetDescriptionResponse::~GetDescriptionResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetDescriptionResponse)
+  SharedDtor();
+}
+
+void GetDescriptionResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete club_;
+  }
+}
+
+void GetDescriptionResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetDescriptionResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetDescriptionResponse_descriptor_;
+}
+
+const GetDescriptionResponse& GetDescriptionResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetDescriptionResponse* GetDescriptionResponse::default_instance_ = NULL;
+
+GetDescriptionResponse* GetDescriptionResponse::New() const {
+  return new GetDescriptionResponse;
+}
+
+void GetDescriptionResponse::Clear() {
+  if (has_club()) {
+    if (club_ != NULL) club_->::bgs::protocol::club::v1::ClubDescription::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetDescriptionResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetDescriptionResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubDescription club = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_club()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetDescriptionResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetDescriptionResponse)
+  return false;
+#undef DO_
+}
+
+void GetDescriptionResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetDescriptionResponse)
+  // optional .bgs.protocol.club.v1.ClubDescription club = 1;
+  if (has_club()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->club(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetDescriptionResponse)
+}
+
+::google::protobuf::uint8* GetDescriptionResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetDescriptionResponse)
+  // optional .bgs.protocol.club.v1.ClubDescription club = 1;
+  if (has_club()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->club(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetDescriptionResponse)
+  return target;
+}
+
+int GetDescriptionResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubDescription club = 1;
+    if (has_club()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->club());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetDescriptionResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetDescriptionResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetDescriptionResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetDescriptionResponse::MergeFrom(const GetDescriptionResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club()) {
+      mutable_club()->::bgs::protocol::club::v1::ClubDescription::MergeFrom(from.club());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetDescriptionResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetDescriptionResponse::CopyFrom(const GetDescriptionResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetDescriptionResponse::IsInitialized() const {
+
+  if (has_club()) {
+    if (!this->club().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetDescriptionResponse::Swap(GetDescriptionResponse* other) {
+  if (other != this) {
+    std::swap(club_, other->club_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetDescriptionResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetDescriptionResponse_descriptor_;
+  metadata.reflection = GetDescriptionResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetClubTypeRequest::kAgentIdFieldNumber;
+const int GetClubTypeRequest::kTypeFieldNumber;
+#endif  // !_MSC_VER
+
+GetClubTypeRequest::GetClubTypeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetClubTypeRequest)
+}
+
+void GetClubTypeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  type_ = const_cast< ::bgs::protocol::club::v1::UniqueClubType*>(&::bgs::protocol::club::v1::UniqueClubType::default_instance());
+}
+
+GetClubTypeRequest::GetClubTypeRequest(const GetClubTypeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetClubTypeRequest)
+}
+
+void GetClubTypeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  type_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetClubTypeRequest::~GetClubTypeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetClubTypeRequest)
+  SharedDtor();
+}
+
+void GetClubTypeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete type_;
+  }
+}
+
+void GetClubTypeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetClubTypeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetClubTypeRequest_descriptor_;
+}
+
+const GetClubTypeRequest& GetClubTypeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetClubTypeRequest* GetClubTypeRequest::default_instance_ = NULL;
+
+GetClubTypeRequest* GetClubTypeRequest::New() const {
+  return new GetClubTypeRequest;
+}
+
+void GetClubTypeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_type()) {
+      if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetClubTypeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetClubTypeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_type;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_type()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetClubTypeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetClubTypeRequest)
+  return false;
+#undef DO_
+}
+
+void GetClubTypeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetClubTypeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->type(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetClubTypeRequest)
+}
+
+::google::protobuf::uint8* GetClubTypeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetClubTypeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->type(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetClubTypeRequest)
+  return target;
+}
+
+int GetClubTypeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->type());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetClubTypeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetClubTypeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetClubTypeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetClubTypeRequest::MergeFrom(const GetClubTypeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_type()) {
+      mutable_type()->::bgs::protocol::club::v1::UniqueClubType::MergeFrom(from.type());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetClubTypeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetClubTypeRequest::CopyFrom(const GetClubTypeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetClubTypeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetClubTypeRequest::Swap(GetClubTypeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(type_, other->type_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetClubTypeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetClubTypeRequest_descriptor_;
+  metadata.reflection = GetClubTypeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetClubTypeResponse::kTypeFieldNumber;
+const int GetClubTypeResponse::kRoleSetFieldNumber;
+const int GetClubTypeResponse::kRangeSetFieldNumber;
+#endif  // !_MSC_VER
+
+GetClubTypeResponse::GetClubTypeResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetClubTypeResponse)
+}
+
+void GetClubTypeResponse::InitAsDefaultInstance() {
+  type_ = const_cast< ::bgs::protocol::club::v1::UniqueClubType*>(&::bgs::protocol::club::v1::UniqueClubType::default_instance());
+  role_set_ = const_cast< ::bgs::protocol::club::v1::ClubRoleSet*>(&::bgs::protocol::club::v1::ClubRoleSet::default_instance());
+  range_set_ = const_cast< ::bgs::protocol::club::v1::ClubTypeRangeSet*>(&::bgs::protocol::club::v1::ClubTypeRangeSet::default_instance());
+}
+
+GetClubTypeResponse::GetClubTypeResponse(const GetClubTypeResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetClubTypeResponse)
+}
+
+void GetClubTypeResponse::SharedCtor() {
+  _cached_size_ = 0;
+  type_ = NULL;
+  role_set_ = NULL;
+  range_set_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetClubTypeResponse::~GetClubTypeResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetClubTypeResponse)
+  SharedDtor();
+}
+
+void GetClubTypeResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete type_;
+    delete role_set_;
+    delete range_set_;
+  }
+}
+
+void GetClubTypeResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetClubTypeResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetClubTypeResponse_descriptor_;
+}
+
+const GetClubTypeResponse& GetClubTypeResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetClubTypeResponse* GetClubTypeResponse::default_instance_ = NULL;
+
+GetClubTypeResponse* GetClubTypeResponse::New() const {
+  return new GetClubTypeResponse;
+}
+
+void GetClubTypeResponse::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_type()) {
+      if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+    }
+    if (has_role_set()) {
+      if (role_set_ != NULL) role_set_->::bgs::protocol::club::v1::ClubRoleSet::Clear();
+    }
+    if (has_range_set()) {
+      if (range_set_ != NULL) range_set_->::bgs::protocol::club::v1::ClubTypeRangeSet::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetClubTypeResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetClubTypeResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_type()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_role_set;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_role_set:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_role_set()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_range_set;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubTypeRangeSet range_set = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_range_set:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_range_set()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetClubTypeResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetClubTypeResponse)
+  return false;
+#undef DO_
+}
+
+void GetClubTypeResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetClubTypeResponse)
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->type(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 2;
+  if (has_role_set()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->role_set(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubTypeRangeSet range_set = 3;
+  if (has_range_set()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->range_set(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetClubTypeResponse)
+}
+
+::google::protobuf::uint8* GetClubTypeResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetClubTypeResponse)
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->type(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 2;
+  if (has_role_set()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->role_set(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubTypeRangeSet range_set = 3;
+  if (has_range_set()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->range_set(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetClubTypeResponse)
+  return target;
+}
+
+int GetClubTypeResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->type());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 2;
+    if (has_role_set()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->role_set());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubTypeRangeSet range_set = 3;
+    if (has_range_set()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->range_set());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetClubTypeResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetClubTypeResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetClubTypeResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetClubTypeResponse::MergeFrom(const GetClubTypeResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_type()) {
+      mutable_type()->::bgs::protocol::club::v1::UniqueClubType::MergeFrom(from.type());
+    }
+    if (from.has_role_set()) {
+      mutable_role_set()->::bgs::protocol::club::v1::ClubRoleSet::MergeFrom(from.role_set());
+    }
+    if (from.has_range_set()) {
+      mutable_range_set()->::bgs::protocol::club::v1::ClubTypeRangeSet::MergeFrom(from.range_set());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetClubTypeResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetClubTypeResponse::CopyFrom(const GetClubTypeResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetClubTypeResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetClubTypeResponse::Swap(GetClubTypeResponse* other) {
+  if (other != this) {
+    std::swap(type_, other->type_);
+    std::swap(role_set_, other->role_set_);
+    std::swap(range_set_, other->range_set_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetClubTypeResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetClubTypeResponse_descriptor_;
+  metadata.reflection = GetClubTypeResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateClubStateRequest::kAgentIdFieldNumber;
+const int UpdateClubStateRequest::kClubIdFieldNumber;
+const int UpdateClubStateRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateClubStateRequest::UpdateClubStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UpdateClubStateRequest)
+}
+
+void UpdateClubStateRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::ClubStateOptions*>(&::bgs::protocol::club::v1::ClubStateOptions::default_instance());
+}
+
+UpdateClubStateRequest::UpdateClubStateRequest(const UpdateClubStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UpdateClubStateRequest)
+}
+
+void UpdateClubStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateClubStateRequest::~UpdateClubStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UpdateClubStateRequest)
+  SharedDtor();
+}
+
+void UpdateClubStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void UpdateClubStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateClubStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateClubStateRequest_descriptor_;
+}
+
+const UpdateClubStateRequest& UpdateClubStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+UpdateClubStateRequest* UpdateClubStateRequest::default_instance_ = NULL;
+
+UpdateClubStateRequest* UpdateClubStateRequest::New() const {
+  return new UpdateClubStateRequest;
+}
+
+void UpdateClubStateRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::ClubStateOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateClubStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UpdateClubStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubStateOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UpdateClubStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UpdateClubStateRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateClubStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UpdateClubStateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubStateOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UpdateClubStateRequest)
+}
+
+::google::protobuf::uint8* UpdateClubStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UpdateClubStateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubStateOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UpdateClubStateRequest)
+  return target;
+}
+
+int UpdateClubStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubStateOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateClubStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateClubStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateClubStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateClubStateRequest::MergeFrom(const UpdateClubStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::ClubStateOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateClubStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateClubStateRequest::CopyFrom(const UpdateClubStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateClubStateRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateClubStateRequest::Swap(UpdateClubStateRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateClubStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateClubStateRequest_descriptor_;
+  metadata.reflection = UpdateClubStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateClubSettingsRequest::kAgentIdFieldNumber;
+const int UpdateClubSettingsRequest::kClubIdFieldNumber;
+const int UpdateClubSettingsRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateClubSettingsRequest::UpdateClubSettingsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+}
+
+void UpdateClubSettingsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::ClubSettingsOptions*>(&::bgs::protocol::club::v1::ClubSettingsOptions::default_instance());
+}
+
+UpdateClubSettingsRequest::UpdateClubSettingsRequest(const UpdateClubSettingsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+}
+
+void UpdateClubSettingsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateClubSettingsRequest::~UpdateClubSettingsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+  SharedDtor();
+}
+
+void UpdateClubSettingsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void UpdateClubSettingsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateClubSettingsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateClubSettingsRequest_descriptor_;
+}
+
+const UpdateClubSettingsRequest& UpdateClubSettingsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+UpdateClubSettingsRequest* UpdateClubSettingsRequest::default_instance_ = NULL;
+
+UpdateClubSettingsRequest* UpdateClubSettingsRequest::New() const {
+  return new UpdateClubSettingsRequest;
+}
+
+void UpdateClubSettingsRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::ClubSettingsOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateClubSettingsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubSettingsOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateClubSettingsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettingsOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+}
+
+::google::protobuf::uint8* UpdateClubSettingsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubSettingsOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+  return target;
+}
+
+int UpdateClubSettingsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubSettingsOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateClubSettingsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateClubSettingsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateClubSettingsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateClubSettingsRequest::MergeFrom(const UpdateClubSettingsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::ClubSettingsOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateClubSettingsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateClubSettingsRequest::CopyFrom(const UpdateClubSettingsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateClubSettingsRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateClubSettingsRequest::Swap(UpdateClubSettingsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateClubSettingsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateClubSettingsRequest_descriptor_;
+  metadata.reflection = UpdateClubSettingsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int JoinRequest::kAgentIdFieldNumber;
+const int JoinRequest::kClubIdFieldNumber;
+const int JoinRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+JoinRequest::JoinRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.JoinRequest)
+}
+
+void JoinRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::CreateMemberOptions*>(&::bgs::protocol::club::v1::CreateMemberOptions::default_instance());
+}
+
+JoinRequest::JoinRequest(const JoinRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.JoinRequest)
+}
+
+void JoinRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+JoinRequest::~JoinRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.JoinRequest)
+  SharedDtor();
+}
+
+void JoinRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void JoinRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* JoinRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return JoinRequest_descriptor_;
+}
+
+const JoinRequest& JoinRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+JoinRequest* JoinRequest::default_instance_ = NULL;
+
+JoinRequest* JoinRequest::New() const {
+  return new JoinRequest;
+}
+
+void JoinRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateMemberOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool JoinRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.JoinRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.CreateMemberOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.JoinRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.JoinRequest)
+  return false;
+#undef DO_
+}
+
+void JoinRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.JoinRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateMemberOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.JoinRequest)
+}
+
+::google::protobuf::uint8* JoinRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.JoinRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateMemberOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.JoinRequest)
+  return target;
+}
+
+int JoinRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.CreateMemberOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void JoinRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const JoinRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const JoinRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void JoinRequest::MergeFrom(const JoinRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::CreateMemberOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void JoinRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void JoinRequest::CopyFrom(const JoinRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool JoinRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_options()) {
+    if (!this->options().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void JoinRequest::Swap(JoinRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata JoinRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = JoinRequest_descriptor_;
+  metadata.reflection = JoinRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int LeaveRequest::kAgentIdFieldNumber;
+const int LeaveRequest::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+LeaveRequest::LeaveRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.LeaveRequest)
+}
+
+void LeaveRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+LeaveRequest::LeaveRequest(const LeaveRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.LeaveRequest)
+}
+
+void LeaveRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+LeaveRequest::~LeaveRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.LeaveRequest)
+  SharedDtor();
+}
+
+void LeaveRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void LeaveRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* LeaveRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LeaveRequest_descriptor_;
+}
+
+const LeaveRequest& LeaveRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+LeaveRequest* LeaveRequest::default_instance_ = NULL;
+
+LeaveRequest* LeaveRequest::New() const {
+  return new LeaveRequest;
+}
+
+void LeaveRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool LeaveRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.LeaveRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.LeaveRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.LeaveRequest)
+  return false;
+#undef DO_
+}
+
+void LeaveRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.LeaveRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.LeaveRequest)
+}
+
+::google::protobuf::uint8* LeaveRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.LeaveRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.LeaveRequest)
+  return target;
+}
+
+int LeaveRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void LeaveRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const LeaveRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const LeaveRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void LeaveRequest::MergeFrom(const LeaveRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void LeaveRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void LeaveRequest::CopyFrom(const LeaveRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LeaveRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void LeaveRequest::Swap(LeaveRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata LeaveRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = LeaveRequest_descriptor_;
+  metadata.reflection = LeaveRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int KickRequest::kAgentIdFieldNumber;
+const int KickRequest::kClubIdFieldNumber;
+const int KickRequest::kTargetIdFieldNumber;
+#endif  // !_MSC_VER
+
+KickRequest::KickRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.KickRequest)
+}
+
+void KickRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+KickRequest::KickRequest(const KickRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.KickRequest)
+}
+
+void KickRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  target_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+KickRequest::~KickRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.KickRequest)
+  SharedDtor();
+}
+
+void KickRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void KickRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* KickRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return KickRequest_descriptor_;
+}
+
+const KickRequest& KickRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+KickRequest* KickRequest::default_instance_ = NULL;
+
+KickRequest* KickRequest::New() const {
+  return new KickRequest;
+}
+
+void KickRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool KickRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.KickRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_target_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.KickRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.KickRequest)
+  return false;
+#undef DO_
+}
+
+void KickRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.KickRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->target_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.KickRequest)
+}
+
+::google::protobuf::uint8* KickRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.KickRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->target_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.KickRequest)
+  return target;
+}
+
+int KickRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void KickRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const KickRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const KickRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void KickRequest::MergeFrom(const KickRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.target_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void KickRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void KickRequest::CopyFrom(const KickRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool KickRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void KickRequest::Swap(KickRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata KickRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = KickRequest_descriptor_;
+  metadata.reflection = KickRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetMemberRequest::kAgentIdFieldNumber;
+const int GetMemberRequest::kClubIdFieldNumber;
+const int GetMemberRequest::kMemberIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetMemberRequest::GetMemberRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetMemberRequest)
+}
+
+void GetMemberRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetMemberRequest::GetMemberRequest(const GetMemberRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetMemberRequest)
+}
+
+void GetMemberRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  member_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetMemberRequest::~GetMemberRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetMemberRequest)
+  SharedDtor();
+}
+
+void GetMemberRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete member_id_;
+  }
+}
+
+void GetMemberRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetMemberRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetMemberRequest_descriptor_;
+}
+
+const GetMemberRequest& GetMemberRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetMemberRequest* GetMemberRequest::default_instance_ = NULL;
+
+GetMemberRequest* GetMemberRequest::New() const {
+  return new GetMemberRequest;
+}
+
+void GetMemberRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetMemberRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetMemberRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_member_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetMemberRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetMemberRequest)
+  return false;
+#undef DO_
+}
+
+void GetMemberRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetMemberRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->member_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetMemberRequest)
+}
+
+::google::protobuf::uint8* GetMemberRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetMemberRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->member_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetMemberRequest)
+  return target;
+}
+
+int GetMemberRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetMemberRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetMemberRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetMemberRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetMemberRequest::MergeFrom(const GetMemberRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetMemberRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetMemberRequest::CopyFrom(const GetMemberRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetMemberRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetMemberRequest::Swap(GetMemberRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(member_id_, other->member_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetMemberRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetMemberRequest_descriptor_;
+  metadata.reflection = GetMemberRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetMemberResponse::kMemberFieldNumber;
+#endif  // !_MSC_VER
+
+GetMemberResponse::GetMemberResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetMemberResponse)
+}
+
+void GetMemberResponse::InitAsDefaultInstance() {
+  member_ = const_cast< ::bgs::protocol::club::v1::Member*>(&::bgs::protocol::club::v1::Member::default_instance());
+}
+
+GetMemberResponse::GetMemberResponse(const GetMemberResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetMemberResponse)
+}
+
+void GetMemberResponse::SharedCtor() {
+  _cached_size_ = 0;
+  member_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetMemberResponse::~GetMemberResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetMemberResponse)
+  SharedDtor();
+}
+
+void GetMemberResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete member_;
+  }
+}
+
+void GetMemberResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetMemberResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetMemberResponse_descriptor_;
+}
+
+const GetMemberResponse& GetMemberResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetMemberResponse* GetMemberResponse::default_instance_ = NULL;
+
+GetMemberResponse* GetMemberResponse::New() const {
+  return new GetMemberResponse;
+}
+
+void GetMemberResponse::Clear() {
+  if (has_member()) {
+    if (member_ != NULL) member_->::bgs::protocol::club::v1::Member::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetMemberResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetMemberResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.Member member = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetMemberResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetMemberResponse)
+  return false;
+#undef DO_
+}
+
+void GetMemberResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetMemberResponse)
+  // optional .bgs.protocol.club.v1.Member member = 1;
+  if (has_member()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->member(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetMemberResponse)
+}
+
+::google::protobuf::uint8* GetMemberResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetMemberResponse)
+  // optional .bgs.protocol.club.v1.Member member = 1;
+  if (has_member()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->member(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetMemberResponse)
+  return target;
+}
+
+int GetMemberResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.Member member = 1;
+    if (has_member()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetMemberResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetMemberResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetMemberResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetMemberResponse::MergeFrom(const GetMemberResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_member()) {
+      mutable_member()->::bgs::protocol::club::v1::Member::MergeFrom(from.member());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetMemberResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetMemberResponse::CopyFrom(const GetMemberResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetMemberResponse::IsInitialized() const {
+
+  if (has_member()) {
+    if (!this->member().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetMemberResponse::Swap(GetMemberResponse* other) {
+  if (other != this) {
+    std::swap(member_, other->member_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetMemberResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetMemberResponse_descriptor_;
+  metadata.reflection = GetMemberResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetMembersRequest::kAgentIdFieldNumber;
+const int GetMembersRequest::kClubIdFieldNumber;
+const int GetMembersRequest::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetMembersRequest::GetMembersRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetMembersRequest)
+}
+
+void GetMembersRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetMembersRequest::GetMembersRequest(const GetMembersRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetMembersRequest)
+}
+
+void GetMembersRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetMembersRequest::~GetMembersRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetMembersRequest)
+  SharedDtor();
+}
+
+void GetMembersRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetMembersRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetMembersRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetMembersRequest_descriptor_;
+}
+
+const GetMembersRequest& GetMembersRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetMembersRequest* GetMembersRequest::default_instance_ = NULL;
+
+GetMembersRequest* GetMembersRequest::New() const {
+  return new GetMembersRequest;
+}
+
+void GetMembersRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetMembersRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, continuation_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetMembersRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetMembersRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetMembersRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetMembersRequest)
+  return false;
+#undef DO_
+}
+
+void GetMembersRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetMembersRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 continuation = 4;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetMembersRequest)
+}
+
+::google::protobuf::uint8* GetMembersRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetMembersRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 continuation = 4;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetMembersRequest)
+  return target;
+}
+
+int GetMembersRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 continuation = 4;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetMembersRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetMembersRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetMembersRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetMembersRequest::MergeFrom(const GetMembersRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetMembersRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetMembersRequest::CopyFrom(const GetMembersRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetMembersRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetMembersRequest::Swap(GetMembersRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetMembersRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetMembersRequest_descriptor_;
+  metadata.reflection = GetMembersRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetMembersResponse::kMemberFieldNumber;
+const int GetMembersResponse::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetMembersResponse::GetMembersResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetMembersResponse)
+}
+
+void GetMembersResponse::InitAsDefaultInstance() {
+}
+
+GetMembersResponse::GetMembersResponse(const GetMembersResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetMembersResponse)
+}
+
+void GetMembersResponse::SharedCtor() {
+  _cached_size_ = 0;
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetMembersResponse::~GetMembersResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetMembersResponse)
+  SharedDtor();
+}
+
+void GetMembersResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetMembersResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetMembersResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetMembersResponse_descriptor_;
+}
+
+const GetMembersResponse& GetMembersResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetMembersResponse* GetMembersResponse::default_instance_ = NULL;
+
+GetMembersResponse* GetMembersResponse::New() const {
+  return new GetMembersResponse;
+}
+
+void GetMembersResponse::Clear() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  member_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetMembersResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetMembersResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.Member member = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_member:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_member;
+        if (input->ExpectTag(16)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetMembersResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetMembersResponse)
+  return false;
+#undef DO_
+}
+
+void GetMembersResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetMembersResponse)
+  // repeated .bgs.protocol.club.v1.Member member = 1;
+  for (int i = 0; i < this->member_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->member(i), output);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetMembersResponse)
+}
+
+::google::protobuf::uint8* GetMembersResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetMembersResponse)
+  // repeated .bgs.protocol.club.v1.Member member = 1;
+  for (int i = 0; i < this->member_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->member(i), target);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetMembersResponse)
+  return target;
+}
+
+int GetMembersResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint64 continuation = 2;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.Member member = 1;
+  total_size += 1 * this->member_size();
+  for (int i = 0; i < this->member_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->member(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetMembersResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetMembersResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetMembersResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetMembersResponse::MergeFrom(const GetMembersResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  member_.MergeFrom(from.member_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetMembersResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetMembersResponse::CopyFrom(const GetMembersResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetMembersResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->member())) return false;
+  return true;
+}
+
+void GetMembersResponse::Swap(GetMembersResponse* other) {
+  if (other != this) {
+    member_.Swap(&other->member_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetMembersResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetMembersResponse_descriptor_;
+  metadata.reflection = GetMembersResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateMemberStateRequest::kAgentIdFieldNumber;
+const int UpdateMemberStateRequest::kClubIdFieldNumber;
+const int UpdateMemberStateRequest::kMemberIdFieldNumber;
+const int UpdateMemberStateRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateMemberStateRequest::UpdateMemberStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UpdateMemberStateRequest)
+}
+
+void UpdateMemberStateRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::MemberStateOptions*>(&::bgs::protocol::club::v1::MemberStateOptions::default_instance());
+}
+
+UpdateMemberStateRequest::UpdateMemberStateRequest(const UpdateMemberStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UpdateMemberStateRequest)
+}
+
+void UpdateMemberStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  member_id_ = NULL;
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateMemberStateRequest::~UpdateMemberStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UpdateMemberStateRequest)
+  SharedDtor();
+}
+
+void UpdateMemberStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete member_id_;
+    delete options_;
+  }
+}
+
+void UpdateMemberStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateMemberStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateMemberStateRequest_descriptor_;
+}
+
+const UpdateMemberStateRequest& UpdateMemberStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+UpdateMemberStateRequest* UpdateMemberStateRequest::default_instance_ = NULL;
+
+UpdateMemberStateRequest* UpdateMemberStateRequest::New() const {
+  return new UpdateMemberStateRequest;
+}
+
+void UpdateMemberStateRequest::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::MemberStateOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateMemberStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UpdateMemberStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_member_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberStateOptions options = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UpdateMemberStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UpdateMemberStateRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateMemberStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UpdateMemberStateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->member_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberStateOptions options = 5;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UpdateMemberStateRequest)
+}
+
+::google::protobuf::uint8* UpdateMemberStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UpdateMemberStateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->member_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberStateOptions options = 5;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UpdateMemberStateRequest)
+  return target;
+}
+
+int UpdateMemberStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberStateOptions options = 5;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateMemberStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateMemberStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateMemberStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateMemberStateRequest::MergeFrom(const UpdateMemberStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::MemberStateOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateMemberStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateMemberStateRequest::CopyFrom(const UpdateMemberStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateMemberStateRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateMemberStateRequest::Swap(UpdateMemberStateRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(member_id_, other->member_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateMemberStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateMemberStateRequest_descriptor_;
+  metadata.reflection = UpdateMemberStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateSubscriberStateRequest::kAgentIdFieldNumber;
+const int UpdateSubscriberStateRequest::kClubIdFieldNumber;
+const int UpdateSubscriberStateRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateSubscriberStateRequest::UpdateSubscriberStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+}
+
+void UpdateSubscriberStateRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::SubscriberStateOptions*>(&::bgs::protocol::club::v1::SubscriberStateOptions::default_instance());
+}
+
+UpdateSubscriberStateRequest::UpdateSubscriberStateRequest(const UpdateSubscriberStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+}
+
+void UpdateSubscriberStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateSubscriberStateRequest::~UpdateSubscriberStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+  SharedDtor();
+}
+
+void UpdateSubscriberStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void UpdateSubscriberStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateSubscriberStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateSubscriberStateRequest_descriptor_;
+}
+
+const UpdateSubscriberStateRequest& UpdateSubscriberStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+UpdateSubscriberStateRequest* UpdateSubscriberStateRequest::default_instance_ = NULL;
+
+UpdateSubscriberStateRequest* UpdateSubscriberStateRequest::New() const {
+  return new UpdateSubscriberStateRequest;
+}
+
+void UpdateSubscriberStateRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::SubscriberStateOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateSubscriberStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.SubscriberStateOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateSubscriberStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.SubscriberStateOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+}
+
+::google::protobuf::uint8* UpdateSubscriberStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.SubscriberStateOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+  return target;
+}
+
+int UpdateSubscriberStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.SubscriberStateOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateSubscriberStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateSubscriberStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateSubscriberStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateSubscriberStateRequest::MergeFrom(const UpdateSubscriberStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::SubscriberStateOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateSubscriberStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateSubscriberStateRequest::CopyFrom(const UpdateSubscriberStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateSubscriberStateRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateSubscriberStateRequest::Swap(UpdateSubscriberStateRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateSubscriberStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateSubscriberStateRequest_descriptor_;
+  metadata.reflection = UpdateSubscriberStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AssignRoleRequest::kAgentIdFieldNumber;
+const int AssignRoleRequest::kClubIdFieldNumber;
+const int AssignRoleRequest::kAssignmentFieldNumber;
+#endif  // !_MSC_VER
+
+AssignRoleRequest::AssignRoleRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.AssignRoleRequest)
+}
+
+void AssignRoleRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  assignment_ = const_cast< ::bgs::protocol::club::v1::RoleAssignment*>(&::bgs::protocol::club::v1::RoleAssignment::default_instance());
+}
+
+AssignRoleRequest::AssignRoleRequest(const AssignRoleRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.AssignRoleRequest)
+}
+
+void AssignRoleRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  assignment_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AssignRoleRequest::~AssignRoleRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.AssignRoleRequest)
+  SharedDtor();
+}
+
+void AssignRoleRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete assignment_;
+  }
+}
+
+void AssignRoleRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AssignRoleRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AssignRoleRequest_descriptor_;
+}
+
+const AssignRoleRequest& AssignRoleRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+AssignRoleRequest* AssignRoleRequest::default_instance_ = NULL;
+
+AssignRoleRequest* AssignRoleRequest::New() const {
+  return new AssignRoleRequest;
+}
+
+void AssignRoleRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_assignment()) {
+      if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::RoleAssignment::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AssignRoleRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.AssignRoleRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_assignment;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_assignment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_assignment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.AssignRoleRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.AssignRoleRequest)
+  return false;
+#undef DO_
+}
+
+void AssignRoleRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.AssignRoleRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+  if (has_assignment()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->assignment(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.AssignRoleRequest)
+}
+
+::google::protobuf::uint8* AssignRoleRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.AssignRoleRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+  if (has_assignment()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->assignment(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.AssignRoleRequest)
+  return target;
+}
+
+int AssignRoleRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+    if (has_assignment()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->assignment());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AssignRoleRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AssignRoleRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AssignRoleRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AssignRoleRequest::MergeFrom(const AssignRoleRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_assignment()) {
+      mutable_assignment()->::bgs::protocol::club::v1::RoleAssignment::MergeFrom(from.assignment());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AssignRoleRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AssignRoleRequest::CopyFrom(const AssignRoleRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AssignRoleRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_assignment()) {
+    if (!this->assignment().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AssignRoleRequest::Swap(AssignRoleRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(assignment_, other->assignment_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AssignRoleRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AssignRoleRequest_descriptor_;
+  metadata.reflection = AssignRoleRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnassignRoleRequest::kAgentIdFieldNumber;
+const int UnassignRoleRequest::kClubIdFieldNumber;
+const int UnassignRoleRequest::kAssignmentFieldNumber;
+#endif  // !_MSC_VER
+
+UnassignRoleRequest::UnassignRoleRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UnassignRoleRequest)
+}
+
+void UnassignRoleRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  assignment_ = const_cast< ::bgs::protocol::club::v1::RoleAssignment*>(&::bgs::protocol::club::v1::RoleAssignment::default_instance());
+}
+
+UnassignRoleRequest::UnassignRoleRequest(const UnassignRoleRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UnassignRoleRequest)
+}
+
+void UnassignRoleRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  assignment_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnassignRoleRequest::~UnassignRoleRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UnassignRoleRequest)
+  SharedDtor();
+}
+
+void UnassignRoleRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete assignment_;
+  }
+}
+
+void UnassignRoleRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnassignRoleRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnassignRoleRequest_descriptor_;
+}
+
+const UnassignRoleRequest& UnassignRoleRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+UnassignRoleRequest* UnassignRoleRequest::default_instance_ = NULL;
+
+UnassignRoleRequest* UnassignRoleRequest::New() const {
+  return new UnassignRoleRequest;
+}
+
+void UnassignRoleRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_assignment()) {
+      if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::RoleAssignment::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnassignRoleRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UnassignRoleRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_assignment;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_assignment:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_assignment()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UnassignRoleRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UnassignRoleRequest)
+  return false;
+#undef DO_
+}
+
+void UnassignRoleRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UnassignRoleRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+  if (has_assignment()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->assignment(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UnassignRoleRequest)
+}
+
+::google::protobuf::uint8* UnassignRoleRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UnassignRoleRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+  if (has_assignment()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->assignment(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UnassignRoleRequest)
+  return target;
+}
+
+int UnassignRoleRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+    if (has_assignment()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->assignment());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnassignRoleRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnassignRoleRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnassignRoleRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnassignRoleRequest::MergeFrom(const UnassignRoleRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_assignment()) {
+      mutable_assignment()->::bgs::protocol::club::v1::RoleAssignment::MergeFrom(from.assignment());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnassignRoleRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnassignRoleRequest::CopyFrom(const UnassignRoleRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnassignRoleRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_assignment()) {
+    if (!this->assignment().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnassignRoleRequest::Swap(UnassignRoleRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(assignment_, other->assignment_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnassignRoleRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnassignRoleRequest_descriptor_;
+  metadata.reflection = UnassignRoleRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendInvitationRequest::kAgentIdFieldNumber;
+const int SendInvitationRequest::kClubIdFieldNumber;
+const int SendInvitationRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+SendInvitationRequest::SendInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SendInvitationRequest)
+}
+
+void SendInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::SendInvitationOptions*>(&::bgs::protocol::club::v1::SendInvitationOptions::default_instance());
+}
+
+SendInvitationRequest::SendInvitationRequest(const SendInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SendInvitationRequest)
+}
+
+void SendInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendInvitationRequest::~SendInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SendInvitationRequest)
+  SharedDtor();
+}
+
+void SendInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void SendInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendInvitationRequest_descriptor_;
+}
+
+const SendInvitationRequest& SendInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+SendInvitationRequest* SendInvitationRequest::default_instance_ = NULL;
+
+SendInvitationRequest* SendInvitationRequest::New() const {
+  return new SendInvitationRequest;
+}
+
+void SendInvitationRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::SendInvitationOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SendInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.SendInvitationOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SendInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SendInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void SendInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SendInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.SendInvitationOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SendInvitationRequest)
+}
+
+::google::protobuf::uint8* SendInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SendInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.SendInvitationOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SendInvitationRequest)
+  return target;
+}
+
+int SendInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.SendInvitationOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendInvitationRequest::MergeFrom(const SendInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::SendInvitationOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendInvitationRequest::CopyFrom(const SendInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendInvitationRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_options()) {
+    if (!this->options().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendInvitationRequest::Swap(SendInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendInvitationRequest_descriptor_;
+  metadata.reflection = SendInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AcceptInvitationRequest::kAgentIdFieldNumber;
+const int AcceptInvitationRequest::kClubIdFieldNumber;
+const int AcceptInvitationRequest::kInvitationIdFieldNumber;
+#endif  // !_MSC_VER
+
+AcceptInvitationRequest::AcceptInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.AcceptInvitationRequest)
+}
+
+void AcceptInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+AcceptInvitationRequest::AcceptInvitationRequest(const AcceptInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.AcceptInvitationRequest)
+}
+
+void AcceptInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AcceptInvitationRequest::~AcceptInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.AcceptInvitationRequest)
+  SharedDtor();
+}
+
+void AcceptInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void AcceptInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AcceptInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AcceptInvitationRequest_descriptor_;
+}
+
+const AcceptInvitationRequest& AcceptInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+AcceptInvitationRequest* AcceptInvitationRequest::default_instance_ = NULL;
+
+AcceptInvitationRequest* AcceptInvitationRequest::New() const {
+  return new AcceptInvitationRequest;
+}
+
+void AcceptInvitationRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AcceptInvitationRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, invitation_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AcceptInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.AcceptInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_invitation_id;
+        break;
+      }
+
+      // optional fixed64 invitation_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.AcceptInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.AcceptInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void AcceptInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.AcceptInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.AcceptInvitationRequest)
+}
+
+::google::protobuf::uint8* AcceptInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.AcceptInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.AcceptInvitationRequest)
+  return target;
+}
+
+int AcceptInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional fixed64 invitation_id = 3;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AcceptInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AcceptInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AcceptInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AcceptInvitationRequest::MergeFrom(const AcceptInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AcceptInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AcceptInvitationRequest::CopyFrom(const AcceptInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AcceptInvitationRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AcceptInvitationRequest::Swap(AcceptInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AcceptInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AcceptInvitationRequest_descriptor_;
+  metadata.reflection = AcceptInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DeclineInvitationRequest::kAgentIdFieldNumber;
+const int DeclineInvitationRequest::kClubIdFieldNumber;
+const int DeclineInvitationRequest::kInvitationIdFieldNumber;
+#endif  // !_MSC_VER
+
+DeclineInvitationRequest::DeclineInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.DeclineInvitationRequest)
+}
+
+void DeclineInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+DeclineInvitationRequest::DeclineInvitationRequest(const DeclineInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.DeclineInvitationRequest)
+}
+
+void DeclineInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DeclineInvitationRequest::~DeclineInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.DeclineInvitationRequest)
+  SharedDtor();
+}
+
+void DeclineInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void DeclineInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DeclineInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DeclineInvitationRequest_descriptor_;
+}
+
+const DeclineInvitationRequest& DeclineInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+DeclineInvitationRequest* DeclineInvitationRequest::default_instance_ = NULL;
+
+DeclineInvitationRequest* DeclineInvitationRequest::New() const {
+  return new DeclineInvitationRequest;
+}
+
+void DeclineInvitationRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<DeclineInvitationRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, invitation_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DeclineInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.DeclineInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_invitation_id;
+        break;
+      }
+
+      // optional fixed64 invitation_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.DeclineInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.DeclineInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void DeclineInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.DeclineInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.DeclineInvitationRequest)
+}
+
+::google::protobuf::uint8* DeclineInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.DeclineInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.DeclineInvitationRequest)
+  return target;
+}
+
+int DeclineInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional fixed64 invitation_id = 3;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DeclineInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DeclineInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DeclineInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DeclineInvitationRequest::MergeFrom(const DeclineInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DeclineInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DeclineInvitationRequest::CopyFrom(const DeclineInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DeclineInvitationRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DeclineInvitationRequest::Swap(DeclineInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DeclineInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DeclineInvitationRequest_descriptor_;
+  metadata.reflection = DeclineInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RevokeInvitationRequest::kAgentIdFieldNumber;
+const int RevokeInvitationRequest::kClubIdFieldNumber;
+const int RevokeInvitationRequest::kInvitationIdFieldNumber;
+#endif  // !_MSC_VER
+
+RevokeInvitationRequest::RevokeInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.RevokeInvitationRequest)
+}
+
+void RevokeInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+RevokeInvitationRequest::RevokeInvitationRequest(const RevokeInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.RevokeInvitationRequest)
+}
+
+void RevokeInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RevokeInvitationRequest::~RevokeInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.RevokeInvitationRequest)
+  SharedDtor();
+}
+
+void RevokeInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void RevokeInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RevokeInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RevokeInvitationRequest_descriptor_;
+}
+
+const RevokeInvitationRequest& RevokeInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+RevokeInvitationRequest* RevokeInvitationRequest::default_instance_ = NULL;
+
+RevokeInvitationRequest* RevokeInvitationRequest::New() const {
+  return new RevokeInvitationRequest;
+}
+
+void RevokeInvitationRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<RevokeInvitationRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, invitation_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RevokeInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.RevokeInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_invitation_id;
+        break;
+      }
+
+      // optional fixed64 invitation_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.RevokeInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.RevokeInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void RevokeInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.RevokeInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.RevokeInvitationRequest)
+}
+
+::google::protobuf::uint8* RevokeInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.RevokeInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.RevokeInvitationRequest)
+  return target;
+}
+
+int RevokeInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional fixed64 invitation_id = 3;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RevokeInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RevokeInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RevokeInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RevokeInvitationRequest::MergeFrom(const RevokeInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RevokeInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RevokeInvitationRequest::CopyFrom(const RevokeInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RevokeInvitationRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RevokeInvitationRequest::Swap(RevokeInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RevokeInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RevokeInvitationRequest_descriptor_;
+  metadata.reflection = RevokeInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetInvitationRequest::kAgentIdFieldNumber;
+const int GetInvitationRequest::kClubIdFieldNumber;
+const int GetInvitationRequest::kInvitationIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetInvitationRequest::GetInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetInvitationRequest)
+}
+
+void GetInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetInvitationRequest::GetInvitationRequest(const GetInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetInvitationRequest)
+}
+
+void GetInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetInvitationRequest::~GetInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetInvitationRequest)
+  SharedDtor();
+}
+
+void GetInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetInvitationRequest_descriptor_;
+}
+
+const GetInvitationRequest& GetInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetInvitationRequest* GetInvitationRequest::default_instance_ = NULL;
+
+GetInvitationRequest* GetInvitationRequest::New() const {
+  return new GetInvitationRequest;
+}
+
+void GetInvitationRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetInvitationRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, invitation_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_invitation_id;
+        break;
+      }
+
+      // optional fixed64 invitation_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void GetInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetInvitationRequest)
+}
+
+::google::protobuf::uint8* GetInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetInvitationRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetInvitationRequest)
+  return target;
+}
+
+int GetInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional fixed64 invitation_id = 3;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetInvitationRequest::MergeFrom(const GetInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetInvitationRequest::CopyFrom(const GetInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetInvitationRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetInvitationRequest::Swap(GetInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetInvitationRequest_descriptor_;
+  metadata.reflection = GetInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetInvitationResponse::kInvitationFieldNumber;
+#endif  // !_MSC_VER
+
+GetInvitationResponse::GetInvitationResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetInvitationResponse)
+}
+
+void GetInvitationResponse::InitAsDefaultInstance() {
+  invitation_ = const_cast< ::bgs::protocol::club::v1::ClubInvitation*>(&::bgs::protocol::club::v1::ClubInvitation::default_instance());
+}
+
+GetInvitationResponse::GetInvitationResponse(const GetInvitationResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetInvitationResponse)
+}
+
+void GetInvitationResponse::SharedCtor() {
+  _cached_size_ = 0;
+  invitation_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetInvitationResponse::~GetInvitationResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetInvitationResponse)
+  SharedDtor();
+}
+
+void GetInvitationResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete invitation_;
+  }
+}
+
+void GetInvitationResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetInvitationResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetInvitationResponse_descriptor_;
+}
+
+const GetInvitationResponse& GetInvitationResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetInvitationResponse* GetInvitationResponse::default_instance_ = NULL;
+
+GetInvitationResponse* GetInvitationResponse::New() const {
+  return new GetInvitationResponse;
+}
+
+void GetInvitationResponse::Clear() {
+  if (has_invitation()) {
+    if (invitation_ != NULL) invitation_->::bgs::protocol::club::v1::ClubInvitation::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetInvitationResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetInvitationResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_invitation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetInvitationResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetInvitationResponse)
+  return false;
+#undef DO_
+}
+
+void GetInvitationResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetInvitationResponse)
+  // optional .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+  if (has_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->invitation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetInvitationResponse)
+}
+
+::google::protobuf::uint8* GetInvitationResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetInvitationResponse)
+  // optional .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+  if (has_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->invitation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetInvitationResponse)
+  return target;
+}
+
+int GetInvitationResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+    if (has_invitation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->invitation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetInvitationResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetInvitationResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetInvitationResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetInvitationResponse::MergeFrom(const GetInvitationResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_invitation()) {
+      mutable_invitation()->::bgs::protocol::club::v1::ClubInvitation::MergeFrom(from.invitation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetInvitationResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetInvitationResponse::CopyFrom(const GetInvitationResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetInvitationResponse::IsInitialized() const {
+
+  if (has_invitation()) {
+    if (!this->invitation().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetInvitationResponse::Swap(GetInvitationResponse* other) {
+  if (other != this) {
+    std::swap(invitation_, other->invitation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetInvitationResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetInvitationResponse_descriptor_;
+  metadata.reflection = GetInvitationResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetInvitationsRequest::kAgentIdFieldNumber;
+const int GetInvitationsRequest::kClubIdFieldNumber;
+const int GetInvitationsRequest::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetInvitationsRequest::GetInvitationsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetInvitationsRequest)
+}
+
+void GetInvitationsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetInvitationsRequest::GetInvitationsRequest(const GetInvitationsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetInvitationsRequest)
+}
+
+void GetInvitationsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetInvitationsRequest::~GetInvitationsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetInvitationsRequest)
+  SharedDtor();
+}
+
+void GetInvitationsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetInvitationsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetInvitationsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetInvitationsRequest_descriptor_;
+}
+
+const GetInvitationsRequest& GetInvitationsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetInvitationsRequest* GetInvitationsRequest::default_instance_ = NULL;
+
+GetInvitationsRequest* GetInvitationsRequest::New() const {
+  return new GetInvitationsRequest;
+}
+
+void GetInvitationsRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetInvitationsRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, continuation_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetInvitationsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetInvitationsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetInvitationsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetInvitationsRequest)
+  return false;
+#undef DO_
+}
+
+void GetInvitationsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetInvitationsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetInvitationsRequest)
+}
+
+::google::protobuf::uint8* GetInvitationsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetInvitationsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetInvitationsRequest)
+  return target;
+}
+
+int GetInvitationsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 continuation = 3;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetInvitationsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetInvitationsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetInvitationsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetInvitationsRequest::MergeFrom(const GetInvitationsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetInvitationsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetInvitationsRequest::CopyFrom(const GetInvitationsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetInvitationsRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetInvitationsRequest::Swap(GetInvitationsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetInvitationsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetInvitationsRequest_descriptor_;
+  metadata.reflection = GetInvitationsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetInvitationsResponse::kInvitationFieldNumber;
+const int GetInvitationsResponse::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetInvitationsResponse::GetInvitationsResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetInvitationsResponse)
+}
+
+void GetInvitationsResponse::InitAsDefaultInstance() {
+}
+
+GetInvitationsResponse::GetInvitationsResponse(const GetInvitationsResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetInvitationsResponse)
+}
+
+void GetInvitationsResponse::SharedCtor() {
+  _cached_size_ = 0;
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetInvitationsResponse::~GetInvitationsResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetInvitationsResponse)
+  SharedDtor();
+}
+
+void GetInvitationsResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetInvitationsResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetInvitationsResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetInvitationsResponse_descriptor_;
+}
+
+const GetInvitationsResponse& GetInvitationsResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetInvitationsResponse* GetInvitationsResponse::default_instance_ = NULL;
+
+GetInvitationsResponse* GetInvitationsResponse::New() const {
+  return new GetInvitationsResponse;
+}
+
+void GetInvitationsResponse::Clear() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  invitation_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetInvitationsResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetInvitationsResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_invitation:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_invitation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_invitation;
+        if (input->ExpectTag(16)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetInvitationsResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetInvitationsResponse)
+  return false;
+#undef DO_
+}
+
+void GetInvitationsResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetInvitationsResponse)
+  // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+  for (int i = 0; i < this->invitation_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->invitation(i), output);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetInvitationsResponse)
+}
+
+::google::protobuf::uint8* GetInvitationsResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetInvitationsResponse)
+  // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+  for (int i = 0; i < this->invitation_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->invitation(i), target);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetInvitationsResponse)
+  return target;
+}
+
+int GetInvitationsResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint64 continuation = 2;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+  total_size += 1 * this->invitation_size();
+  for (int i = 0; i < this->invitation_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->invitation(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetInvitationsResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetInvitationsResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetInvitationsResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetInvitationsResponse::MergeFrom(const GetInvitationsResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  invitation_.MergeFrom(from.invitation_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetInvitationsResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetInvitationsResponse::CopyFrom(const GetInvitationsResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetInvitationsResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->invitation())) return false;
+  return true;
+}
+
+void GetInvitationsResponse::Swap(GetInvitationsResponse* other) {
+  if (other != this) {
+    invitation_.Swap(&other->invitation_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetInvitationsResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetInvitationsResponse_descriptor_;
+  metadata.reflection = GetInvitationsResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendSuggestionRequest::kAgentIdFieldNumber;
+const int SendSuggestionRequest::kClubIdFieldNumber;
+const int SendSuggestionRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+SendSuggestionRequest::SendSuggestionRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SendSuggestionRequest)
+}
+
+void SendSuggestionRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::SendSuggestionOptions*>(&::bgs::protocol::club::v1::SendSuggestionOptions::default_instance());
+}
+
+SendSuggestionRequest::SendSuggestionRequest(const SendSuggestionRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SendSuggestionRequest)
+}
+
+void SendSuggestionRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendSuggestionRequest::~SendSuggestionRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SendSuggestionRequest)
+  SharedDtor();
+}
+
+void SendSuggestionRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void SendSuggestionRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendSuggestionRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendSuggestionRequest_descriptor_;
+}
+
+const SendSuggestionRequest& SendSuggestionRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+SendSuggestionRequest* SendSuggestionRequest::default_instance_ = NULL;
+
+SendSuggestionRequest* SendSuggestionRequest::New() const {
+  return new SendSuggestionRequest;
+}
+
+void SendSuggestionRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::SendSuggestionOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendSuggestionRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SendSuggestionRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.SendSuggestionOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SendSuggestionRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SendSuggestionRequest)
+  return false;
+#undef DO_
+}
+
+void SendSuggestionRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SendSuggestionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.SendSuggestionOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SendSuggestionRequest)
+}
+
+::google::protobuf::uint8* SendSuggestionRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SendSuggestionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.SendSuggestionOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SendSuggestionRequest)
+  return target;
+}
+
+int SendSuggestionRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.SendSuggestionOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendSuggestionRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendSuggestionRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendSuggestionRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendSuggestionRequest::MergeFrom(const SendSuggestionRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::SendSuggestionOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendSuggestionRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendSuggestionRequest::CopyFrom(const SendSuggestionRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendSuggestionRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_options()) {
+    if (!this->options().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendSuggestionRequest::Swap(SendSuggestionRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendSuggestionRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendSuggestionRequest_descriptor_;
+  metadata.reflection = SendSuggestionRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AcceptSuggestionRequest::kAgentIdFieldNumber;
+const int AcceptSuggestionRequest::kClubIdFieldNumber;
+const int AcceptSuggestionRequest::kSuggestionIdFieldNumber;
+#endif  // !_MSC_VER
+
+AcceptSuggestionRequest::AcceptSuggestionRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.AcceptSuggestionRequest)
+}
+
+void AcceptSuggestionRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+AcceptSuggestionRequest::AcceptSuggestionRequest(const AcceptSuggestionRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.AcceptSuggestionRequest)
+}
+
+void AcceptSuggestionRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  suggestion_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AcceptSuggestionRequest::~AcceptSuggestionRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.AcceptSuggestionRequest)
+  SharedDtor();
+}
+
+void AcceptSuggestionRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void AcceptSuggestionRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AcceptSuggestionRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AcceptSuggestionRequest_descriptor_;
+}
+
+const AcceptSuggestionRequest& AcceptSuggestionRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+AcceptSuggestionRequest* AcceptSuggestionRequest::default_instance_ = NULL;
+
+AcceptSuggestionRequest* AcceptSuggestionRequest::New() const {
+  return new AcceptSuggestionRequest;
+}
+
+void AcceptSuggestionRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AcceptSuggestionRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, suggestion_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AcceptSuggestionRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.AcceptSuggestionRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_suggestion_id;
+        break;
+      }
+
+      // optional fixed64 suggestion_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_suggestion_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &suggestion_id_)));
+          set_has_suggestion_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.AcceptSuggestionRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.AcceptSuggestionRequest)
+  return false;
+#undef DO_
+}
+
+void AcceptSuggestionRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.AcceptSuggestionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional fixed64 suggestion_id = 3;
+  if (has_suggestion_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->suggestion_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.AcceptSuggestionRequest)
+}
+
+::google::protobuf::uint8* AcceptSuggestionRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.AcceptSuggestionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional fixed64 suggestion_id = 3;
+  if (has_suggestion_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->suggestion_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.AcceptSuggestionRequest)
+  return target;
+}
+
+int AcceptSuggestionRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional fixed64 suggestion_id = 3;
+    if (has_suggestion_id()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AcceptSuggestionRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AcceptSuggestionRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AcceptSuggestionRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AcceptSuggestionRequest::MergeFrom(const AcceptSuggestionRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_suggestion_id()) {
+      set_suggestion_id(from.suggestion_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AcceptSuggestionRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AcceptSuggestionRequest::CopyFrom(const AcceptSuggestionRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AcceptSuggestionRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AcceptSuggestionRequest::Swap(AcceptSuggestionRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(suggestion_id_, other->suggestion_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AcceptSuggestionRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AcceptSuggestionRequest_descriptor_;
+  metadata.reflection = AcceptSuggestionRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DeclineSuggestionRequest::kAgentIdFieldNumber;
+const int DeclineSuggestionRequest::kClubIdFieldNumber;
+const int DeclineSuggestionRequest::kSuggestionIdFieldNumber;
+#endif  // !_MSC_VER
+
+DeclineSuggestionRequest::DeclineSuggestionRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.DeclineSuggestionRequest)
+}
+
+void DeclineSuggestionRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+DeclineSuggestionRequest::DeclineSuggestionRequest(const DeclineSuggestionRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.DeclineSuggestionRequest)
+}
+
+void DeclineSuggestionRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  suggestion_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DeclineSuggestionRequest::~DeclineSuggestionRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.DeclineSuggestionRequest)
+  SharedDtor();
+}
+
+void DeclineSuggestionRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void DeclineSuggestionRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DeclineSuggestionRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DeclineSuggestionRequest_descriptor_;
+}
+
+const DeclineSuggestionRequest& DeclineSuggestionRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+DeclineSuggestionRequest* DeclineSuggestionRequest::default_instance_ = NULL;
+
+DeclineSuggestionRequest* DeclineSuggestionRequest::New() const {
+  return new DeclineSuggestionRequest;
+}
+
+void DeclineSuggestionRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<DeclineSuggestionRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, suggestion_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DeclineSuggestionRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.DeclineSuggestionRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_suggestion_id;
+        break;
+      }
+
+      // optional fixed64 suggestion_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_suggestion_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &suggestion_id_)));
+          set_has_suggestion_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.DeclineSuggestionRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.DeclineSuggestionRequest)
+  return false;
+#undef DO_
+}
+
+void DeclineSuggestionRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.DeclineSuggestionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional fixed64 suggestion_id = 3;
+  if (has_suggestion_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->suggestion_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.DeclineSuggestionRequest)
+}
+
+::google::protobuf::uint8* DeclineSuggestionRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.DeclineSuggestionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional fixed64 suggestion_id = 3;
+  if (has_suggestion_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->suggestion_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.DeclineSuggestionRequest)
+  return target;
+}
+
+int DeclineSuggestionRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional fixed64 suggestion_id = 3;
+    if (has_suggestion_id()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DeclineSuggestionRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DeclineSuggestionRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DeclineSuggestionRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DeclineSuggestionRequest::MergeFrom(const DeclineSuggestionRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_suggestion_id()) {
+      set_suggestion_id(from.suggestion_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DeclineSuggestionRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DeclineSuggestionRequest::CopyFrom(const DeclineSuggestionRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DeclineSuggestionRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DeclineSuggestionRequest::Swap(DeclineSuggestionRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(suggestion_id_, other->suggestion_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DeclineSuggestionRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DeclineSuggestionRequest_descriptor_;
+  metadata.reflection = DeclineSuggestionRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetSuggestionRequest::kAgentIdFieldNumber;
+const int GetSuggestionRequest::kClubIdFieldNumber;
+const int GetSuggestionRequest::kSuggestionIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetSuggestionRequest::GetSuggestionRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetSuggestionRequest)
+}
+
+void GetSuggestionRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetSuggestionRequest::GetSuggestionRequest(const GetSuggestionRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetSuggestionRequest)
+}
+
+void GetSuggestionRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  suggestion_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetSuggestionRequest::~GetSuggestionRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetSuggestionRequest)
+  SharedDtor();
+}
+
+void GetSuggestionRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetSuggestionRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetSuggestionRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetSuggestionRequest_descriptor_;
+}
+
+const GetSuggestionRequest& GetSuggestionRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetSuggestionRequest* GetSuggestionRequest::default_instance_ = NULL;
+
+GetSuggestionRequest* GetSuggestionRequest::New() const {
+  return new GetSuggestionRequest;
+}
+
+void GetSuggestionRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetSuggestionRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, suggestion_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetSuggestionRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetSuggestionRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_suggestion_id;
+        break;
+      }
+
+      // optional fixed64 suggestion_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_suggestion_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &suggestion_id_)));
+          set_has_suggestion_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetSuggestionRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetSuggestionRequest)
+  return false;
+#undef DO_
+}
+
+void GetSuggestionRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetSuggestionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional fixed64 suggestion_id = 3;
+  if (has_suggestion_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->suggestion_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetSuggestionRequest)
+}
+
+::google::protobuf::uint8* GetSuggestionRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetSuggestionRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional fixed64 suggestion_id = 3;
+  if (has_suggestion_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->suggestion_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetSuggestionRequest)
+  return target;
+}
+
+int GetSuggestionRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional fixed64 suggestion_id = 3;
+    if (has_suggestion_id()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetSuggestionRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetSuggestionRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetSuggestionRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetSuggestionRequest::MergeFrom(const GetSuggestionRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_suggestion_id()) {
+      set_suggestion_id(from.suggestion_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetSuggestionRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetSuggestionRequest::CopyFrom(const GetSuggestionRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetSuggestionRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetSuggestionRequest::Swap(GetSuggestionRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(suggestion_id_, other->suggestion_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetSuggestionRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetSuggestionRequest_descriptor_;
+  metadata.reflection = GetSuggestionRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetSuggestionResponse::kSuggestionFieldNumber;
+#endif  // !_MSC_VER
+
+GetSuggestionResponse::GetSuggestionResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetSuggestionResponse)
+}
+
+void GetSuggestionResponse::InitAsDefaultInstance() {
+  suggestion_ = const_cast< ::bgs::protocol::club::v1::ClubSuggestion*>(&::bgs::protocol::club::v1::ClubSuggestion::default_instance());
+}
+
+GetSuggestionResponse::GetSuggestionResponse(const GetSuggestionResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetSuggestionResponse)
+}
+
+void GetSuggestionResponse::SharedCtor() {
+  _cached_size_ = 0;
+  suggestion_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetSuggestionResponse::~GetSuggestionResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetSuggestionResponse)
+  SharedDtor();
+}
+
+void GetSuggestionResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete suggestion_;
+  }
+}
+
+void GetSuggestionResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetSuggestionResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetSuggestionResponse_descriptor_;
+}
+
+const GetSuggestionResponse& GetSuggestionResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetSuggestionResponse* GetSuggestionResponse::default_instance_ = NULL;
+
+GetSuggestionResponse* GetSuggestionResponse::New() const {
+  return new GetSuggestionResponse;
+}
+
+void GetSuggestionResponse::Clear() {
+  if (has_suggestion()) {
+    if (suggestion_ != NULL) suggestion_->::bgs::protocol::club::v1::ClubSuggestion::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetSuggestionResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetSuggestionResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suggestion()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetSuggestionResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetSuggestionResponse)
+  return false;
+#undef DO_
+}
+
+void GetSuggestionResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetSuggestionResponse)
+  // optional .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+  if (has_suggestion()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->suggestion(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetSuggestionResponse)
+}
+
+::google::protobuf::uint8* GetSuggestionResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetSuggestionResponse)
+  // optional .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+  if (has_suggestion()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->suggestion(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetSuggestionResponse)
+  return target;
+}
+
+int GetSuggestionResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+    if (has_suggestion()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suggestion());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetSuggestionResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetSuggestionResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetSuggestionResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetSuggestionResponse::MergeFrom(const GetSuggestionResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_suggestion()) {
+      mutable_suggestion()->::bgs::protocol::club::v1::ClubSuggestion::MergeFrom(from.suggestion());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetSuggestionResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetSuggestionResponse::CopyFrom(const GetSuggestionResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetSuggestionResponse::IsInitialized() const {
+
+  if (has_suggestion()) {
+    if (!this->suggestion().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetSuggestionResponse::Swap(GetSuggestionResponse* other) {
+  if (other != this) {
+    std::swap(suggestion_, other->suggestion_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetSuggestionResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetSuggestionResponse_descriptor_;
+  metadata.reflection = GetSuggestionResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetSuggestionsRequest::kAgentIdFieldNumber;
+const int GetSuggestionsRequest::kClubIdFieldNumber;
+const int GetSuggestionsRequest::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetSuggestionsRequest::GetSuggestionsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetSuggestionsRequest)
+}
+
+void GetSuggestionsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetSuggestionsRequest::GetSuggestionsRequest(const GetSuggestionsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetSuggestionsRequest)
+}
+
+void GetSuggestionsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetSuggestionsRequest::~GetSuggestionsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetSuggestionsRequest)
+  SharedDtor();
+}
+
+void GetSuggestionsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetSuggestionsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetSuggestionsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetSuggestionsRequest_descriptor_;
+}
+
+const GetSuggestionsRequest& GetSuggestionsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetSuggestionsRequest* GetSuggestionsRequest::default_instance_ = NULL;
+
+GetSuggestionsRequest* GetSuggestionsRequest::New() const {
+  return new GetSuggestionsRequest;
+}
+
+void GetSuggestionsRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetSuggestionsRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, continuation_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetSuggestionsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetSuggestionsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetSuggestionsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetSuggestionsRequest)
+  return false;
+#undef DO_
+}
+
+void GetSuggestionsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetSuggestionsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetSuggestionsRequest)
+}
+
+::google::protobuf::uint8* GetSuggestionsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetSuggestionsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetSuggestionsRequest)
+  return target;
+}
+
+int GetSuggestionsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 continuation = 3;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetSuggestionsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetSuggestionsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetSuggestionsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetSuggestionsRequest::MergeFrom(const GetSuggestionsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetSuggestionsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetSuggestionsRequest::CopyFrom(const GetSuggestionsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetSuggestionsRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetSuggestionsRequest::Swap(GetSuggestionsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetSuggestionsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetSuggestionsRequest_descriptor_;
+  metadata.reflection = GetSuggestionsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetSuggestionsResponse::kSuggestionFieldNumber;
+const int GetSuggestionsResponse::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetSuggestionsResponse::GetSuggestionsResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetSuggestionsResponse)
+}
+
+void GetSuggestionsResponse::InitAsDefaultInstance() {
+}
+
+GetSuggestionsResponse::GetSuggestionsResponse(const GetSuggestionsResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetSuggestionsResponse)
+}
+
+void GetSuggestionsResponse::SharedCtor() {
+  _cached_size_ = 0;
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetSuggestionsResponse::~GetSuggestionsResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetSuggestionsResponse)
+  SharedDtor();
+}
+
+void GetSuggestionsResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetSuggestionsResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetSuggestionsResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetSuggestionsResponse_descriptor_;
+}
+
+const GetSuggestionsResponse& GetSuggestionsResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetSuggestionsResponse* GetSuggestionsResponse::default_instance_ = NULL;
+
+GetSuggestionsResponse* GetSuggestionsResponse::New() const {
+  return new GetSuggestionsResponse;
+}
+
+void GetSuggestionsResponse::Clear() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  suggestion_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetSuggestionsResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetSuggestionsResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_suggestion:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_suggestion()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_suggestion;
+        if (input->ExpectTag(16)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetSuggestionsResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetSuggestionsResponse)
+  return false;
+#undef DO_
+}
+
+void GetSuggestionsResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetSuggestionsResponse)
+  // repeated .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+  for (int i = 0; i < this->suggestion_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->suggestion(i), output);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetSuggestionsResponse)
+}
+
+::google::protobuf::uint8* GetSuggestionsResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetSuggestionsResponse)
+  // repeated .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+  for (int i = 0; i < this->suggestion_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->suggestion(i), target);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetSuggestionsResponse)
+  return target;
+}
+
+int GetSuggestionsResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint64 continuation = 2;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+  total_size += 1 * this->suggestion_size();
+  for (int i = 0; i < this->suggestion_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->suggestion(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetSuggestionsResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetSuggestionsResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetSuggestionsResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetSuggestionsResponse::MergeFrom(const GetSuggestionsResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  suggestion_.MergeFrom(from.suggestion_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetSuggestionsResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetSuggestionsResponse::CopyFrom(const GetSuggestionsResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetSuggestionsResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->suggestion())) return false;
+  return true;
+}
+
+void GetSuggestionsResponse::Swap(GetSuggestionsResponse* other) {
+  if (other != this) {
+    suggestion_.Swap(&other->suggestion_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetSuggestionsResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetSuggestionsResponse_descriptor_;
+  metadata.reflection = GetSuggestionsResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateTicketRequest::kAgentIdFieldNumber;
+const int CreateTicketRequest::kClubIdFieldNumber;
+const int CreateTicketRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+CreateTicketRequest::CreateTicketRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateTicketRequest)
+}
+
+void CreateTicketRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::CreateTicketOptions*>(&::bgs::protocol::club::v1::CreateTicketOptions::default_instance());
+}
+
+CreateTicketRequest::CreateTicketRequest(const CreateTicketRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateTicketRequest)
+}
+
+void CreateTicketRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateTicketRequest::~CreateTicketRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateTicketRequest)
+  SharedDtor();
+}
+
+void CreateTicketRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void CreateTicketRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateTicketRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateTicketRequest_descriptor_;
+}
+
+const CreateTicketRequest& CreateTicketRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+CreateTicketRequest* CreateTicketRequest::default_instance_ = NULL;
+
+CreateTicketRequest* CreateTicketRequest::New() const {
+  return new CreateTicketRequest;
+}
+
+void CreateTicketRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateTicketOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateTicketRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateTicketRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.CreateTicketOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateTicketRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateTicketRequest)
+  return false;
+#undef DO_
+}
+
+void CreateTicketRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateTicketRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateTicketOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateTicketRequest)
+}
+
+::google::protobuf::uint8* CreateTicketRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateTicketRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateTicketOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateTicketRequest)
+  return target;
+}
+
+int CreateTicketRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.CreateTicketOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateTicketRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateTicketRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateTicketRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateTicketRequest::MergeFrom(const CreateTicketRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::CreateTicketOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateTicketRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateTicketRequest::CopyFrom(const CreateTicketRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateTicketRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CreateTicketRequest::Swap(CreateTicketRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateTicketRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateTicketRequest_descriptor_;
+  metadata.reflection = CreateTicketRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateTicketResponse::kTicketFieldNumber;
+#endif  // !_MSC_VER
+
+CreateTicketResponse::CreateTicketResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateTicketResponse)
+}
+
+void CreateTicketResponse::InitAsDefaultInstance() {
+  ticket_ = const_cast< ::bgs::protocol::club::v1::ClubTicket*>(&::bgs::protocol::club::v1::ClubTicket::default_instance());
+}
+
+CreateTicketResponse::CreateTicketResponse(const CreateTicketResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateTicketResponse)
+}
+
+void CreateTicketResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ticket_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateTicketResponse::~CreateTicketResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateTicketResponse)
+  SharedDtor();
+}
+
+void CreateTicketResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete ticket_;
+  }
+}
+
+void CreateTicketResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateTicketResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateTicketResponse_descriptor_;
+}
+
+const CreateTicketResponse& CreateTicketResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+CreateTicketResponse* CreateTicketResponse::default_instance_ = NULL;
+
+CreateTicketResponse* CreateTicketResponse::New() const {
+  return new CreateTicketResponse;
+}
+
+void CreateTicketResponse::Clear() {
+  if (has_ticket()) {
+    if (ticket_ != NULL) ticket_->::bgs::protocol::club::v1::ClubTicket::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateTicketResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateTicketResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_ticket()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateTicketResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateTicketResponse)
+  return false;
+#undef DO_
+}
+
+void CreateTicketResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateTicketResponse)
+  // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  if (has_ticket()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->ticket(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateTicketResponse)
+}
+
+::google::protobuf::uint8* CreateTicketResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateTicketResponse)
+  // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  if (has_ticket()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->ticket(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateTicketResponse)
+  return target;
+}
+
+int CreateTicketResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+    if (has_ticket()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->ticket());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateTicketResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateTicketResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateTicketResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateTicketResponse::MergeFrom(const CreateTicketResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_ticket()) {
+      mutable_ticket()->::bgs::protocol::club::v1::ClubTicket::MergeFrom(from.ticket());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateTicketResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateTicketResponse::CopyFrom(const CreateTicketResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateTicketResponse::IsInitialized() const {
+
+  if (has_ticket()) {
+    if (!this->ticket().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CreateTicketResponse::Swap(CreateTicketResponse* other) {
+  if (other != this) {
+    std::swap(ticket_, other->ticket_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateTicketResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateTicketResponse_descriptor_;
+  metadata.reflection = CreateTicketResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DestroyTicketRequest::kAgentIdFieldNumber;
+const int DestroyTicketRequest::kClubIdFieldNumber;
+const int DestroyTicketRequest::kTicketIdFieldNumber;
+#endif  // !_MSC_VER
+
+DestroyTicketRequest::DestroyTicketRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.DestroyTicketRequest)
+}
+
+void DestroyTicketRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+DestroyTicketRequest::DestroyTicketRequest(const DestroyTicketRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.DestroyTicketRequest)
+}
+
+void DestroyTicketRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ticket_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DestroyTicketRequest::~DestroyTicketRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.DestroyTicketRequest)
+  SharedDtor();
+}
+
+void DestroyTicketRequest::SharedDtor() {
+  if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ticket_id_;
+  }
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void DestroyTicketRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DestroyTicketRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DestroyTicketRequest_descriptor_;
+}
+
+const DestroyTicketRequest& DestroyTicketRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+DestroyTicketRequest* DestroyTicketRequest::default_instance_ = NULL;
+
+DestroyTicketRequest* DestroyTicketRequest::New() const {
+  return new DestroyTicketRequest;
+}
+
+void DestroyTicketRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_ticket_id()) {
+      if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        ticket_id_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DestroyTicketRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.DestroyTicketRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_ticket_id;
+        break;
+      }
+
+      // optional string ticket_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_ticket_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_ticket_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->ticket_id().data(), this->ticket_id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "ticket_id");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.DestroyTicketRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.DestroyTicketRequest)
+  return false;
+#undef DO_
+}
+
+void DestroyTicketRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.DestroyTicketRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional string ticket_id = 3;
+  if (has_ticket_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->ticket_id().data(), this->ticket_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "ticket_id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->ticket_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.DestroyTicketRequest)
+}
+
+::google::protobuf::uint8* DestroyTicketRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.DestroyTicketRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional string ticket_id = 3;
+  if (has_ticket_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->ticket_id().data(), this->ticket_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "ticket_id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->ticket_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.DestroyTicketRequest)
+  return target;
+}
+
+int DestroyTicketRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional string ticket_id = 3;
+    if (has_ticket_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->ticket_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DestroyTicketRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DestroyTicketRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DestroyTicketRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DestroyTicketRequest::MergeFrom(const DestroyTicketRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_ticket_id()) {
+      set_ticket_id(from.ticket_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DestroyTicketRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DestroyTicketRequest::CopyFrom(const DestroyTicketRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DestroyTicketRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DestroyTicketRequest::Swap(DestroyTicketRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(ticket_id_, other->ticket_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DestroyTicketRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DestroyTicketRequest_descriptor_;
+  metadata.reflection = DestroyTicketRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RedeemTicketRequest::kAgentIdFieldNumber;
+const int RedeemTicketRequest::kTicketIdFieldNumber;
+#endif  // !_MSC_VER
+
+RedeemTicketRequest::RedeemTicketRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.RedeemTicketRequest)
+}
+
+void RedeemTicketRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+RedeemTicketRequest::RedeemTicketRequest(const RedeemTicketRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.RedeemTicketRequest)
+}
+
+void RedeemTicketRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ticket_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RedeemTicketRequest::~RedeemTicketRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.RedeemTicketRequest)
+  SharedDtor();
+}
+
+void RedeemTicketRequest::SharedDtor() {
+  if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ticket_id_;
+  }
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void RedeemTicketRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RedeemTicketRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RedeemTicketRequest_descriptor_;
+}
+
+const RedeemTicketRequest& RedeemTicketRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+RedeemTicketRequest* RedeemTicketRequest::default_instance_ = NULL;
+
+RedeemTicketRequest* RedeemTicketRequest::New() const {
+  return new RedeemTicketRequest;
+}
+
+void RedeemTicketRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_ticket_id()) {
+      if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        ticket_id_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RedeemTicketRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.RedeemTicketRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_ticket_id;
+        break;
+      }
+
+      // optional string ticket_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_ticket_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_ticket_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->ticket_id().data(), this->ticket_id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "ticket_id");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.RedeemTicketRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.RedeemTicketRequest)
+  return false;
+#undef DO_
+}
+
+void RedeemTicketRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.RedeemTicketRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional string ticket_id = 3;
+  if (has_ticket_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->ticket_id().data(), this->ticket_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "ticket_id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->ticket_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.RedeemTicketRequest)
+}
+
+::google::protobuf::uint8* RedeemTicketRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.RedeemTicketRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional string ticket_id = 3;
+  if (has_ticket_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->ticket_id().data(), this->ticket_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "ticket_id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->ticket_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.RedeemTicketRequest)
+  return target;
+}
+
+int RedeemTicketRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional string ticket_id = 3;
+    if (has_ticket_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->ticket_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RedeemTicketRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RedeemTicketRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RedeemTicketRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RedeemTicketRequest::MergeFrom(const RedeemTicketRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_ticket_id()) {
+      set_ticket_id(from.ticket_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RedeemTicketRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RedeemTicketRequest::CopyFrom(const RedeemTicketRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RedeemTicketRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RedeemTicketRequest::Swap(RedeemTicketRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(ticket_id_, other->ticket_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RedeemTicketRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RedeemTicketRequest_descriptor_;
+  metadata.reflection = RedeemTicketRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetTicketRequest::kAgentIdFieldNumber;
+const int GetTicketRequest::kTicketIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetTicketRequest::GetTicketRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetTicketRequest)
+}
+
+void GetTicketRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetTicketRequest::GetTicketRequest(const GetTicketRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetTicketRequest)
+}
+
+void GetTicketRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ticket_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetTicketRequest::~GetTicketRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetTicketRequest)
+  SharedDtor();
+}
+
+void GetTicketRequest::SharedDtor() {
+  if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ticket_id_;
+  }
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetTicketRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetTicketRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetTicketRequest_descriptor_;
+}
+
+const GetTicketRequest& GetTicketRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetTicketRequest* GetTicketRequest::default_instance_ = NULL;
+
+GetTicketRequest* GetTicketRequest::New() const {
+  return new GetTicketRequest;
+}
+
+void GetTicketRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_ticket_id()) {
+      if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        ticket_id_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetTicketRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetTicketRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_ticket_id;
+        break;
+      }
+
+      // optional string ticket_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_ticket_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_ticket_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->ticket_id().data(), this->ticket_id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "ticket_id");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetTicketRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetTicketRequest)
+  return false;
+#undef DO_
+}
+
+void GetTicketRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetTicketRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional string ticket_id = 3;
+  if (has_ticket_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->ticket_id().data(), this->ticket_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "ticket_id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->ticket_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetTicketRequest)
+}
+
+::google::protobuf::uint8* GetTicketRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetTicketRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional string ticket_id = 3;
+  if (has_ticket_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->ticket_id().data(), this->ticket_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "ticket_id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->ticket_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetTicketRequest)
+  return target;
+}
+
+int GetTicketRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional string ticket_id = 3;
+    if (has_ticket_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->ticket_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetTicketRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetTicketRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetTicketRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetTicketRequest::MergeFrom(const GetTicketRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_ticket_id()) {
+      set_ticket_id(from.ticket_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetTicketRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetTicketRequest::CopyFrom(const GetTicketRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetTicketRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetTicketRequest::Swap(GetTicketRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(ticket_id_, other->ticket_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetTicketRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetTicketRequest_descriptor_;
+  metadata.reflection = GetTicketRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetTicketResponse::kTicketFieldNumber;
+#endif  // !_MSC_VER
+
+GetTicketResponse::GetTicketResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetTicketResponse)
+}
+
+void GetTicketResponse::InitAsDefaultInstance() {
+  ticket_ = const_cast< ::bgs::protocol::club::v1::ClubTicket*>(&::bgs::protocol::club::v1::ClubTicket::default_instance());
+}
+
+GetTicketResponse::GetTicketResponse(const GetTicketResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetTicketResponse)
+}
+
+void GetTicketResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ticket_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetTicketResponse::~GetTicketResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetTicketResponse)
+  SharedDtor();
+}
+
+void GetTicketResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete ticket_;
+  }
+}
+
+void GetTicketResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetTicketResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetTicketResponse_descriptor_;
+}
+
+const GetTicketResponse& GetTicketResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetTicketResponse* GetTicketResponse::default_instance_ = NULL;
+
+GetTicketResponse* GetTicketResponse::New() const {
+  return new GetTicketResponse;
+}
+
+void GetTicketResponse::Clear() {
+  if (has_ticket()) {
+    if (ticket_ != NULL) ticket_->::bgs::protocol::club::v1::ClubTicket::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetTicketResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetTicketResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_ticket()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetTicketResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetTicketResponse)
+  return false;
+#undef DO_
+}
+
+void GetTicketResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetTicketResponse)
+  // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  if (has_ticket()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->ticket(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetTicketResponse)
+}
+
+::google::protobuf::uint8* GetTicketResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetTicketResponse)
+  // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  if (has_ticket()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->ticket(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetTicketResponse)
+  return target;
+}
+
+int GetTicketResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+    if (has_ticket()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->ticket());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetTicketResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetTicketResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetTicketResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetTicketResponse::MergeFrom(const GetTicketResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_ticket()) {
+      mutable_ticket()->::bgs::protocol::club::v1::ClubTicket::MergeFrom(from.ticket());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetTicketResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetTicketResponse::CopyFrom(const GetTicketResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetTicketResponse::IsInitialized() const {
+
+  if (has_ticket()) {
+    if (!this->ticket().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetTicketResponse::Swap(GetTicketResponse* other) {
+  if (other != this) {
+    std::swap(ticket_, other->ticket_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetTicketResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetTicketResponse_descriptor_;
+  metadata.reflection = GetTicketResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetTicketsRequest::kAgentIdFieldNumber;
+const int GetTicketsRequest::kClubIdFieldNumber;
+const int GetTicketsRequest::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetTicketsRequest::GetTicketsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetTicketsRequest)
+}
+
+void GetTicketsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetTicketsRequest::GetTicketsRequest(const GetTicketsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetTicketsRequest)
+}
+
+void GetTicketsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetTicketsRequest::~GetTicketsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetTicketsRequest)
+  SharedDtor();
+}
+
+void GetTicketsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetTicketsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetTicketsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetTicketsRequest_descriptor_;
+}
+
+const GetTicketsRequest& GetTicketsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetTicketsRequest* GetTicketsRequest::default_instance_ = NULL;
+
+GetTicketsRequest* GetTicketsRequest::New() const {
+  return new GetTicketsRequest;
+}
+
+void GetTicketsRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetTicketsRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, continuation_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetTicketsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetTicketsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetTicketsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetTicketsRequest)
+  return false;
+#undef DO_
+}
+
+void GetTicketsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetTicketsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetTicketsRequest)
+}
+
+::google::protobuf::uint8* GetTicketsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetTicketsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetTicketsRequest)
+  return target;
+}
+
+int GetTicketsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 continuation = 3;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetTicketsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetTicketsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetTicketsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetTicketsRequest::MergeFrom(const GetTicketsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetTicketsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetTicketsRequest::CopyFrom(const GetTicketsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetTicketsRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetTicketsRequest::Swap(GetTicketsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetTicketsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetTicketsRequest_descriptor_;
+  metadata.reflection = GetTicketsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetTicketsResponse::kTicketFieldNumber;
+const int GetTicketsResponse::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetTicketsResponse::GetTicketsResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetTicketsResponse)
+}
+
+void GetTicketsResponse::InitAsDefaultInstance() {
+}
+
+GetTicketsResponse::GetTicketsResponse(const GetTicketsResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetTicketsResponse)
+}
+
+void GetTicketsResponse::SharedCtor() {
+  _cached_size_ = 0;
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetTicketsResponse::~GetTicketsResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetTicketsResponse)
+  SharedDtor();
+}
+
+void GetTicketsResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetTicketsResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetTicketsResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetTicketsResponse_descriptor_;
+}
+
+const GetTicketsResponse& GetTicketsResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetTicketsResponse* GetTicketsResponse::default_instance_ = NULL;
+
+GetTicketsResponse* GetTicketsResponse::New() const {
+  return new GetTicketsResponse;
+}
+
+void GetTicketsResponse::Clear() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ticket_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetTicketsResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetTicketsResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.ClubTicket ticket = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_ticket:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_ticket()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_ticket;
+        if (input->ExpectTag(16)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetTicketsResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetTicketsResponse)
+  return false;
+#undef DO_
+}
+
+void GetTicketsResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetTicketsResponse)
+  // repeated .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  for (int i = 0; i < this->ticket_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->ticket(i), output);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetTicketsResponse)
+}
+
+::google::protobuf::uint8* GetTicketsResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetTicketsResponse)
+  // repeated .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  for (int i = 0; i < this->ticket_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->ticket(i), target);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetTicketsResponse)
+  return target;
+}
+
+int GetTicketsResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint64 continuation = 2;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  total_size += 1 * this->ticket_size();
+  for (int i = 0; i < this->ticket_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->ticket(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetTicketsResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetTicketsResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetTicketsResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetTicketsResponse::MergeFrom(const GetTicketsResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  ticket_.MergeFrom(from.ticket_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetTicketsResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetTicketsResponse::CopyFrom(const GetTicketsResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetTicketsResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->ticket())) return false;
+  return true;
+}
+
+void GetTicketsResponse::Swap(GetTicketsResponse* other) {
+  if (other != this) {
+    ticket_.Swap(&other->ticket_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetTicketsResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetTicketsResponse_descriptor_;
+  metadata.reflection = GetTicketsResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AddBanRequest::kAgentIdFieldNumber;
+const int AddBanRequest::kClubIdFieldNumber;
+const int AddBanRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+AddBanRequest::AddBanRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.AddBanRequest)
+}
+
+void AddBanRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::AddBanOptions*>(&::bgs::protocol::club::v1::AddBanOptions::default_instance());
+}
+
+AddBanRequest::AddBanRequest(const AddBanRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.AddBanRequest)
+}
+
+void AddBanRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AddBanRequest::~AddBanRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.AddBanRequest)
+  SharedDtor();
+}
+
+void AddBanRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void AddBanRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AddBanRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AddBanRequest_descriptor_;
+}
+
+const AddBanRequest& AddBanRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+AddBanRequest* AddBanRequest::default_instance_ = NULL;
+
+AddBanRequest* AddBanRequest::New() const {
+  return new AddBanRequest;
+}
+
+void AddBanRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::AddBanOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AddBanRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.AddBanRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.AddBanOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.AddBanRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.AddBanRequest)
+  return false;
+#undef DO_
+}
+
+void AddBanRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.AddBanRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.AddBanOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.AddBanRequest)
+}
+
+::google::protobuf::uint8* AddBanRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.AddBanRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.AddBanOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.AddBanRequest)
+  return target;
+}
+
+int AddBanRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.AddBanOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AddBanRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AddBanRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AddBanRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AddBanRequest::MergeFrom(const AddBanRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::AddBanOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AddBanRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AddBanRequest::CopyFrom(const AddBanRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AddBanRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_options()) {
+    if (!this->options().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AddBanRequest::Swap(AddBanRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AddBanRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AddBanRequest_descriptor_;
+  metadata.reflection = AddBanRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RemoveBanRequest::kAgentIdFieldNumber;
+const int RemoveBanRequest::kClubIdFieldNumber;
+const int RemoveBanRequest::kTargetIdFieldNumber;
+#endif  // !_MSC_VER
+
+RemoveBanRequest::RemoveBanRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.RemoveBanRequest)
+}
+
+void RemoveBanRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+RemoveBanRequest::RemoveBanRequest(const RemoveBanRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.RemoveBanRequest)
+}
+
+void RemoveBanRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  target_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RemoveBanRequest::~RemoveBanRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.RemoveBanRequest)
+  SharedDtor();
+}
+
+void RemoveBanRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void RemoveBanRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RemoveBanRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RemoveBanRequest_descriptor_;
+}
+
+const RemoveBanRequest& RemoveBanRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+RemoveBanRequest* RemoveBanRequest::default_instance_ = NULL;
+
+RemoveBanRequest* RemoveBanRequest::New() const {
+  return new RemoveBanRequest;
+}
+
+void RemoveBanRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RemoveBanRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.RemoveBanRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_target_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.RemoveBanRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.RemoveBanRequest)
+  return false;
+#undef DO_
+}
+
+void RemoveBanRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.RemoveBanRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->target_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.RemoveBanRequest)
+}
+
+::google::protobuf::uint8* RemoveBanRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.RemoveBanRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->target_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.RemoveBanRequest)
+  return target;
+}
+
+int RemoveBanRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RemoveBanRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RemoveBanRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RemoveBanRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RemoveBanRequest::MergeFrom(const RemoveBanRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.target_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RemoveBanRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RemoveBanRequest::CopyFrom(const RemoveBanRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RemoveBanRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RemoveBanRequest::Swap(RemoveBanRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RemoveBanRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RemoveBanRequest_descriptor_;
+  metadata.reflection = RemoveBanRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetBanRequest::kAgentIdFieldNumber;
+const int GetBanRequest::kClubIdFieldNumber;
+const int GetBanRequest::kTargetIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetBanRequest::GetBanRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetBanRequest)
+}
+
+void GetBanRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetBanRequest::GetBanRequest(const GetBanRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetBanRequest)
+}
+
+void GetBanRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  target_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetBanRequest::~GetBanRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetBanRequest)
+  SharedDtor();
+}
+
+void GetBanRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void GetBanRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetBanRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetBanRequest_descriptor_;
+}
+
+const GetBanRequest& GetBanRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetBanRequest* GetBanRequest::default_instance_ = NULL;
+
+GetBanRequest* GetBanRequest::New() const {
+  return new GetBanRequest;
+}
+
+void GetBanRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetBanRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetBanRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_target_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetBanRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetBanRequest)
+  return false;
+#undef DO_
+}
+
+void GetBanRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetBanRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->target_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetBanRequest)
+}
+
+::google::protobuf::uint8* GetBanRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetBanRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->target_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetBanRequest)
+  return target;
+}
+
+int GetBanRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetBanRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetBanRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetBanRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetBanRequest::MergeFrom(const GetBanRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.target_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetBanRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetBanRequest::CopyFrom(const GetBanRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetBanRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetBanRequest::Swap(GetBanRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetBanRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetBanRequest_descriptor_;
+  metadata.reflection = GetBanRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetBanResponse::kBanFieldNumber;
+#endif  // !_MSC_VER
+
+GetBanResponse::GetBanResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetBanResponse)
+}
+
+void GetBanResponse::InitAsDefaultInstance() {
+  ban_ = const_cast< ::bgs::protocol::club::v1::ClubBan*>(&::bgs::protocol::club::v1::ClubBan::default_instance());
+}
+
+GetBanResponse::GetBanResponse(const GetBanResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetBanResponse)
+}
+
+void GetBanResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ban_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetBanResponse::~GetBanResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetBanResponse)
+  SharedDtor();
+}
+
+void GetBanResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete ban_;
+  }
+}
+
+void GetBanResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetBanResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetBanResponse_descriptor_;
+}
+
+const GetBanResponse& GetBanResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetBanResponse* GetBanResponse::default_instance_ = NULL;
+
+GetBanResponse* GetBanResponse::New() const {
+  return new GetBanResponse;
+}
+
+void GetBanResponse::Clear() {
+  if (has_ban()) {
+    if (ban_ != NULL) ban_->::bgs::protocol::club::v1::ClubBan::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetBanResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetBanResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.ClubBan ban = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_ban()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetBanResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetBanResponse)
+  return false;
+#undef DO_
+}
+
+void GetBanResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetBanResponse)
+  // optional .bgs.protocol.club.v1.ClubBan ban = 1;
+  if (has_ban()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->ban(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetBanResponse)
+}
+
+::google::protobuf::uint8* GetBanResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetBanResponse)
+  // optional .bgs.protocol.club.v1.ClubBan ban = 1;
+  if (has_ban()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->ban(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetBanResponse)
+  return target;
+}
+
+int GetBanResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.ClubBan ban = 1;
+    if (has_ban()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->ban());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetBanResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetBanResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetBanResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetBanResponse::MergeFrom(const GetBanResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_ban()) {
+      mutable_ban()->::bgs::protocol::club::v1::ClubBan::MergeFrom(from.ban());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetBanResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetBanResponse::CopyFrom(const GetBanResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetBanResponse::IsInitialized() const {
+
+  if (has_ban()) {
+    if (!this->ban().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetBanResponse::Swap(GetBanResponse* other) {
+  if (other != this) {
+    std::swap(ban_, other->ban_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetBanResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetBanResponse_descriptor_;
+  metadata.reflection = GetBanResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetBansRequest::kAgentIdFieldNumber;
+const int GetBansRequest::kClubIdFieldNumber;
+const int GetBansRequest::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetBansRequest::GetBansRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetBansRequest)
+}
+
+void GetBansRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetBansRequest::GetBansRequest(const GetBansRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetBansRequest)
+}
+
+void GetBansRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetBansRequest::~GetBansRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetBansRequest)
+  SharedDtor();
+}
+
+void GetBansRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetBansRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetBansRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetBansRequest_descriptor_;
+}
+
+const GetBansRequest& GetBansRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetBansRequest* GetBansRequest::default_instance_ = NULL;
+
+GetBansRequest* GetBansRequest::New() const {
+  return new GetBansRequest;
+}
+
+void GetBansRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetBansRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, continuation_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetBansRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetBansRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetBansRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetBansRequest)
+  return false;
+#undef DO_
+}
+
+void GetBansRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetBansRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetBansRequest)
+}
+
+::google::protobuf::uint8* GetBansRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetBansRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetBansRequest)
+  return target;
+}
+
+int GetBansRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 continuation = 3;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetBansRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetBansRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetBansRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetBansRequest::MergeFrom(const GetBansRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetBansRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetBansRequest::CopyFrom(const GetBansRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetBansRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetBansRequest::Swap(GetBansRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetBansRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetBansRequest_descriptor_;
+  metadata.reflection = GetBansRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetBansResponse::kBanFieldNumber;
+const int GetBansResponse::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetBansResponse::GetBansResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetBansResponse)
+}
+
+void GetBansResponse::InitAsDefaultInstance() {
+}
+
+GetBansResponse::GetBansResponse(const GetBansResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetBansResponse)
+}
+
+void GetBansResponse::SharedCtor() {
+  _cached_size_ = 0;
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetBansResponse::~GetBansResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetBansResponse)
+  SharedDtor();
+}
+
+void GetBansResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetBansResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetBansResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetBansResponse_descriptor_;
+}
+
+const GetBansResponse& GetBansResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetBansResponse* GetBansResponse::default_instance_ = NULL;
+
+GetBansResponse* GetBansResponse::New() const {
+  return new GetBansResponse;
+}
+
+void GetBansResponse::Clear() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ban_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetBansResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetBansResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.ClubBan ban = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_ban:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_ban()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_ban;
+        if (input->ExpectTag(16)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetBansResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetBansResponse)
+  return false;
+#undef DO_
+}
+
+void GetBansResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetBansResponse)
+  // repeated .bgs.protocol.club.v1.ClubBan ban = 1;
+  for (int i = 0; i < this->ban_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->ban(i), output);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetBansResponse)
+}
+
+::google::protobuf::uint8* GetBansResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetBansResponse)
+  // repeated .bgs.protocol.club.v1.ClubBan ban = 1;
+  for (int i = 0; i < this->ban_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->ban(i), target);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetBansResponse)
+  return target;
+}
+
+int GetBansResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint64 continuation = 2;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.ClubBan ban = 1;
+  total_size += 1 * this->ban_size();
+  for (int i = 0; i < this->ban_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->ban(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetBansResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetBansResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetBansResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetBansResponse::MergeFrom(const GetBansResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  ban_.MergeFrom(from.ban_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetBansResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetBansResponse::CopyFrom(const GetBansResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetBansResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->ban())) return false;
+  return true;
+}
+
+void GetBansResponse::Swap(GetBansResponse* other) {
+  if (other != this) {
+    ban_.Swap(&other->ban_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetBansResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetBansResponse_descriptor_;
+  metadata.reflection = GetBansResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeStreamRequest::kAgentIdFieldNumber;
+const int SubscribeStreamRequest::kClubIdFieldNumber;
+const int SubscribeStreamRequest::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeStreamRequest::SubscribeStreamRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SubscribeStreamRequest)
+}
+
+void SubscribeStreamRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+SubscribeStreamRequest::SubscribeStreamRequest(const SubscribeStreamRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SubscribeStreamRequest)
+}
+
+void SubscribeStreamRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeStreamRequest::~SubscribeStreamRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SubscribeStreamRequest)
+  SharedDtor();
+}
+
+void SubscribeStreamRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SubscribeStreamRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeStreamRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeStreamRequest_descriptor_;
+}
+
+const SubscribeStreamRequest& SubscribeStreamRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+SubscribeStreamRequest* SubscribeStreamRequest::default_instance_ = NULL;
+
+SubscribeStreamRequest* SubscribeStreamRequest::New() const {
+  return new SubscribeStreamRequest;
+}
+
+void SubscribeStreamRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  stream_id_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeStreamRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SubscribeStreamRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // repeated uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 1, 24, input, this->mutable_stream_id())));
+        } else if (tag == 26) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, this->mutable_stream_id())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SubscribeStreamRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SubscribeStreamRequest)
+  return false;
+#undef DO_
+}
+
+void SubscribeStreamRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SubscribeStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // repeated uint64 stream_id = 3;
+  for (int i = 0; i < this->stream_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(
+      3, this->stream_id(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SubscribeStreamRequest)
+}
+
+::google::protobuf::uint8* SubscribeStreamRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SubscribeStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // repeated uint64 stream_id = 3;
+  for (int i = 0; i < this->stream_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt64ToArray(3, this->stream_id(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SubscribeStreamRequest)
+  return target;
+}
+
+int SubscribeStreamRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  // repeated uint64 stream_id = 3;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->stream_id_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt64Size(this->stream_id(i));
+    }
+    total_size += 1 * this->stream_id_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeStreamRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeStreamRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeStreamRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeStreamRequest::MergeFrom(const SubscribeStreamRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  stream_id_.MergeFrom(from.stream_id_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeStreamRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeStreamRequest::CopyFrom(const SubscribeStreamRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeStreamRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscribeStreamRequest::Swap(SubscribeStreamRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    stream_id_.Swap(&other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeStreamRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeStreamRequest_descriptor_;
+  metadata.reflection = SubscribeStreamRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsubscribeStreamRequest::kAgentIdFieldNumber;
+const int UnsubscribeStreamRequest::kClubIdFieldNumber;
+const int UnsubscribeStreamRequest::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+UnsubscribeStreamRequest::UnsubscribeStreamRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+}
+
+void UnsubscribeStreamRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+UnsubscribeStreamRequest::UnsubscribeStreamRequest(const UnsubscribeStreamRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+}
+
+void UnsubscribeStreamRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsubscribeStreamRequest::~UnsubscribeStreamRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+  SharedDtor();
+}
+
+void UnsubscribeStreamRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void UnsubscribeStreamRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsubscribeStreamRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsubscribeStreamRequest_descriptor_;
+}
+
+const UnsubscribeStreamRequest& UnsubscribeStreamRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+UnsubscribeStreamRequest* UnsubscribeStreamRequest::default_instance_ = NULL;
+
+UnsubscribeStreamRequest* UnsubscribeStreamRequest::New() const {
+  return new UnsubscribeStreamRequest;
+}
+
+void UnsubscribeStreamRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  stream_id_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsubscribeStreamRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // repeated uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 1, 24, input, this->mutable_stream_id())));
+        } else if (tag == 26) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, this->mutable_stream_id())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+  return false;
+#undef DO_
+}
+
+void UnsubscribeStreamRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // repeated uint64 stream_id = 3;
+  for (int i = 0; i < this->stream_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(
+      3, this->stream_id(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+}
+
+::google::protobuf::uint8* UnsubscribeStreamRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // repeated uint64 stream_id = 3;
+  for (int i = 0; i < this->stream_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt64ToArray(3, this->stream_id(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+  return target;
+}
+
+int UnsubscribeStreamRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  // repeated uint64 stream_id = 3;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->stream_id_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt64Size(this->stream_id(i));
+    }
+    total_size += 1 * this->stream_id_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsubscribeStreamRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsubscribeStreamRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsubscribeStreamRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsubscribeStreamRequest::MergeFrom(const UnsubscribeStreamRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  stream_id_.MergeFrom(from.stream_id_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsubscribeStreamRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsubscribeStreamRequest::CopyFrom(const UnsubscribeStreamRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsubscribeStreamRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnsubscribeStreamRequest::Swap(UnsubscribeStreamRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    stream_id_.Swap(&other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsubscribeStreamRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsubscribeStreamRequest_descriptor_;
+  metadata.reflection = UnsubscribeStreamRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateStreamRequest::kAgentIdFieldNumber;
+const int CreateStreamRequest::kClubIdFieldNumber;
+const int CreateStreamRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+CreateStreamRequest::CreateStreamRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateStreamRequest)
+}
+
+void CreateStreamRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::CreateStreamOptions*>(&::bgs::protocol::club::v1::CreateStreamOptions::default_instance());
+}
+
+CreateStreamRequest::CreateStreamRequest(const CreateStreamRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateStreamRequest)
+}
+
+void CreateStreamRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateStreamRequest::~CreateStreamRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateStreamRequest)
+  SharedDtor();
+}
+
+void CreateStreamRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void CreateStreamRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateStreamRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateStreamRequest_descriptor_;
+}
+
+const CreateStreamRequest& CreateStreamRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+CreateStreamRequest* CreateStreamRequest::default_instance_ = NULL;
+
+CreateStreamRequest* CreateStreamRequest::New() const {
+  return new CreateStreamRequest;
+}
+
+void CreateStreamRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateStreamOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateStreamRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateStreamRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.CreateStreamOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateStreamRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateStreamRequest)
+  return false;
+#undef DO_
+}
+
+void CreateStreamRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateStreamOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateStreamRequest)
+}
+
+::google::protobuf::uint8* CreateStreamRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateStreamOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateStreamRequest)
+  return target;
+}
+
+int CreateStreamRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.club.v1.CreateStreamOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateStreamRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateStreamRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateStreamRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateStreamRequest::MergeFrom(const CreateStreamRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::CreateStreamOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateStreamRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateStreamRequest::CopyFrom(const CreateStreamRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateStreamRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CreateStreamRequest::Swap(CreateStreamRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateStreamRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateStreamRequest_descriptor_;
+  metadata.reflection = CreateStreamRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DestroyStreamRequest::kAgentIdFieldNumber;
+const int DestroyStreamRequest::kClubIdFieldNumber;
+const int DestroyStreamRequest::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+DestroyStreamRequest::DestroyStreamRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.DestroyStreamRequest)
+}
+
+void DestroyStreamRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+DestroyStreamRequest::DestroyStreamRequest(const DestroyStreamRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.DestroyStreamRequest)
+}
+
+void DestroyStreamRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DestroyStreamRequest::~DestroyStreamRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.DestroyStreamRequest)
+  SharedDtor();
+}
+
+void DestroyStreamRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void DestroyStreamRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DestroyStreamRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DestroyStreamRequest_descriptor_;
+}
+
+const DestroyStreamRequest& DestroyStreamRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+DestroyStreamRequest* DestroyStreamRequest::default_instance_ = NULL;
+
+DestroyStreamRequest* DestroyStreamRequest::New() const {
+  return new DestroyStreamRequest;
+}
+
+void DestroyStreamRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<DestroyStreamRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DestroyStreamRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.DestroyStreamRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.DestroyStreamRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.DestroyStreamRequest)
+  return false;
+#undef DO_
+}
+
+void DestroyStreamRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.DestroyStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.DestroyStreamRequest)
+}
+
+::google::protobuf::uint8* DestroyStreamRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.DestroyStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.DestroyStreamRequest)
+  return target;
+}
+
+int DestroyStreamRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DestroyStreamRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DestroyStreamRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DestroyStreamRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DestroyStreamRequest::MergeFrom(const DestroyStreamRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DestroyStreamRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DestroyStreamRequest::CopyFrom(const DestroyStreamRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DestroyStreamRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DestroyStreamRequest::Swap(DestroyStreamRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DestroyStreamRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DestroyStreamRequest_descriptor_;
+  metadata.reflection = DestroyStreamRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamRequest::kAgentIdFieldNumber;
+const int GetStreamRequest::kClubIdFieldNumber;
+const int GetStreamRequest::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamRequest::GetStreamRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetStreamRequest)
+}
+
+void GetStreamRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetStreamRequest::GetStreamRequest(const GetStreamRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetStreamRequest)
+}
+
+void GetStreamRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamRequest::~GetStreamRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetStreamRequest)
+  SharedDtor();
+}
+
+void GetStreamRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetStreamRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamRequest_descriptor_;
+}
+
+const GetStreamRequest& GetStreamRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetStreamRequest* GetStreamRequest::default_instance_ = NULL;
+
+GetStreamRequest* GetStreamRequest::New() const {
+  return new GetStreamRequest;
+}
+
+void GetStreamRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetStreamRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetStreamRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetStreamRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetStreamRequest)
+  return false;
+#undef DO_
+}
+
+void GetStreamRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetStreamRequest)
+}
+
+::google::protobuf::uint8* GetStreamRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetStreamRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetStreamRequest)
+  return target;
+}
+
+int GetStreamRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamRequest::MergeFrom(const GetStreamRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamRequest::CopyFrom(const GetStreamRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetStreamRequest::Swap(GetStreamRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamRequest_descriptor_;
+  metadata.reflection = GetStreamRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamResponse::kStreamFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamResponse::GetStreamResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetStreamResponse)
+}
+
+void GetStreamResponse::InitAsDefaultInstance() {
+  stream_ = const_cast< ::bgs::protocol::club::v1::Stream*>(&::bgs::protocol::club::v1::Stream::default_instance());
+}
+
+GetStreamResponse::GetStreamResponse(const GetStreamResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetStreamResponse)
+}
+
+void GetStreamResponse::SharedCtor() {
+  _cached_size_ = 0;
+  stream_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamResponse::~GetStreamResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetStreamResponse)
+  SharedDtor();
+}
+
+void GetStreamResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete stream_;
+  }
+}
+
+void GetStreamResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamResponse_descriptor_;
+}
+
+const GetStreamResponse& GetStreamResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetStreamResponse* GetStreamResponse::default_instance_ = NULL;
+
+GetStreamResponse* GetStreamResponse::New() const {
+  return new GetStreamResponse;
+}
+
+void GetStreamResponse::Clear() {
+  if (has_stream()) {
+    if (stream_ != NULL) stream_->::bgs::protocol::club::v1::Stream::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetStreamResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.Stream stream = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_stream()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetStreamResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetStreamResponse)
+  return false;
+#undef DO_
+}
+
+void GetStreamResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetStreamResponse)
+  // optional .bgs.protocol.club.v1.Stream stream = 1;
+  if (has_stream()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->stream(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetStreamResponse)
+}
+
+::google::protobuf::uint8* GetStreamResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetStreamResponse)
+  // optional .bgs.protocol.club.v1.Stream stream = 1;
+  if (has_stream()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->stream(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetStreamResponse)
+  return target;
+}
+
+int GetStreamResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.Stream stream = 1;
+    if (has_stream()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->stream());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamResponse::MergeFrom(const GetStreamResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_stream()) {
+      mutable_stream()->::bgs::protocol::club::v1::Stream::MergeFrom(from.stream());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamResponse::CopyFrom(const GetStreamResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetStreamResponse::Swap(GetStreamResponse* other) {
+  if (other != this) {
+    std::swap(stream_, other->stream_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamResponse_descriptor_;
+  metadata.reflection = GetStreamResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamsRequest::kAgentIdFieldNumber;
+const int GetStreamsRequest::kClubIdFieldNumber;
+const int GetStreamsRequest::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamsRequest::GetStreamsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetStreamsRequest)
+}
+
+void GetStreamsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetStreamsRequest::GetStreamsRequest(const GetStreamsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetStreamsRequest)
+}
+
+void GetStreamsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamsRequest::~GetStreamsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetStreamsRequest)
+  SharedDtor();
+}
+
+void GetStreamsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetStreamsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamsRequest_descriptor_;
+}
+
+const GetStreamsRequest& GetStreamsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetStreamsRequest* GetStreamsRequest::default_instance_ = NULL;
+
+GetStreamsRequest* GetStreamsRequest::New() const {
+  return new GetStreamsRequest;
+}
+
+void GetStreamsRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetStreamsRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, continuation_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetStreamsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetStreamsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetStreamsRequest)
+  return false;
+#undef DO_
+}
+
+void GetStreamsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetStreamsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetStreamsRequest)
+}
+
+::google::protobuf::uint8* GetStreamsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetStreamsRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetStreamsRequest)
+  return target;
+}
+
+int GetStreamsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 continuation = 3;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamsRequest::MergeFrom(const GetStreamsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamsRequest::CopyFrom(const GetStreamsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamsRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetStreamsRequest::Swap(GetStreamsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamsRequest_descriptor_;
+  metadata.reflection = GetStreamsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamsResponse::kStreamFieldNumber;
+const int GetStreamsResponse::kViewFieldNumber;
+const int GetStreamsResponse::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamsResponse::GetStreamsResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetStreamsResponse)
+}
+
+void GetStreamsResponse::InitAsDefaultInstance() {
+}
+
+GetStreamsResponse::GetStreamsResponse(const GetStreamsResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetStreamsResponse)
+}
+
+void GetStreamsResponse::SharedCtor() {
+  _cached_size_ = 0;
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamsResponse::~GetStreamsResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetStreamsResponse)
+  SharedDtor();
+}
+
+void GetStreamsResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetStreamsResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamsResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamsResponse_descriptor_;
+}
+
+const GetStreamsResponse& GetStreamsResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetStreamsResponse* GetStreamsResponse::default_instance_ = NULL;
+
+GetStreamsResponse* GetStreamsResponse::New() const {
+  return new GetStreamsResponse;
+}
+
+void GetStreamsResponse::Clear() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  stream_.Clear();
+  view_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamsResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetStreamsResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.Stream stream = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_stream:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_stream()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_stream;
+        if (input->ExpectTag(18)) goto parse_view;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.StreamView view = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_view:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_view()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_view;
+        if (input->ExpectTag(24)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetStreamsResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetStreamsResponse)
+  return false;
+#undef DO_
+}
+
+void GetStreamsResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetStreamsResponse)
+  // repeated .bgs.protocol.club.v1.Stream stream = 1;
+  for (int i = 0; i < this->stream_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->stream(i), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.StreamView view = 2;
+  for (int i = 0; i < this->view_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->view(i), output);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetStreamsResponse)
+}
+
+::google::protobuf::uint8* GetStreamsResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetStreamsResponse)
+  // repeated .bgs.protocol.club.v1.Stream stream = 1;
+  for (int i = 0; i < this->stream_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->stream(i), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.StreamView view = 2;
+  for (int i = 0; i < this->view_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->view(i), target);
+  }
+
+  // optional uint64 continuation = 3;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetStreamsResponse)
+  return target;
+}
+
+int GetStreamsResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[2 / 32] & (0xffu << (2 % 32))) {
+    // optional uint64 continuation = 3;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.Stream stream = 1;
+  total_size += 1 * this->stream_size();
+  for (int i = 0; i < this->stream_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->stream(i));
+  }
+
+  // repeated .bgs.protocol.club.v1.StreamView view = 2;
+  total_size += 1 * this->view_size();
+  for (int i = 0; i < this->view_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->view(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamsResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamsResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamsResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamsResponse::MergeFrom(const GetStreamsResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  stream_.MergeFrom(from.stream_);
+  view_.MergeFrom(from.view_);
+  if (from._has_bits_[2 / 32] & (0xffu << (2 % 32))) {
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamsResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamsResponse::CopyFrom(const GetStreamsResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamsResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetStreamsResponse::Swap(GetStreamsResponse* other) {
+  if (other != this) {
+    stream_.Swap(&other->stream_);
+    view_.Swap(&other->view_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamsResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamsResponse_descriptor_;
+  metadata.reflection = GetStreamsResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateStreamStateRequest::kAgentIdFieldNumber;
+const int UpdateStreamStateRequest::kClubIdFieldNumber;
+const int UpdateStreamStateRequest::kStreamIdFieldNumber;
+const int UpdateStreamStateRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateStreamStateRequest::UpdateStreamStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.UpdateStreamStateRequest)
+}
+
+void UpdateStreamStateRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::StreamStateOptions*>(&::bgs::protocol::club::v1::StreamStateOptions::default_instance());
+}
+
+UpdateStreamStateRequest::UpdateStreamStateRequest(const UpdateStreamStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.UpdateStreamStateRequest)
+}
+
+void UpdateStreamStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateStreamStateRequest::~UpdateStreamStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.UpdateStreamStateRequest)
+  SharedDtor();
+}
+
+void UpdateStreamStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void UpdateStreamStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateStreamStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateStreamStateRequest_descriptor_;
+}
+
+const UpdateStreamStateRequest& UpdateStreamStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+UpdateStreamStateRequest* UpdateStreamStateRequest::default_instance_ = NULL;
+
+UpdateStreamStateRequest* UpdateStreamStateRequest::New() const {
+  return new UpdateStreamStateRequest;
+}
+
+void UpdateStreamStateRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<UpdateStreamStateRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::StreamStateOptions::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateStreamStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.UpdateStreamStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamStateOptions options = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.UpdateStreamStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.UpdateStreamStateRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateStreamStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.UpdateStreamStateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamStateOptions options = 5;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.UpdateStreamStateRequest)
+}
+
+::google::protobuf::uint8* UpdateStreamStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.UpdateStreamStateRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamStateOptions options = 5;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.UpdateStreamStateRequest)
+  return target;
+}
+
+int UpdateStreamStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamStateOptions options = 5;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateStreamStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateStreamStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateStreamStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateStreamStateRequest::MergeFrom(const UpdateStreamStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::StreamStateOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateStreamStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateStreamStateRequest::CopyFrom(const UpdateStreamStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateStreamStateRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateStreamStateRequest::Swap(UpdateStreamStateRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateStreamStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateStreamStateRequest_descriptor_;
+  metadata.reflection = UpdateStreamStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SetStreamFocusRequest::kAgentIdFieldNumber;
+const int SetStreamFocusRequest::kClubIdFieldNumber;
+const int SetStreamFocusRequest::kStreamIdFieldNumber;
+const int SetStreamFocusRequest::kFocusFieldNumber;
+#endif  // !_MSC_VER
+
+SetStreamFocusRequest::SetStreamFocusRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SetStreamFocusRequest)
+}
+
+void SetStreamFocusRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+SetStreamFocusRequest::SetStreamFocusRequest(const SetStreamFocusRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SetStreamFocusRequest)
+}
+
+void SetStreamFocusRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  focus_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SetStreamFocusRequest::~SetStreamFocusRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SetStreamFocusRequest)
+  SharedDtor();
+}
+
+void SetStreamFocusRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SetStreamFocusRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SetStreamFocusRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SetStreamFocusRequest_descriptor_;
+}
+
+const SetStreamFocusRequest& SetStreamFocusRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+SetStreamFocusRequest* SetStreamFocusRequest::default_instance_ = NULL;
+
+SetStreamFocusRequest* SetStreamFocusRequest::New() const {
+  return new SetStreamFocusRequest;
+}
+
+void SetStreamFocusRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<SetStreamFocusRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(club_id_, focus_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SetStreamFocusRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SetStreamFocusRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_focus;
+        break;
+      }
+
+      // optional bool focus = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_focus:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &focus_)));
+          set_has_focus();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SetStreamFocusRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SetStreamFocusRequest)
+  return false;
+#undef DO_
+}
+
+void SetStreamFocusRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SetStreamFocusRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  // optional bool focus = 4;
+  if (has_focus()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->focus(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SetStreamFocusRequest)
+}
+
+::google::protobuf::uint8* SetStreamFocusRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SetStreamFocusRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  // optional bool focus = 4;
+  if (has_focus()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->focus(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SetStreamFocusRequest)
+  return target;
+}
+
+int SetStreamFocusRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional bool focus = 4;
+    if (has_focus()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SetStreamFocusRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SetStreamFocusRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SetStreamFocusRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SetStreamFocusRequest::MergeFrom(const SetStreamFocusRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_focus()) {
+      set_focus(from.focus());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SetStreamFocusRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SetStreamFocusRequest::CopyFrom(const SetStreamFocusRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SetStreamFocusRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SetStreamFocusRequest::Swap(SetStreamFocusRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(focus_, other->focus_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SetStreamFocusRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SetStreamFocusRequest_descriptor_;
+  metadata.reflection = SetStreamFocusRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateMessageRequest::kAgentIdFieldNumber;
+const int CreateMessageRequest::kClubIdFieldNumber;
+const int CreateMessageRequest::kStreamIdFieldNumber;
+const int CreateMessageRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+CreateMessageRequest::CreateMessageRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateMessageRequest)
+}
+
+void CreateMessageRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::CreateMessageOptions*>(&::bgs::protocol::club::v1::CreateMessageOptions::default_instance());
+}
+
+CreateMessageRequest::CreateMessageRequest(const CreateMessageRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateMessageRequest)
+}
+
+void CreateMessageRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateMessageRequest::~CreateMessageRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateMessageRequest)
+  SharedDtor();
+}
+
+void CreateMessageRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void CreateMessageRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateMessageRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateMessageRequest_descriptor_;
+}
+
+const CreateMessageRequest& CreateMessageRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+CreateMessageRequest* CreateMessageRequest::default_instance_ = NULL;
+
+CreateMessageRequest* CreateMessageRequest::New() const {
+  return new CreateMessageRequest;
+}
+
+void CreateMessageRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<CreateMessageRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateMessageOptions::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateMessageRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateMessageRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.CreateMessageOptions options = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateMessageRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateMessageRequest)
+  return false;
+#undef DO_
+}
+
+void CreateMessageRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateMessageRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateMessageOptions options = 4;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateMessageRequest)
+}
+
+::google::protobuf::uint8* CreateMessageRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateMessageRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateMessageOptions options = 4;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateMessageRequest)
+  return target;
+}
+
+int CreateMessageRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.club.v1.CreateMessageOptions options = 4;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateMessageRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateMessageRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateMessageRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateMessageRequest::MergeFrom(const CreateMessageRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::CreateMessageOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateMessageRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateMessageRequest::CopyFrom(const CreateMessageRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateMessageRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_options()) {
+    if (!this->options().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CreateMessageRequest::Swap(CreateMessageRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateMessageRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateMessageRequest_descriptor_;
+  metadata.reflection = CreateMessageRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateMessageResponse::kMessageFieldNumber;
+#endif  // !_MSC_VER
+
+CreateMessageResponse::CreateMessageResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateMessageResponse)
+}
+
+void CreateMessageResponse::InitAsDefaultInstance() {
+  message_ = const_cast< ::bgs::protocol::club::v1::StreamMessage*>(&::bgs::protocol::club::v1::StreamMessage::default_instance());
+}
+
+CreateMessageResponse::CreateMessageResponse(const CreateMessageResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateMessageResponse)
+}
+
+void CreateMessageResponse::SharedCtor() {
+  _cached_size_ = 0;
+  message_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateMessageResponse::~CreateMessageResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateMessageResponse)
+  SharedDtor();
+}
+
+void CreateMessageResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete message_;
+  }
+}
+
+void CreateMessageResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateMessageResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateMessageResponse_descriptor_;
+}
+
+const CreateMessageResponse& CreateMessageResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+CreateMessageResponse* CreateMessageResponse::default_instance_ = NULL;
+
+CreateMessageResponse* CreateMessageResponse::New() const {
+  return new CreateMessageResponse;
+}
+
+void CreateMessageResponse::Clear() {
+  if (has_message()) {
+    if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateMessageResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateMessageResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateMessageResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateMessageResponse)
+  return false;
+#undef DO_
+}
+
+void CreateMessageResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateMessageResponse)
+  // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->message(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateMessageResponse)
+}
+
+::google::protobuf::uint8* CreateMessageResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateMessageResponse)
+  // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+  if (has_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->message(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateMessageResponse)
+  return target;
+}
+
+int CreateMessageResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+    if (has_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateMessageResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateMessageResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateMessageResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateMessageResponse::MergeFrom(const CreateMessageResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_message()) {
+      mutable_message()->::bgs::protocol::club::v1::StreamMessage::MergeFrom(from.message());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateMessageResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateMessageResponse::CopyFrom(const CreateMessageResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateMessageResponse::IsInitialized() const {
+
+  if (has_message()) {
+    if (!this->message().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CreateMessageResponse::Swap(CreateMessageResponse* other) {
+  if (other != this) {
+    std::swap(message_, other->message_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateMessageResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateMessageResponse_descriptor_;
+  metadata.reflection = CreateMessageResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DestroyMessageRequest::kAgentIdFieldNumber;
+const int DestroyMessageRequest::kClubIdFieldNumber;
+const int DestroyMessageRequest::kStreamIdFieldNumber;
+const int DestroyMessageRequest::kMessageIdFieldNumber;
+#endif  // !_MSC_VER
+
+DestroyMessageRequest::DestroyMessageRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.DestroyMessageRequest)
+}
+
+void DestroyMessageRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  message_id_ = const_cast< ::bgs::protocol::MessageId*>(&::bgs::protocol::MessageId::default_instance());
+}
+
+DestroyMessageRequest::DestroyMessageRequest(const DestroyMessageRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.DestroyMessageRequest)
+}
+
+void DestroyMessageRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  message_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DestroyMessageRequest::~DestroyMessageRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.DestroyMessageRequest)
+  SharedDtor();
+}
+
+void DestroyMessageRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete message_id_;
+  }
+}
+
+void DestroyMessageRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DestroyMessageRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DestroyMessageRequest_descriptor_;
+}
+
+const DestroyMessageRequest& DestroyMessageRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+DestroyMessageRequest* DestroyMessageRequest::default_instance_ = NULL;
+
+DestroyMessageRequest* DestroyMessageRequest::New() const {
+  return new DestroyMessageRequest;
+}
+
+void DestroyMessageRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<DestroyMessageRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_message_id()) {
+      if (message_id_ != NULL) message_id_->::bgs::protocol::MessageId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DestroyMessageRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.DestroyMessageRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_message_id;
+        break;
+      }
+
+      // optional .bgs.protocol.MessageId message_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_message_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.DestroyMessageRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.DestroyMessageRequest)
+  return false;
+#undef DO_
+}
+
+void DestroyMessageRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.DestroyMessageRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.MessageId message_id = 4;
+  if (has_message_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->message_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.DestroyMessageRequest)
+}
+
+::google::protobuf::uint8* DestroyMessageRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.DestroyMessageRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.MessageId message_id = 4;
+  if (has_message_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->message_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.DestroyMessageRequest)
+  return target;
+}
+
+int DestroyMessageRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.MessageId message_id = 4;
+    if (has_message_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DestroyMessageRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DestroyMessageRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DestroyMessageRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DestroyMessageRequest::MergeFrom(const DestroyMessageRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_message_id()) {
+      mutable_message_id()->::bgs::protocol::MessageId::MergeFrom(from.message_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DestroyMessageRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DestroyMessageRequest::CopyFrom(const DestroyMessageRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DestroyMessageRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DestroyMessageRequest::Swap(DestroyMessageRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(message_id_, other->message_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DestroyMessageRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DestroyMessageRequest_descriptor_;
+  metadata.reflection = DestroyMessageRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DestroyMessageResponse::kMessageFieldNumber;
+#endif  // !_MSC_VER
+
+DestroyMessageResponse::DestroyMessageResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.DestroyMessageResponse)
+}
+
+void DestroyMessageResponse::InitAsDefaultInstance() {
+  message_ = const_cast< ::bgs::protocol::club::v1::StreamMessage*>(&::bgs::protocol::club::v1::StreamMessage::default_instance());
+}
+
+DestroyMessageResponse::DestroyMessageResponse(const DestroyMessageResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.DestroyMessageResponse)
+}
+
+void DestroyMessageResponse::SharedCtor() {
+  _cached_size_ = 0;
+  message_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DestroyMessageResponse::~DestroyMessageResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.DestroyMessageResponse)
+  SharedDtor();
+}
+
+void DestroyMessageResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete message_;
+  }
+}
+
+void DestroyMessageResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DestroyMessageResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DestroyMessageResponse_descriptor_;
+}
+
+const DestroyMessageResponse& DestroyMessageResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+DestroyMessageResponse* DestroyMessageResponse::default_instance_ = NULL;
+
+DestroyMessageResponse* DestroyMessageResponse::New() const {
+  return new DestroyMessageResponse;
+}
+
+void DestroyMessageResponse::Clear() {
+  if (has_message()) {
+    if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DestroyMessageResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.DestroyMessageResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.DestroyMessageResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.DestroyMessageResponse)
+  return false;
+#undef DO_
+}
+
+void DestroyMessageResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.DestroyMessageResponse)
+  // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->message(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.DestroyMessageResponse)
+}
+
+::google::protobuf::uint8* DestroyMessageResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.DestroyMessageResponse)
+  // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+  if (has_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->message(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.DestroyMessageResponse)
+  return target;
+}
+
+int DestroyMessageResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+    if (has_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DestroyMessageResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DestroyMessageResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DestroyMessageResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DestroyMessageResponse::MergeFrom(const DestroyMessageResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_message()) {
+      mutable_message()->::bgs::protocol::club::v1::StreamMessage::MergeFrom(from.message());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DestroyMessageResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DestroyMessageResponse::CopyFrom(const DestroyMessageResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DestroyMessageResponse::IsInitialized() const {
+
+  if (has_message()) {
+    if (!this->message().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DestroyMessageResponse::Swap(DestroyMessageResponse* other) {
+  if (other != this) {
+    std::swap(message_, other->message_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DestroyMessageResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DestroyMessageResponse_descriptor_;
+  metadata.reflection = DestroyMessageResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int EditMessageRequest::kAgentIdFieldNumber;
+const int EditMessageRequest::kClubIdFieldNumber;
+const int EditMessageRequest::kStreamIdFieldNumber;
+const int EditMessageRequest::kMessageIdFieldNumber;
+const int EditMessageRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+EditMessageRequest::EditMessageRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.EditMessageRequest)
+}
+
+void EditMessageRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  message_id_ = const_cast< ::bgs::protocol::MessageId*>(&::bgs::protocol::MessageId::default_instance());
+  options_ = const_cast< ::bgs::protocol::club::v1::CreateMessageOptions*>(&::bgs::protocol::club::v1::CreateMessageOptions::default_instance());
+}
+
+EditMessageRequest::EditMessageRequest(const EditMessageRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.EditMessageRequest)
+}
+
+void EditMessageRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  message_id_ = NULL;
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+EditMessageRequest::~EditMessageRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.EditMessageRequest)
+  SharedDtor();
+}
+
+void EditMessageRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete message_id_;
+    delete options_;
+  }
+}
+
+void EditMessageRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* EditMessageRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EditMessageRequest_descriptor_;
+}
+
+const EditMessageRequest& EditMessageRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+EditMessageRequest* EditMessageRequest::default_instance_ = NULL;
+
+EditMessageRequest* EditMessageRequest::New() const {
+  return new EditMessageRequest;
+}
+
+void EditMessageRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<EditMessageRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_message_id()) {
+      if (message_id_ != NULL) message_id_->::bgs::protocol::MessageId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateMessageOptions::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool EditMessageRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.EditMessageRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_message_id;
+        break;
+      }
+
+      // optional .bgs.protocol.MessageId message_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_message_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.CreateMessageOptions options = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.EditMessageRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.EditMessageRequest)
+  return false;
+#undef DO_
+}
+
+void EditMessageRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.EditMessageRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.MessageId message_id = 4;
+  if (has_message_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->message_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateMessageOptions options = 5;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.EditMessageRequest)
+}
+
+::google::protobuf::uint8* EditMessageRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.EditMessageRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.MessageId message_id = 4;
+  if (has_message_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->message_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.CreateMessageOptions options = 5;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.EditMessageRequest)
+  return target;
+}
+
+int EditMessageRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.MessageId message_id = 4;
+    if (has_message_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message_id());
+    }
+
+    // optional .bgs.protocol.club.v1.CreateMessageOptions options = 5;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void EditMessageRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const EditMessageRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const EditMessageRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void EditMessageRequest::MergeFrom(const EditMessageRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_message_id()) {
+      mutable_message_id()->::bgs::protocol::MessageId::MergeFrom(from.message_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::club::v1::CreateMessageOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void EditMessageRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void EditMessageRequest::CopyFrom(const EditMessageRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EditMessageRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_options()) {
+    if (!this->options().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void EditMessageRequest::Swap(EditMessageRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(message_id_, other->message_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata EditMessageRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = EditMessageRequest_descriptor_;
+  metadata.reflection = EditMessageRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int EditMessageResponse::kMessageFieldNumber;
+#endif  // !_MSC_VER
+
+EditMessageResponse::EditMessageResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.EditMessageResponse)
+}
+
+void EditMessageResponse::InitAsDefaultInstance() {
+  message_ = const_cast< ::bgs::protocol::club::v1::StreamMessage*>(&::bgs::protocol::club::v1::StreamMessage::default_instance());
+}
+
+EditMessageResponse::EditMessageResponse(const EditMessageResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.EditMessageResponse)
+}
+
+void EditMessageResponse::SharedCtor() {
+  _cached_size_ = 0;
+  message_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+EditMessageResponse::~EditMessageResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.EditMessageResponse)
+  SharedDtor();
+}
+
+void EditMessageResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete message_;
+  }
+}
+
+void EditMessageResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* EditMessageResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EditMessageResponse_descriptor_;
+}
+
+const EditMessageResponse& EditMessageResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+EditMessageResponse* EditMessageResponse::default_instance_ = NULL;
+
+EditMessageResponse* EditMessageResponse::New() const {
+  return new EditMessageResponse;
+}
+
+void EditMessageResponse::Clear() {
+  if (has_message()) {
+    if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool EditMessageResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.EditMessageResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.EditMessageResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.EditMessageResponse)
+  return false;
+#undef DO_
+}
+
+void EditMessageResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.EditMessageResponse)
+  // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->message(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.EditMessageResponse)
+}
+
+::google::protobuf::uint8* EditMessageResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.EditMessageResponse)
+  // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+  if (has_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->message(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.EditMessageResponse)
+  return target;
+}
+
+int EditMessageResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+    if (has_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void EditMessageResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const EditMessageResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const EditMessageResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void EditMessageResponse::MergeFrom(const EditMessageResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_message()) {
+      mutable_message()->::bgs::protocol::club::v1::StreamMessage::MergeFrom(from.message());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void EditMessageResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void EditMessageResponse::CopyFrom(const EditMessageResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EditMessageResponse::IsInitialized() const {
+
+  if (has_message()) {
+    if (!this->message().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void EditMessageResponse::Swap(EditMessageResponse* other) {
+  if (other != this) {
+    std::swap(message_, other->message_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata EditMessageResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = EditMessageResponse_descriptor_;
+  metadata.reflection = EditMessageResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SetMessagePinnedRequest::kAgentIdFieldNumber;
+const int SetMessagePinnedRequest::kClubIdFieldNumber;
+const int SetMessagePinnedRequest::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+SetMessagePinnedRequest::SetMessagePinnedRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SetMessagePinnedRequest)
+}
+
+void SetMessagePinnedRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+SetMessagePinnedRequest::SetMessagePinnedRequest(const SetMessagePinnedRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SetMessagePinnedRequest)
+}
+
+void SetMessagePinnedRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SetMessagePinnedRequest::~SetMessagePinnedRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SetMessagePinnedRequest)
+  SharedDtor();
+}
+
+void SetMessagePinnedRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SetMessagePinnedRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SetMessagePinnedRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SetMessagePinnedRequest_descriptor_;
+}
+
+const SetMessagePinnedRequest& SetMessagePinnedRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+SetMessagePinnedRequest* SetMessagePinnedRequest::default_instance_ = NULL;
+
+SetMessagePinnedRequest* SetMessagePinnedRequest::New() const {
+  return new SetMessagePinnedRequest;
+}
+
+void SetMessagePinnedRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<SetMessagePinnedRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SetMessagePinnedRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SetMessagePinnedRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SetMessagePinnedRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SetMessagePinnedRequest)
+  return false;
+#undef DO_
+}
+
+void SetMessagePinnedRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SetMessagePinnedRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SetMessagePinnedRequest)
+}
+
+::google::protobuf::uint8* SetMessagePinnedRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SetMessagePinnedRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SetMessagePinnedRequest)
+  return target;
+}
+
+int SetMessagePinnedRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SetMessagePinnedRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SetMessagePinnedRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SetMessagePinnedRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SetMessagePinnedRequest::MergeFrom(const SetMessagePinnedRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SetMessagePinnedRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SetMessagePinnedRequest::CopyFrom(const SetMessagePinnedRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SetMessagePinnedRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SetMessagePinnedRequest::Swap(SetMessagePinnedRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SetMessagePinnedRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SetMessagePinnedRequest_descriptor_;
+  metadata.reflection = SetMessagePinnedRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SetTypingIndicatorRequest::kAgentIdFieldNumber;
+const int SetTypingIndicatorRequest::kClubIdFieldNumber;
+const int SetTypingIndicatorRequest::kStreamIdFieldNumber;
+const int SetTypingIndicatorRequest::kIndicatorFieldNumber;
+#endif  // !_MSC_VER
+
+SetTypingIndicatorRequest::SetTypingIndicatorRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+}
+
+void SetTypingIndicatorRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+SetTypingIndicatorRequest::SetTypingIndicatorRequest(const SetTypingIndicatorRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+}
+
+void SetTypingIndicatorRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  indicator_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SetTypingIndicatorRequest::~SetTypingIndicatorRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+  SharedDtor();
+}
+
+void SetTypingIndicatorRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SetTypingIndicatorRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SetTypingIndicatorRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SetTypingIndicatorRequest_descriptor_;
+}
+
+const SetTypingIndicatorRequest& SetTypingIndicatorRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+SetTypingIndicatorRequest* SetTypingIndicatorRequest::default_instance_ = NULL;
+
+SetTypingIndicatorRequest* SetTypingIndicatorRequest::New() const {
+  return new SetTypingIndicatorRequest;
+}
+
+void SetTypingIndicatorRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<SetTypingIndicatorRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(club_id_, indicator_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SetTypingIndicatorRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_indicator;
+        break;
+      }
+
+      // optional .bgs.protocol.TypingIndicator indicator = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_indicator:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::TypingIndicator_IsValid(value)) {
+            set_indicator(static_cast< ::bgs::protocol::TypingIndicator >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(4, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+  return false;
+#undef DO_
+}
+
+void SetTypingIndicatorRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.TypingIndicator indicator = 4;
+  if (has_indicator()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->indicator(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+}
+
+::google::protobuf::uint8* SetTypingIndicatorRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.TypingIndicator indicator = 4;
+  if (has_indicator()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      4, this->indicator(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+  return target;
+}
+
+int SetTypingIndicatorRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.TypingIndicator indicator = 4;
+    if (has_indicator()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->indicator());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SetTypingIndicatorRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SetTypingIndicatorRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SetTypingIndicatorRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SetTypingIndicatorRequest::MergeFrom(const SetTypingIndicatorRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_indicator()) {
+      set_indicator(from.indicator());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SetTypingIndicatorRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SetTypingIndicatorRequest::CopyFrom(const SetTypingIndicatorRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SetTypingIndicatorRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SetTypingIndicatorRequest::Swap(SetTypingIndicatorRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(indicator_, other->indicator_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SetTypingIndicatorRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SetTypingIndicatorRequest_descriptor_;
+  metadata.reflection = SetTypingIndicatorRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AdvanceStreamViewTimeRequest::kAgentIdFieldNumber;
+const int AdvanceStreamViewTimeRequest::kClubIdFieldNumber;
+const int AdvanceStreamViewTimeRequest::kStreamIdDeprecatedFieldNumber;
+const int AdvanceStreamViewTimeRequest::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+AdvanceStreamViewTimeRequest::AdvanceStreamViewTimeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+}
+
+void AdvanceStreamViewTimeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+AdvanceStreamViewTimeRequest::AdvanceStreamViewTimeRequest(const AdvanceStreamViewTimeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+}
+
+void AdvanceStreamViewTimeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_deprecated_ = GOOGLE_ULONGLONG(0);
+  _stream_id_cached_byte_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AdvanceStreamViewTimeRequest::~AdvanceStreamViewTimeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+  SharedDtor();
+}
+
+void AdvanceStreamViewTimeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void AdvanceStreamViewTimeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AdvanceStreamViewTimeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AdvanceStreamViewTimeRequest_descriptor_;
+}
+
+const AdvanceStreamViewTimeRequest& AdvanceStreamViewTimeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+AdvanceStreamViewTimeRequest* AdvanceStreamViewTimeRequest::default_instance_ = NULL;
+
+AdvanceStreamViewTimeRequest* AdvanceStreamViewTimeRequest::New() const {
+  return new AdvanceStreamViewTimeRequest;
+}
+
+void AdvanceStreamViewTimeRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AdvanceStreamViewTimeRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, stream_id_deprecated_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  stream_id_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AdvanceStreamViewTimeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id_deprecated;
+        break;
+      }
+
+      // optional uint64 stream_id_deprecated = 3 [deprecated = true];
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id_deprecated:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_deprecated_)));
+          set_has_stream_id_deprecated();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_stream_id;
+        break;
+      }
+
+      // repeated uint64 stream_id = 4 [packed = true];
+      case 4: {
+        if (tag == 34) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, this->mutable_stream_id())));
+        } else if (tag == 32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 1, 34, input, this->mutable_stream_id())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+  return false;
+#undef DO_
+}
+
+void AdvanceStreamViewTimeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id_deprecated = 3 [deprecated = true];
+  if (has_stream_id_deprecated()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id_deprecated(), output);
+  }
+
+  // repeated uint64 stream_id = 4 [packed = true];
+  if (this->stream_id_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_stream_id_cached_byte_size_);
+  }
+  for (int i = 0; i < this->stream_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64NoTag(
+      this->stream_id(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+}
+
+::google::protobuf::uint8* AdvanceStreamViewTimeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id_deprecated = 3 [deprecated = true];
+  if (has_stream_id_deprecated()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id_deprecated(), target);
+  }
+
+  // repeated uint64 stream_id = 4 [packed = true];
+  if (this->stream_id_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      4,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _stream_id_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->stream_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt64NoTagToArray(this->stream_id(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+  return target;
+}
+
+int AdvanceStreamViewTimeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id_deprecated = 3 [deprecated = true];
+    if (has_stream_id_deprecated()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id_deprecated());
+    }
+
+  }
+  // repeated uint64 stream_id = 4 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->stream_id_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt64Size(this->stream_id(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _stream_id_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AdvanceStreamViewTimeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AdvanceStreamViewTimeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AdvanceStreamViewTimeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AdvanceStreamViewTimeRequest::MergeFrom(const AdvanceStreamViewTimeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  stream_id_.MergeFrom(from.stream_id_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id_deprecated()) {
+      set_stream_id_deprecated(from.stream_id_deprecated());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AdvanceStreamViewTimeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AdvanceStreamViewTimeRequest::CopyFrom(const AdvanceStreamViewTimeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AdvanceStreamViewTimeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AdvanceStreamViewTimeRequest::Swap(AdvanceStreamViewTimeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_deprecated_, other->stream_id_deprecated_);
+    stream_id_.Swap(&other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AdvanceStreamViewTimeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AdvanceStreamViewTimeRequest_descriptor_;
+  metadata.reflection = AdvanceStreamViewTimeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AdvanceStreamMentionViewTimeRequest::kAgentIdFieldNumber;
+const int AdvanceStreamMentionViewTimeRequest::kClubIdFieldNumber;
+const int AdvanceStreamMentionViewTimeRequest::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+AdvanceStreamMentionViewTimeRequest::AdvanceStreamMentionViewTimeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+}
+
+void AdvanceStreamMentionViewTimeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+AdvanceStreamMentionViewTimeRequest::AdvanceStreamMentionViewTimeRequest(const AdvanceStreamMentionViewTimeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+}
+
+void AdvanceStreamMentionViewTimeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AdvanceStreamMentionViewTimeRequest::~AdvanceStreamMentionViewTimeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+  SharedDtor();
+}
+
+void AdvanceStreamMentionViewTimeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void AdvanceStreamMentionViewTimeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AdvanceStreamMentionViewTimeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AdvanceStreamMentionViewTimeRequest_descriptor_;
+}
+
+const AdvanceStreamMentionViewTimeRequest& AdvanceStreamMentionViewTimeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+AdvanceStreamMentionViewTimeRequest* AdvanceStreamMentionViewTimeRequest::default_instance_ = NULL;
+
+AdvanceStreamMentionViewTimeRequest* AdvanceStreamMentionViewTimeRequest::New() const {
+  return new AdvanceStreamMentionViewTimeRequest;
+}
+
+void AdvanceStreamMentionViewTimeRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AdvanceStreamMentionViewTimeRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AdvanceStreamMentionViewTimeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+  return false;
+#undef DO_
+}
+
+void AdvanceStreamMentionViewTimeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+}
+
+::google::protobuf::uint8* AdvanceStreamMentionViewTimeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+  return target;
+}
+
+int AdvanceStreamMentionViewTimeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AdvanceStreamMentionViewTimeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AdvanceStreamMentionViewTimeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AdvanceStreamMentionViewTimeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AdvanceStreamMentionViewTimeRequest::MergeFrom(const AdvanceStreamMentionViewTimeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AdvanceStreamMentionViewTimeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AdvanceStreamMentionViewTimeRequest::CopyFrom(const AdvanceStreamMentionViewTimeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AdvanceStreamMentionViewTimeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AdvanceStreamMentionViewTimeRequest::Swap(AdvanceStreamMentionViewTimeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AdvanceStreamMentionViewTimeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AdvanceStreamMentionViewTimeRequest_descriptor_;
+  metadata.reflection = AdvanceStreamMentionViewTimeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AdvanceActivityViewTimeRequest::kAgentIdFieldNumber;
+const int AdvanceActivityViewTimeRequest::kClubIdFieldNumber;
+#endif  // !_MSC_VER
+
+AdvanceActivityViewTimeRequest::AdvanceActivityViewTimeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+}
+
+void AdvanceActivityViewTimeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+AdvanceActivityViewTimeRequest::AdvanceActivityViewTimeRequest(const AdvanceActivityViewTimeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+}
+
+void AdvanceActivityViewTimeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AdvanceActivityViewTimeRequest::~AdvanceActivityViewTimeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+  SharedDtor();
+}
+
+void AdvanceActivityViewTimeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void AdvanceActivityViewTimeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AdvanceActivityViewTimeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AdvanceActivityViewTimeRequest_descriptor_;
+}
+
+const AdvanceActivityViewTimeRequest& AdvanceActivityViewTimeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+AdvanceActivityViewTimeRequest* AdvanceActivityViewTimeRequest::default_instance_ = NULL;
+
+AdvanceActivityViewTimeRequest* AdvanceActivityViewTimeRequest::New() const {
+  return new AdvanceActivityViewTimeRequest;
+}
+
+void AdvanceActivityViewTimeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AdvanceActivityViewTimeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+  return false;
+#undef DO_
+}
+
+void AdvanceActivityViewTimeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+}
+
+::google::protobuf::uint8* AdvanceActivityViewTimeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+  return target;
+}
+
+int AdvanceActivityViewTimeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AdvanceActivityViewTimeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AdvanceActivityViewTimeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AdvanceActivityViewTimeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AdvanceActivityViewTimeRequest::MergeFrom(const AdvanceActivityViewTimeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AdvanceActivityViewTimeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AdvanceActivityViewTimeRequest::CopyFrom(const AdvanceActivityViewTimeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AdvanceActivityViewTimeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AdvanceActivityViewTimeRequest::Swap(AdvanceActivityViewTimeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AdvanceActivityViewTimeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AdvanceActivityViewTimeRequest_descriptor_;
+  metadata.reflection = AdvanceActivityViewTimeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamHistoryRequest::kAgentIdFieldNumber;
+const int GetStreamHistoryRequest::kClubIdFieldNumber;
+const int GetStreamHistoryRequest::kStreamIdFieldNumber;
+const int GetStreamHistoryRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamHistoryRequest::GetStreamHistoryRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetStreamHistoryRequest)
+}
+
+void GetStreamHistoryRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::GetEventOptions*>(&::bgs::protocol::GetEventOptions::default_instance());
+}
+
+GetStreamHistoryRequest::GetStreamHistoryRequest(const GetStreamHistoryRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetStreamHistoryRequest)
+}
+
+void GetStreamHistoryRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamHistoryRequest::~GetStreamHistoryRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetStreamHistoryRequest)
+  SharedDtor();
+}
+
+void GetStreamHistoryRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void GetStreamHistoryRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamHistoryRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamHistoryRequest_descriptor_;
+}
+
+const GetStreamHistoryRequest& GetStreamHistoryRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetStreamHistoryRequest* GetStreamHistoryRequest::default_instance_ = NULL;
+
+GetStreamHistoryRequest* GetStreamHistoryRequest::New() const {
+  return new GetStreamHistoryRequest;
+}
+
+void GetStreamHistoryRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetStreamHistoryRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::GetEventOptions::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamHistoryRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetStreamHistoryRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.GetEventOptions options = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetStreamHistoryRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetStreamHistoryRequest)
+  return false;
+#undef DO_
+}
+
+void GetStreamHistoryRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetStreamHistoryRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.GetEventOptions options = 4;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetStreamHistoryRequest)
+}
+
+::google::protobuf::uint8* GetStreamHistoryRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetStreamHistoryRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.GetEventOptions options = 4;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetStreamHistoryRequest)
+  return target;
+}
+
+int GetStreamHistoryRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.GetEventOptions options = 4;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamHistoryRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamHistoryRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamHistoryRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamHistoryRequest::MergeFrom(const GetStreamHistoryRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::GetEventOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamHistoryRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamHistoryRequest::CopyFrom(const GetStreamHistoryRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamHistoryRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetStreamHistoryRequest::Swap(GetStreamHistoryRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamHistoryRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamHistoryRequest_descriptor_;
+  metadata.reflection = GetStreamHistoryRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamHistoryResponse::kMessageFieldNumber;
+const int GetStreamHistoryResponse::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamHistoryResponse::GetStreamHistoryResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetStreamHistoryResponse)
+}
+
+void GetStreamHistoryResponse::InitAsDefaultInstance() {
+}
+
+GetStreamHistoryResponse::GetStreamHistoryResponse(const GetStreamHistoryResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetStreamHistoryResponse)
+}
+
+void GetStreamHistoryResponse::SharedCtor() {
+  _cached_size_ = 0;
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamHistoryResponse::~GetStreamHistoryResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetStreamHistoryResponse)
+  SharedDtor();
+}
+
+void GetStreamHistoryResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetStreamHistoryResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamHistoryResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamHistoryResponse_descriptor_;
+}
+
+const GetStreamHistoryResponse& GetStreamHistoryResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetStreamHistoryResponse* GetStreamHistoryResponse::default_instance_ = NULL;
+
+GetStreamHistoryResponse* GetStreamHistoryResponse::New() const {
+  return new GetStreamHistoryResponse;
+}
+
+void GetStreamHistoryResponse::Clear() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  message_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamHistoryResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetStreamHistoryResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_message;
+        if (input->ExpectTag(16)) goto parse_continuation;
+        break;
+      }
+
+      // optional uint64 continuation = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_continuation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetStreamHistoryResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetStreamHistoryResponse)
+  return false;
+#undef DO_
+}
+
+void GetStreamHistoryResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetStreamHistoryResponse)
+  // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+  for (int i = 0; i < this->message_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->message(i), output);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetStreamHistoryResponse)
+}
+
+::google::protobuf::uint8* GetStreamHistoryResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetStreamHistoryResponse)
+  // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+  for (int i = 0; i < this->message_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->message(i), target);
+  }
+
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetStreamHistoryResponse)
+  return target;
+}
+
+int GetStreamHistoryResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint64 continuation = 2;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+  total_size += 1 * this->message_size();
+  for (int i = 0; i < this->message_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->message(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamHistoryResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamHistoryResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamHistoryResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamHistoryResponse::MergeFrom(const GetStreamHistoryResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  message_.MergeFrom(from.message_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamHistoryResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamHistoryResponse::CopyFrom(const GetStreamHistoryResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamHistoryResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->message())) return false;
+  return true;
+}
+
+void GetStreamHistoryResponse::Swap(GetStreamHistoryResponse* other) {
+  if (other != this) {
+    message_.Swap(&other->message_);
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamHistoryResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamHistoryResponse_descriptor_;
+  metadata.reflection = GetStreamHistoryResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetClubActivityRequest::kAgentIdFieldNumber;
+const int GetClubActivityRequest::kClubIdFieldNumber;
+const int GetClubActivityRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+GetClubActivityRequest::GetClubActivityRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetClubActivityRequest)
+}
+
+void GetClubActivityRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  options_ = const_cast< ::bgs::protocol::GetEventOptions*>(&::bgs::protocol::GetEventOptions::default_instance());
+}
+
+GetClubActivityRequest::GetClubActivityRequest(const GetClubActivityRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetClubActivityRequest)
+}
+
+void GetClubActivityRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetClubActivityRequest::~GetClubActivityRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetClubActivityRequest)
+  SharedDtor();
+}
+
+void GetClubActivityRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void GetClubActivityRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetClubActivityRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetClubActivityRequest_descriptor_;
+}
+
+const GetClubActivityRequest& GetClubActivityRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetClubActivityRequest* GetClubActivityRequest::default_instance_ = NULL;
+
+GetClubActivityRequest* GetClubActivityRequest::New() const {
+  return new GetClubActivityRequest;
+}
+
+void GetClubActivityRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    club_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::GetEventOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetClubActivityRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetClubActivityRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.GetEventOptions options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetClubActivityRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetClubActivityRequest)
+  return false;
+#undef DO_
+}
+
+void GetClubActivityRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetClubActivityRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional .bgs.protocol.GetEventOptions options = 3;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetClubActivityRequest)
+}
+
+::google::protobuf::uint8* GetClubActivityRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetClubActivityRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional .bgs.protocol.GetEventOptions options = 3;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetClubActivityRequest)
+  return target;
+}
+
+int GetClubActivityRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional .bgs.protocol.GetEventOptions options = 3;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetClubActivityRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetClubActivityRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetClubActivityRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetClubActivityRequest::MergeFrom(const GetClubActivityRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::GetEventOptions::MergeFrom(from.options());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetClubActivityRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetClubActivityRequest::CopyFrom(const GetClubActivityRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetClubActivityRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetClubActivityRequest::Swap(GetClubActivityRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetClubActivityRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetClubActivityRequest_descriptor_;
+  metadata.reflection = GetClubActivityRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetClubActivityResponse::kContinuationFieldNumber;
+#endif  // !_MSC_VER
+
+GetClubActivityResponse::GetClubActivityResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetClubActivityResponse)
+}
+
+void GetClubActivityResponse::InitAsDefaultInstance() {
+}
+
+GetClubActivityResponse::GetClubActivityResponse(const GetClubActivityResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetClubActivityResponse)
+}
+
+void GetClubActivityResponse::SharedCtor() {
+  _cached_size_ = 0;
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetClubActivityResponse::~GetClubActivityResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetClubActivityResponse)
+  SharedDtor();
+}
+
+void GetClubActivityResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetClubActivityResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetClubActivityResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetClubActivityResponse_descriptor_;
+}
+
+const GetClubActivityResponse& GetClubActivityResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetClubActivityResponse* GetClubActivityResponse::default_instance_ = NULL;
+
+GetClubActivityResponse* GetClubActivityResponse::New() const {
+  return new GetClubActivityResponse;
+}
+
+void GetClubActivityResponse::Clear() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetClubActivityResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetClubActivityResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 continuation = 2;
+      case 2: {
+        if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &continuation_)));
+          set_has_continuation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetClubActivityResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetClubActivityResponse)
+  return false;
+#undef DO_
+}
+
+void GetClubActivityResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetClubActivityResponse)
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->continuation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetClubActivityResponse)
+}
+
+::google::protobuf::uint8* GetClubActivityResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetClubActivityResponse)
+  // optional uint64 continuation = 2;
+  if (has_continuation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->continuation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetClubActivityResponse)
+  return target;
+}
+
+int GetClubActivityResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 continuation = 2;
+    if (has_continuation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->continuation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetClubActivityResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetClubActivityResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetClubActivityResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetClubActivityResponse::MergeFrom(const GetClubActivityResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_continuation()) {
+      set_continuation(from.continuation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetClubActivityResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetClubActivityResponse::CopyFrom(const GetClubActivityResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetClubActivityResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetClubActivityResponse::Swap(GetClubActivityResponse* other) {
+  if (other != this) {
+    std::swap(continuation_, other->continuation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetClubActivityResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetClubActivityResponse_descriptor_;
+  metadata.reflection = GetClubActivityResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamVoiceTokenRequest::kAgentIdFieldNumber;
+const int GetStreamVoiceTokenRequest::kClubIdFieldNumber;
+const int GetStreamVoiceTokenRequest::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamVoiceTokenRequest::GetStreamVoiceTokenRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+}
+
+void GetStreamVoiceTokenRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+GetStreamVoiceTokenRequest::GetStreamVoiceTokenRequest(const GetStreamVoiceTokenRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+}
+
+void GetStreamVoiceTokenRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamVoiceTokenRequest::~GetStreamVoiceTokenRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+  SharedDtor();
+}
+
+void GetStreamVoiceTokenRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetStreamVoiceTokenRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamVoiceTokenRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamVoiceTokenRequest_descriptor_;
+}
+
+const GetStreamVoiceTokenRequest& GetStreamVoiceTokenRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetStreamVoiceTokenRequest* GetStreamVoiceTokenRequest::default_instance_ = NULL;
+
+GetStreamVoiceTokenRequest* GetStreamVoiceTokenRequest::New() const {
+  return new GetStreamVoiceTokenRequest;
+}
+
+void GetStreamVoiceTokenRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetStreamVoiceTokenRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamVoiceTokenRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+  return false;
+#undef DO_
+}
+
+void GetStreamVoiceTokenRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+}
+
+::google::protobuf::uint8* GetStreamVoiceTokenRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+  return target;
+}
+
+int GetStreamVoiceTokenRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamVoiceTokenRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamVoiceTokenRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamVoiceTokenRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamVoiceTokenRequest::MergeFrom(const GetStreamVoiceTokenRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamVoiceTokenRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamVoiceTokenRequest::CopyFrom(const GetStreamVoiceTokenRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamVoiceTokenRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetStreamVoiceTokenRequest::Swap(GetStreamVoiceTokenRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamVoiceTokenRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamVoiceTokenRequest_descriptor_;
+  metadata.reflection = GetStreamVoiceTokenRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetStreamVoiceTokenResponse::kChannelUriFieldNumber;
+const int GetStreamVoiceTokenResponse::kCredentialsFieldNumber;
+#endif  // !_MSC_VER
+
+GetStreamVoiceTokenResponse::GetStreamVoiceTokenResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+}
+
+void GetStreamVoiceTokenResponse::InitAsDefaultInstance() {
+  credentials_ = const_cast< ::bgs::protocol::VoiceCredentials*>(&::bgs::protocol::VoiceCredentials::default_instance());
+}
+
+GetStreamVoiceTokenResponse::GetStreamVoiceTokenResponse(const GetStreamVoiceTokenResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+}
+
+void GetStreamVoiceTokenResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  channel_uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  credentials_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetStreamVoiceTokenResponse::~GetStreamVoiceTokenResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+  SharedDtor();
+}
+
+void GetStreamVoiceTokenResponse::SharedDtor() {
+  if (channel_uri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete channel_uri_;
+  }
+  if (this != default_instance_) {
+    delete credentials_;
+  }
+}
+
+void GetStreamVoiceTokenResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetStreamVoiceTokenResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetStreamVoiceTokenResponse_descriptor_;
+}
+
+const GetStreamVoiceTokenResponse& GetStreamVoiceTokenResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+GetStreamVoiceTokenResponse* GetStreamVoiceTokenResponse::default_instance_ = NULL;
+
+GetStreamVoiceTokenResponse* GetStreamVoiceTokenResponse::New() const {
+  return new GetStreamVoiceTokenResponse;
+}
+
+void GetStreamVoiceTokenResponse::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_channel_uri()) {
+      if (channel_uri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        channel_uri_->clear();
+      }
+    }
+    if (has_credentials()) {
+      if (credentials_ != NULL) credentials_->::bgs::protocol::VoiceCredentials::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetStreamVoiceTokenResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string channel_uri = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_channel_uri()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->channel_uri().data(), this->channel_uri().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "channel_uri");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_credentials;
+        break;
+      }
+
+      // optional .bgs.protocol.VoiceCredentials credentials = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_credentials:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_credentials()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+  return false;
+#undef DO_
+}
+
+void GetStreamVoiceTokenResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+  // optional string channel_uri = 1;
+  if (has_channel_uri()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->channel_uri().data(), this->channel_uri().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "channel_uri");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->channel_uri(), output);
+  }
+
+  // optional .bgs.protocol.VoiceCredentials credentials = 2;
+  if (has_credentials()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->credentials(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+}
+
+::google::protobuf::uint8* GetStreamVoiceTokenResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+  // optional string channel_uri = 1;
+  if (has_channel_uri()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->channel_uri().data(), this->channel_uri().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "channel_uri");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->channel_uri(), target);
+  }
+
+  // optional .bgs.protocol.VoiceCredentials credentials = 2;
+  if (has_credentials()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->credentials(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+  return target;
+}
+
+int GetStreamVoiceTokenResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string channel_uri = 1;
+    if (has_channel_uri()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->channel_uri());
+    }
+
+    // optional .bgs.protocol.VoiceCredentials credentials = 2;
+    if (has_credentials()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->credentials());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetStreamVoiceTokenResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetStreamVoiceTokenResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetStreamVoiceTokenResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetStreamVoiceTokenResponse::MergeFrom(const GetStreamVoiceTokenResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_channel_uri()) {
+      set_channel_uri(from.channel_uri());
+    }
+    if (from.has_credentials()) {
+      mutable_credentials()->::bgs::protocol::VoiceCredentials::MergeFrom(from.credentials());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetStreamVoiceTokenResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetStreamVoiceTokenResponse::CopyFrom(const GetStreamVoiceTokenResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetStreamVoiceTokenResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetStreamVoiceTokenResponse::Swap(GetStreamVoiceTokenResponse* other) {
+  if (other != this) {
+    std::swap(channel_uri_, other->channel_uri_);
+    std::swap(credentials_, other->credentials_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetStreamVoiceTokenResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetStreamVoiceTokenResponse_descriptor_;
+  metadata.reflection = GetStreamVoiceTokenResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int KickFromStreamVoiceRequest::kAgentIdFieldNumber;
+const int KickFromStreamVoiceRequest::kClubIdFieldNumber;
+const int KickFromStreamVoiceRequest::kStreamIdFieldNumber;
+const int KickFromStreamVoiceRequest::kTargetIdFieldNumber;
+#endif  // !_MSC_VER
+
+KickFromStreamVoiceRequest::KickFromStreamVoiceRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+}
+
+void KickFromStreamVoiceRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+KickFromStreamVoiceRequest::KickFromStreamVoiceRequest(const KickFromStreamVoiceRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+}
+
+void KickFromStreamVoiceRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  target_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+KickFromStreamVoiceRequest::~KickFromStreamVoiceRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+  SharedDtor();
+}
+
+void KickFromStreamVoiceRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void KickFromStreamVoiceRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* KickFromStreamVoiceRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return KickFromStreamVoiceRequest_descriptor_;
+}
+
+const KickFromStreamVoiceRequest& KickFromStreamVoiceRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frequest_2eproto();
+  return *default_instance_;
+}
+
+KickFromStreamVoiceRequest* KickFromStreamVoiceRequest::default_instance_ = NULL;
+
+KickFromStreamVoiceRequest* KickFromStreamVoiceRequest::New() const {
+  return new KickFromStreamVoiceRequest;
+}
+
+void KickFromStreamVoiceRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<KickFromStreamVoiceRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(club_id_, stream_id_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool KickFromStreamVoiceRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_club_id;
+        break;
+      }
+
+      // optional uint64 club_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_club_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_target_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId target_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+  return false;
+#undef DO_
+}
+
+void KickFromStreamVoiceRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 4;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->target_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+}
+
+::google::protobuf::uint8* KickFromStreamVoiceRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 club_id = 2;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 3;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 4;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->target_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+  return target;
+}
+
+int KickFromStreamVoiceRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 club_id = 2;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 3;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId target_id = 4;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void KickFromStreamVoiceRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const KickFromStreamVoiceRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const KickFromStreamVoiceRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void KickFromStreamVoiceRequest::MergeFrom(const KickFromStreamVoiceRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.agent_id());
+    }
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.target_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void KickFromStreamVoiceRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void KickFromStreamVoiceRequest::CopyFrom(const KickFromStreamVoiceRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool KickFromStreamVoiceRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void KickFromStreamVoiceRequest::Swap(KickFromStreamVoiceRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata KickFromStreamVoiceRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = KickFromStreamVoiceRequest_descriptor_;
+  metadata.reflection = KickFromStreamVoiceRequest_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_request.pb.h b/src/server/proto/Client/club_request.pb.h
new file mode 100644
index 00000000000..bcb622e409e
--- /dev/null
+++ b/src/server/proto/Client/club_request.pb.h
@@ -0,0 +1,15093 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_request.proto
+
+#ifndef PROTOBUF_club_5frequest_2eproto__INCLUDED
+#define PROTOBUF_club_5frequest_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "club_types.pb.h"  // IWYU pragma: export
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+void protobuf_AssignDesc_club_5frequest_2eproto();
+void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+class SubscribeRequest;
+class UnsubscribeRequest;
+class CreateRequest;
+class CreateResponse;
+class DestroyRequest;
+class GetDescriptionRequest;
+class GetDescriptionResponse;
+class GetClubTypeRequest;
+class GetClubTypeResponse;
+class UpdateClubStateRequest;
+class UpdateClubSettingsRequest;
+class JoinRequest;
+class LeaveRequest;
+class KickRequest;
+class GetMemberRequest;
+class GetMemberResponse;
+class GetMembersRequest;
+class GetMembersResponse;
+class UpdateMemberStateRequest;
+class UpdateSubscriberStateRequest;
+class AssignRoleRequest;
+class UnassignRoleRequest;
+class SendInvitationRequest;
+class AcceptInvitationRequest;
+class DeclineInvitationRequest;
+class RevokeInvitationRequest;
+class GetInvitationRequest;
+class GetInvitationResponse;
+class GetInvitationsRequest;
+class GetInvitationsResponse;
+class SendSuggestionRequest;
+class AcceptSuggestionRequest;
+class DeclineSuggestionRequest;
+class GetSuggestionRequest;
+class GetSuggestionResponse;
+class GetSuggestionsRequest;
+class GetSuggestionsResponse;
+class CreateTicketRequest;
+class CreateTicketResponse;
+class DestroyTicketRequest;
+class RedeemTicketRequest;
+class GetTicketRequest;
+class GetTicketResponse;
+class GetTicketsRequest;
+class GetTicketsResponse;
+class AddBanRequest;
+class RemoveBanRequest;
+class GetBanRequest;
+class GetBanResponse;
+class GetBansRequest;
+class GetBansResponse;
+class SubscribeStreamRequest;
+class UnsubscribeStreamRequest;
+class CreateStreamRequest;
+class DestroyStreamRequest;
+class GetStreamRequest;
+class GetStreamResponse;
+class GetStreamsRequest;
+class GetStreamsResponse;
+class UpdateStreamStateRequest;
+class SetStreamFocusRequest;
+class CreateMessageRequest;
+class CreateMessageResponse;
+class DestroyMessageRequest;
+class DestroyMessageResponse;
+class EditMessageRequest;
+class EditMessageResponse;
+class SetMessagePinnedRequest;
+class SetTypingIndicatorRequest;
+class AdvanceStreamViewTimeRequest;
+class AdvanceStreamMentionViewTimeRequest;
+class AdvanceActivityViewTimeRequest;
+class GetStreamHistoryRequest;
+class GetStreamHistoryResponse;
+class GetClubActivityRequest;
+class GetClubActivityResponse;
+class GetStreamVoiceTokenRequest;
+class GetStreamVoiceTokenResponse;
+class KickFromStreamVoiceRequest;
+
+// ===================================================================
+
+class TC_PROTO_API SubscribeRequest : public ::google::protobuf::Message {
+ public:
+  SubscribeRequest();
+  virtual ~SubscribeRequest();
+
+  SubscribeRequest(const SubscribeRequest& from);
+
+  inline SubscribeRequest& operator=(const SubscribeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubscribeRequest& default_instance();
+
+  void Swap(SubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeRequest& from);
+  void MergeFrom(const SubscribeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UnsubscribeRequest : public ::google::protobuf::Message {
+ public:
+  UnsubscribeRequest();
+  virtual ~UnsubscribeRequest();
+
+  UnsubscribeRequest(const UnsubscribeRequest& from);
+
+  inline UnsubscribeRequest& operator=(const UnsubscribeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UnsubscribeRequest& default_instance();
+
+  void Swap(UnsubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsubscribeRequest& from);
+  void MergeFrom(const UnsubscribeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UnsubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateRequest : public ::google::protobuf::Message {
+ public:
+  CreateRequest();
+  virtual ~CreateRequest();
+
+  CreateRequest(const CreateRequest& from);
+
+  inline CreateRequest& operator=(const CreateRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateRequest& default_instance();
+
+  void Swap(CreateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateRequest& from);
+  void MergeFrom(const CreateRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.ClubCreateOptions options = 2;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::ClubCreateOptions& options() const;
+  inline ::bgs::protocol::club::v1::ClubCreateOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::ClubCreateOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::ClubCreateOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::ClubCreateOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateResponse : public ::google::protobuf::Message {
+ public:
+  CreateResponse();
+  virtual ~CreateResponse();
+
+  CreateResponse(const CreateResponse& from);
+
+  inline CreateResponse& operator=(const CreateResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateResponse& default_instance();
+
+  void Swap(CreateResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateResponse& from);
+  void MergeFrom(const CreateResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 club_id = 1;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateResponse)
+ private:
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 club_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API DestroyRequest : public ::google::protobuf::Message {
+ public:
+  DestroyRequest();
+  virtual ~DestroyRequest();
+
+  DestroyRequest(const DestroyRequest& from);
+
+  inline DestroyRequest& operator=(const DestroyRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DestroyRequest& default_instance();
+
+  void Swap(DestroyRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  DestroyRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DestroyRequest& from);
+  void MergeFrom(const DestroyRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.DestroyRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static DestroyRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetDescriptionRequest : public ::google::protobuf::Message {
+ public:
+  GetDescriptionRequest();
+  virtual ~GetDescriptionRequest();
+
+  GetDescriptionRequest(const GetDescriptionRequest& from);
+
+  inline GetDescriptionRequest& operator=(const GetDescriptionRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetDescriptionRequest& default_instance();
+
+  void Swap(GetDescriptionRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetDescriptionRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetDescriptionRequest& from);
+  void MergeFrom(const GetDescriptionRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetDescriptionRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetDescriptionRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetDescriptionResponse : public ::google::protobuf::Message {
+ public:
+  GetDescriptionResponse();
+  virtual ~GetDescriptionResponse();
+
+  GetDescriptionResponse(const GetDescriptionResponse& from);
+
+  inline GetDescriptionResponse& operator=(const GetDescriptionResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetDescriptionResponse& default_instance();
+
+  void Swap(GetDescriptionResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetDescriptionResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetDescriptionResponse& from);
+  void MergeFrom(const GetDescriptionResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubDescription club = 1;
+  inline bool has_club() const;
+  inline void clear_club();
+  static const int kClubFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubDescription& club() const;
+  inline ::bgs::protocol::club::v1::ClubDescription* mutable_club();
+  inline ::bgs::protocol::club::v1::ClubDescription* release_club();
+  inline void set_allocated_club(::bgs::protocol::club::v1::ClubDescription* club);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetDescriptionResponse)
+ private:
+  inline void set_has_club();
+  inline void clear_has_club();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubDescription* club_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetDescriptionResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetClubTypeRequest : public ::google::protobuf::Message {
+ public:
+  GetClubTypeRequest();
+  virtual ~GetClubTypeRequest();
+
+  GetClubTypeRequest(const GetClubTypeRequest& from);
+
+  inline GetClubTypeRequest& operator=(const GetClubTypeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetClubTypeRequest& default_instance();
+
+  void Swap(GetClubTypeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetClubTypeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetClubTypeRequest& from);
+  void MergeFrom(const GetClubTypeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::UniqueClubType& type() const;
+  inline ::bgs::protocol::club::v1::UniqueClubType* mutable_type();
+  inline ::bgs::protocol::club::v1::UniqueClubType* release_type();
+  inline void set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetClubTypeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_type();
+  inline void clear_has_type();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::bgs::protocol::club::v1::UniqueClubType* type_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetClubTypeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetClubTypeResponse : public ::google::protobuf::Message {
+ public:
+  GetClubTypeResponse();
+  virtual ~GetClubTypeResponse();
+
+  GetClubTypeResponse(const GetClubTypeResponse& from);
+
+  inline GetClubTypeResponse& operator=(const GetClubTypeResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetClubTypeResponse& default_instance();
+
+  void Swap(GetClubTypeResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetClubTypeResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetClubTypeResponse& from);
+  void MergeFrom(const GetClubTypeResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::UniqueClubType& type() const;
+  inline ::bgs::protocol::club::v1::UniqueClubType* mutable_type();
+  inline ::bgs::protocol::club::v1::UniqueClubType* release_type();
+  inline void set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type);
+
+  // optional .bgs.protocol.club.v1.ClubRoleSet role_set = 2;
+  inline bool has_role_set() const;
+  inline void clear_role_set();
+  static const int kRoleSetFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::ClubRoleSet& role_set() const;
+  inline ::bgs::protocol::club::v1::ClubRoleSet* mutable_role_set();
+  inline ::bgs::protocol::club::v1::ClubRoleSet* release_role_set();
+  inline void set_allocated_role_set(::bgs::protocol::club::v1::ClubRoleSet* role_set);
+
+  // optional .bgs.protocol.club.v1.ClubTypeRangeSet range_set = 3;
+  inline bool has_range_set() const;
+  inline void clear_range_set();
+  static const int kRangeSetFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::ClubTypeRangeSet& range_set() const;
+  inline ::bgs::protocol::club::v1::ClubTypeRangeSet* mutable_range_set();
+  inline ::bgs::protocol::club::v1::ClubTypeRangeSet* release_range_set();
+  inline void set_allocated_range_set(::bgs::protocol::club::v1::ClubTypeRangeSet* range_set);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetClubTypeResponse)
+ private:
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_role_set();
+  inline void clear_has_role_set();
+  inline void set_has_range_set();
+  inline void clear_has_range_set();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::UniqueClubType* type_;
+  ::bgs::protocol::club::v1::ClubRoleSet* role_set_;
+  ::bgs::protocol::club::v1::ClubTypeRangeSet* range_set_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetClubTypeResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UpdateClubStateRequest : public ::google::protobuf::Message {
+ public:
+  UpdateClubStateRequest();
+  virtual ~UpdateClubStateRequest();
+
+  UpdateClubStateRequest(const UpdateClubStateRequest& from);
+
+  inline UpdateClubStateRequest& operator=(const UpdateClubStateRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UpdateClubStateRequest& default_instance();
+
+  void Swap(UpdateClubStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateClubStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateClubStateRequest& from);
+  void MergeFrom(const UpdateClubStateRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.ClubStateOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::ClubStateOptions& options() const;
+  inline ::bgs::protocol::club::v1::ClubStateOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::ClubStateOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::ClubStateOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UpdateClubStateRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::ClubStateOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateClubStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UpdateClubSettingsRequest : public ::google::protobuf::Message {
+ public:
+  UpdateClubSettingsRequest();
+  virtual ~UpdateClubSettingsRequest();
+
+  UpdateClubSettingsRequest(const UpdateClubSettingsRequest& from);
+
+  inline UpdateClubSettingsRequest& operator=(const UpdateClubSettingsRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UpdateClubSettingsRequest& default_instance();
+
+  void Swap(UpdateClubSettingsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateClubSettingsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateClubSettingsRequest& from);
+  void MergeFrom(const UpdateClubSettingsRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.ClubSettingsOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::ClubSettingsOptions& options() const;
+  inline ::bgs::protocol::club::v1::ClubSettingsOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::ClubSettingsOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::ClubSettingsOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UpdateClubSettingsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::ClubSettingsOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateClubSettingsRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API JoinRequest : public ::google::protobuf::Message {
+ public:
+  JoinRequest();
+  virtual ~JoinRequest();
+
+  JoinRequest(const JoinRequest& from);
+
+  inline JoinRequest& operator=(const JoinRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JoinRequest& default_instance();
+
+  void Swap(JoinRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  JoinRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const JoinRequest& from);
+  void MergeFrom(const JoinRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.CreateMemberOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::CreateMemberOptions& options() const;
+  inline ::bgs::protocol::club::v1::CreateMemberOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::CreateMemberOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::CreateMemberOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.JoinRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::CreateMemberOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static JoinRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API LeaveRequest : public ::google::protobuf::Message {
+ public:
+  LeaveRequest();
+  virtual ~LeaveRequest();
+
+  LeaveRequest(const LeaveRequest& from);
+
+  inline LeaveRequest& operator=(const LeaveRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const LeaveRequest& default_instance();
+
+  void Swap(LeaveRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  LeaveRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const LeaveRequest& from);
+  void MergeFrom(const LeaveRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.LeaveRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static LeaveRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API KickRequest : public ::google::protobuf::Message {
+ public:
+  KickRequest();
+  virtual ~KickRequest();
+
+  KickRequest(const KickRequest& from);
+
+  inline KickRequest& operator=(const KickRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const KickRequest& default_instance();
+
+  void Swap(KickRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  KickRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const KickRequest& from);
+  void MergeFrom(const KickRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberId& target_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_target_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.KickRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::MemberId* target_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static KickRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetMemberRequest : public ::google::protobuf::Message {
+ public:
+  GetMemberRequest();
+  virtual ~GetMemberRequest();
+
+  GetMemberRequest(const GetMemberRequest& from);
+
+  inline GetMemberRequest& operator=(const GetMemberRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetMemberRequest& default_instance();
+
+  void Swap(GetMemberRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetMemberRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetMemberRequest& from);
+  void MergeFrom(const GetMemberRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetMemberRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetMemberRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetMemberResponse : public ::google::protobuf::Message {
+ public:
+  GetMemberResponse();
+  virtual ~GetMemberResponse();
+
+  GetMemberResponse(const GetMemberResponse& from);
+
+  inline GetMemberResponse& operator=(const GetMemberResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetMemberResponse& default_instance();
+
+  void Swap(GetMemberResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetMemberResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetMemberResponse& from);
+  void MergeFrom(const GetMemberResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.Member member = 1;
+  inline bool has_member() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::Member& member() const;
+  inline ::bgs::protocol::club::v1::Member* mutable_member();
+  inline ::bgs::protocol::club::v1::Member* release_member();
+  inline void set_allocated_member(::bgs::protocol::club::v1::Member* member);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetMemberResponse)
+ private:
+  inline void set_has_member();
+  inline void clear_has_member();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::Member* member_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetMemberResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetMembersRequest : public ::google::protobuf::Message {
+ public:
+  GetMembersRequest();
+  virtual ~GetMembersRequest();
+
+  GetMembersRequest(const GetMembersRequest& from);
+
+  inline GetMembersRequest& operator=(const GetMembersRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetMembersRequest& default_instance();
+
+  void Swap(GetMembersRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetMembersRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetMembersRequest& from);
+  void MergeFrom(const GetMembersRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 continuation = 4;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 4;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetMembersRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetMembersRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetMembersResponse : public ::google::protobuf::Message {
+ public:
+  GetMembersResponse();
+  virtual ~GetMembersResponse();
+
+  GetMembersResponse(const GetMembersResponse& from);
+
+  inline GetMembersResponse& operator=(const GetMembersResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetMembersResponse& default_instance();
+
+  void Swap(GetMembersResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetMembersResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetMembersResponse& from);
+  void MergeFrom(const GetMembersResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.Member member = 1;
+  inline int member_size() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::Member& member(int index) const;
+  inline ::bgs::protocol::club::v1::Member* mutable_member(int index);
+  inline ::bgs::protocol::club::v1::Member* add_member();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member >&
+      member() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member >*
+      mutable_member();
+
+  // optional uint64 continuation = 2;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 2;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetMembersResponse)
+ private:
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member > member_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetMembersResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UpdateMemberStateRequest : public ::google::protobuf::Message {
+ public:
+  UpdateMemberStateRequest();
+  virtual ~UpdateMemberStateRequest();
+
+  UpdateMemberStateRequest(const UpdateMemberStateRequest& from);
+
+  inline UpdateMemberStateRequest& operator=(const UpdateMemberStateRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UpdateMemberStateRequest& default_instance();
+
+  void Swap(UpdateMemberStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateMemberStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateMemberStateRequest& from);
+  void MergeFrom(const UpdateMemberStateRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 3;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // optional .bgs.protocol.club.v1.MemberStateOptions options = 5;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::MemberStateOptions& options() const;
+  inline ::bgs::protocol::club::v1::MemberStateOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::MemberStateOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::MemberStateOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UpdateMemberStateRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  ::bgs::protocol::club::v1::MemberStateOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateMemberStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UpdateSubscriberStateRequest : public ::google::protobuf::Message {
+ public:
+  UpdateSubscriberStateRequest();
+  virtual ~UpdateSubscriberStateRequest();
+
+  UpdateSubscriberStateRequest(const UpdateSubscriberStateRequest& from);
+
+  inline UpdateSubscriberStateRequest& operator=(const UpdateSubscriberStateRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UpdateSubscriberStateRequest& default_instance();
+
+  void Swap(UpdateSubscriberStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateSubscriberStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateSubscriberStateRequest& from);
+  void MergeFrom(const UpdateSubscriberStateRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.SubscriberStateOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::SubscriberStateOptions& options() const;
+  inline ::bgs::protocol::club::v1::SubscriberStateOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::SubscriberStateOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::SubscriberStateOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UpdateSubscriberStateRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::SubscriberStateOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateSubscriberStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AssignRoleRequest : public ::google::protobuf::Message {
+ public:
+  AssignRoleRequest();
+  virtual ~AssignRoleRequest();
+
+  AssignRoleRequest(const AssignRoleRequest& from);
+
+  inline AssignRoleRequest& operator=(const AssignRoleRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AssignRoleRequest& default_instance();
+
+  void Swap(AssignRoleRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AssignRoleRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AssignRoleRequest& from);
+  void MergeFrom(const AssignRoleRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+  inline bool has_assignment() const;
+  inline void clear_assignment();
+  static const int kAssignmentFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::RoleAssignment& assignment() const;
+  inline ::bgs::protocol::club::v1::RoleAssignment* mutable_assignment();
+  inline ::bgs::protocol::club::v1::RoleAssignment* release_assignment();
+  inline void set_allocated_assignment(::bgs::protocol::club::v1::RoleAssignment* assignment);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.AssignRoleRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_assignment();
+  inline void clear_has_assignment();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::RoleAssignment* assignment_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static AssignRoleRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UnassignRoleRequest : public ::google::protobuf::Message {
+ public:
+  UnassignRoleRequest();
+  virtual ~UnassignRoleRequest();
+
+  UnassignRoleRequest(const UnassignRoleRequest& from);
+
+  inline UnassignRoleRequest& operator=(const UnassignRoleRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UnassignRoleRequest& default_instance();
+
+  void Swap(UnassignRoleRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UnassignRoleRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnassignRoleRequest& from);
+  void MergeFrom(const UnassignRoleRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+  inline bool has_assignment() const;
+  inline void clear_assignment();
+  static const int kAssignmentFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::RoleAssignment& assignment() const;
+  inline ::bgs::protocol::club::v1::RoleAssignment* mutable_assignment();
+  inline ::bgs::protocol::club::v1::RoleAssignment* release_assignment();
+  inline void set_allocated_assignment(::bgs::protocol::club::v1::RoleAssignment* assignment);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UnassignRoleRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_assignment();
+  inline void clear_has_assignment();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::RoleAssignment* assignment_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnassignRoleRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SendInvitationRequest : public ::google::protobuf::Message {
+ public:
+  SendInvitationRequest();
+  virtual ~SendInvitationRequest();
+
+  SendInvitationRequest(const SendInvitationRequest& from);
+
+  inline SendInvitationRequest& operator=(const SendInvitationRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SendInvitationRequest& default_instance();
+
+  void Swap(SendInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SendInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendInvitationRequest& from);
+  void MergeFrom(const SendInvitationRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.SendInvitationOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::SendInvitationOptions& options() const;
+  inline ::bgs::protocol::club::v1::SendInvitationOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::SendInvitationOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::SendInvitationOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SendInvitationRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::SendInvitationOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AcceptInvitationRequest : public ::google::protobuf::Message {
+ public:
+  AcceptInvitationRequest();
+  virtual ~AcceptInvitationRequest();
+
+  AcceptInvitationRequest(const AcceptInvitationRequest& from);
+
+  inline AcceptInvitationRequest& operator=(const AcceptInvitationRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AcceptInvitationRequest& default_instance();
+
+  void Swap(AcceptInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AcceptInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AcceptInvitationRequest& from);
+  void MergeFrom(const AcceptInvitationRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional fixed64 invitation_id = 3;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.AcceptInvitationRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static AcceptInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API DeclineInvitationRequest : public ::google::protobuf::Message {
+ public:
+  DeclineInvitationRequest();
+  virtual ~DeclineInvitationRequest();
+
+  DeclineInvitationRequest(const DeclineInvitationRequest& from);
+
+  inline DeclineInvitationRequest& operator=(const DeclineInvitationRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DeclineInvitationRequest& default_instance();
+
+  void Swap(DeclineInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  DeclineInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DeclineInvitationRequest& from);
+  void MergeFrom(const DeclineInvitationRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional fixed64 invitation_id = 3;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.DeclineInvitationRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static DeclineInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RevokeInvitationRequest : public ::google::protobuf::Message {
+ public:
+  RevokeInvitationRequest();
+  virtual ~RevokeInvitationRequest();
+
+  RevokeInvitationRequest(const RevokeInvitationRequest& from);
+
+  inline RevokeInvitationRequest& operator=(const RevokeInvitationRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RevokeInvitationRequest& default_instance();
+
+  void Swap(RevokeInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  RevokeInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RevokeInvitationRequest& from);
+  void MergeFrom(const RevokeInvitationRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional fixed64 invitation_id = 3;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.RevokeInvitationRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static RevokeInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetInvitationRequest : public ::google::protobuf::Message {
+ public:
+  GetInvitationRequest();
+  virtual ~GetInvitationRequest();
+
+  GetInvitationRequest(const GetInvitationRequest& from);
+
+  inline GetInvitationRequest& operator=(const GetInvitationRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetInvitationRequest& default_instance();
+
+  void Swap(GetInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetInvitationRequest& from);
+  void MergeFrom(const GetInvitationRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional fixed64 invitation_id = 3;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetInvitationRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetInvitationResponse : public ::google::protobuf::Message {
+ public:
+  GetInvitationResponse();
+  virtual ~GetInvitationResponse();
+
+  GetInvitationResponse(const GetInvitationResponse& from);
+
+  inline GetInvitationResponse& operator=(const GetInvitationResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetInvitationResponse& default_instance();
+
+  void Swap(GetInvitationResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetInvitationResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetInvitationResponse& from);
+  void MergeFrom(const GetInvitationResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+  inline bool has_invitation() const;
+  inline void clear_invitation();
+  static const int kInvitationFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubInvitation& invitation() const;
+  inline ::bgs::protocol::club::v1::ClubInvitation* mutable_invitation();
+  inline ::bgs::protocol::club::v1::ClubInvitation* release_invitation();
+  inline void set_allocated_invitation(::bgs::protocol::club::v1::ClubInvitation* invitation);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetInvitationResponse)
+ private:
+  inline void set_has_invitation();
+  inline void clear_has_invitation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubInvitation* invitation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetInvitationResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetInvitationsRequest : public ::google::protobuf::Message {
+ public:
+  GetInvitationsRequest();
+  virtual ~GetInvitationsRequest();
+
+  GetInvitationsRequest(const GetInvitationsRequest& from);
+
+  inline GetInvitationsRequest& operator=(const GetInvitationsRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetInvitationsRequest& default_instance();
+
+  void Swap(GetInvitationsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetInvitationsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetInvitationsRequest& from);
+  void MergeFrom(const GetInvitationsRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 continuation = 3;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 3;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetInvitationsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetInvitationsRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetInvitationsResponse : public ::google::protobuf::Message {
+ public:
+  GetInvitationsResponse();
+  virtual ~GetInvitationsResponse();
+
+  GetInvitationsResponse(const GetInvitationsResponse& from);
+
+  inline GetInvitationsResponse& operator=(const GetInvitationsResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetInvitationsResponse& default_instance();
+
+  void Swap(GetInvitationsResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetInvitationsResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetInvitationsResponse& from);
+  void MergeFrom(const GetInvitationsResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+  inline int invitation_size() const;
+  inline void clear_invitation();
+  static const int kInvitationFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubInvitation& invitation(int index) const;
+  inline ::bgs::protocol::club::v1::ClubInvitation* mutable_invitation(int index);
+  inline ::bgs::protocol::club::v1::ClubInvitation* add_invitation();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation >&
+      invitation() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation >*
+      mutable_invitation();
+
+  // optional uint64 continuation = 2;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 2;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetInvitationsResponse)
+ private:
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation > invitation_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetInvitationsResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SendSuggestionRequest : public ::google::protobuf::Message {
+ public:
+  SendSuggestionRequest();
+  virtual ~SendSuggestionRequest();
+
+  SendSuggestionRequest(const SendSuggestionRequest& from);
+
+  inline SendSuggestionRequest& operator=(const SendSuggestionRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SendSuggestionRequest& default_instance();
+
+  void Swap(SendSuggestionRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SendSuggestionRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendSuggestionRequest& from);
+  void MergeFrom(const SendSuggestionRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.SendSuggestionOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::SendSuggestionOptions& options() const;
+  inline ::bgs::protocol::club::v1::SendSuggestionOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::SendSuggestionOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::SendSuggestionOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SendSuggestionRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::SendSuggestionOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendSuggestionRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AcceptSuggestionRequest : public ::google::protobuf::Message {
+ public:
+  AcceptSuggestionRequest();
+  virtual ~AcceptSuggestionRequest();
+
+  AcceptSuggestionRequest(const AcceptSuggestionRequest& from);
+
+  inline AcceptSuggestionRequest& operator=(const AcceptSuggestionRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AcceptSuggestionRequest& default_instance();
+
+  void Swap(AcceptSuggestionRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AcceptSuggestionRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AcceptSuggestionRequest& from);
+  void MergeFrom(const AcceptSuggestionRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional fixed64 suggestion_id = 3;
+  inline bool has_suggestion_id() const;
+  inline void clear_suggestion_id();
+  static const int kSuggestionIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 suggestion_id() const;
+  inline void set_suggestion_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.AcceptSuggestionRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_suggestion_id();
+  inline void clear_has_suggestion_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 suggestion_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static AcceptSuggestionRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API DeclineSuggestionRequest : public ::google::protobuf::Message {
+ public:
+  DeclineSuggestionRequest();
+  virtual ~DeclineSuggestionRequest();
+
+  DeclineSuggestionRequest(const DeclineSuggestionRequest& from);
+
+  inline DeclineSuggestionRequest& operator=(const DeclineSuggestionRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DeclineSuggestionRequest& default_instance();
+
+  void Swap(DeclineSuggestionRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  DeclineSuggestionRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DeclineSuggestionRequest& from);
+  void MergeFrom(const DeclineSuggestionRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional fixed64 suggestion_id = 3;
+  inline bool has_suggestion_id() const;
+  inline void clear_suggestion_id();
+  static const int kSuggestionIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 suggestion_id() const;
+  inline void set_suggestion_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.DeclineSuggestionRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_suggestion_id();
+  inline void clear_has_suggestion_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 suggestion_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static DeclineSuggestionRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetSuggestionRequest : public ::google::protobuf::Message {
+ public:
+  GetSuggestionRequest();
+  virtual ~GetSuggestionRequest();
+
+  GetSuggestionRequest(const GetSuggestionRequest& from);
+
+  inline GetSuggestionRequest& operator=(const GetSuggestionRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetSuggestionRequest& default_instance();
+
+  void Swap(GetSuggestionRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetSuggestionRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetSuggestionRequest& from);
+  void MergeFrom(const GetSuggestionRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional fixed64 suggestion_id = 3;
+  inline bool has_suggestion_id() const;
+  inline void clear_suggestion_id();
+  static const int kSuggestionIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 suggestion_id() const;
+  inline void set_suggestion_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetSuggestionRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_suggestion_id();
+  inline void clear_has_suggestion_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 suggestion_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetSuggestionRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetSuggestionResponse : public ::google::protobuf::Message {
+ public:
+  GetSuggestionResponse();
+  virtual ~GetSuggestionResponse();
+
+  GetSuggestionResponse(const GetSuggestionResponse& from);
+
+  inline GetSuggestionResponse& operator=(const GetSuggestionResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetSuggestionResponse& default_instance();
+
+  void Swap(GetSuggestionResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetSuggestionResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetSuggestionResponse& from);
+  void MergeFrom(const GetSuggestionResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+  inline bool has_suggestion() const;
+  inline void clear_suggestion();
+  static const int kSuggestionFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubSuggestion& suggestion() const;
+  inline ::bgs::protocol::club::v1::ClubSuggestion* mutable_suggestion();
+  inline ::bgs::protocol::club::v1::ClubSuggestion* release_suggestion();
+  inline void set_allocated_suggestion(::bgs::protocol::club::v1::ClubSuggestion* suggestion);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetSuggestionResponse)
+ private:
+  inline void set_has_suggestion();
+  inline void clear_has_suggestion();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubSuggestion* suggestion_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetSuggestionResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetSuggestionsRequest : public ::google::protobuf::Message {
+ public:
+  GetSuggestionsRequest();
+  virtual ~GetSuggestionsRequest();
+
+  GetSuggestionsRequest(const GetSuggestionsRequest& from);
+
+  inline GetSuggestionsRequest& operator=(const GetSuggestionsRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetSuggestionsRequest& default_instance();
+
+  void Swap(GetSuggestionsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetSuggestionsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetSuggestionsRequest& from);
+  void MergeFrom(const GetSuggestionsRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 continuation = 3;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 3;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetSuggestionsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetSuggestionsRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetSuggestionsResponse : public ::google::protobuf::Message {
+ public:
+  GetSuggestionsResponse();
+  virtual ~GetSuggestionsResponse();
+
+  GetSuggestionsResponse(const GetSuggestionsResponse& from);
+
+  inline GetSuggestionsResponse& operator=(const GetSuggestionsResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetSuggestionsResponse& default_instance();
+
+  void Swap(GetSuggestionsResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetSuggestionsResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetSuggestionsResponse& from);
+  void MergeFrom(const GetSuggestionsResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+  inline int suggestion_size() const;
+  inline void clear_suggestion();
+  static const int kSuggestionFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubSuggestion& suggestion(int index) const;
+  inline ::bgs::protocol::club::v1::ClubSuggestion* mutable_suggestion(int index);
+  inline ::bgs::protocol::club::v1::ClubSuggestion* add_suggestion();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubSuggestion >&
+      suggestion() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubSuggestion >*
+      mutable_suggestion();
+
+  // optional uint64 continuation = 2;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 2;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetSuggestionsResponse)
+ private:
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubSuggestion > suggestion_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetSuggestionsResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateTicketRequest : public ::google::protobuf::Message {
+ public:
+  CreateTicketRequest();
+  virtual ~CreateTicketRequest();
+
+  CreateTicketRequest(const CreateTicketRequest& from);
+
+  inline CreateTicketRequest& operator=(const CreateTicketRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateTicketRequest& default_instance();
+
+  void Swap(CreateTicketRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateTicketRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateTicketRequest& from);
+  void MergeFrom(const CreateTicketRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.CreateTicketOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::CreateTicketOptions& options() const;
+  inline ::bgs::protocol::club::v1::CreateTicketOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::CreateTicketOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::CreateTicketOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateTicketRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::CreateTicketOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateTicketRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateTicketResponse : public ::google::protobuf::Message {
+ public:
+  CreateTicketResponse();
+  virtual ~CreateTicketResponse();
+
+  CreateTicketResponse(const CreateTicketResponse& from);
+
+  inline CreateTicketResponse& operator=(const CreateTicketResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateTicketResponse& default_instance();
+
+  void Swap(CreateTicketResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateTicketResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateTicketResponse& from);
+  void MergeFrom(const CreateTicketResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  inline bool has_ticket() const;
+  inline void clear_ticket();
+  static const int kTicketFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubTicket& ticket() const;
+  inline ::bgs::protocol::club::v1::ClubTicket* mutable_ticket();
+  inline ::bgs::protocol::club::v1::ClubTicket* release_ticket();
+  inline void set_allocated_ticket(::bgs::protocol::club::v1::ClubTicket* ticket);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateTicketResponse)
+ private:
+  inline void set_has_ticket();
+  inline void clear_has_ticket();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubTicket* ticket_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateTicketResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API DestroyTicketRequest : public ::google::protobuf::Message {
+ public:
+  DestroyTicketRequest();
+  virtual ~DestroyTicketRequest();
+
+  DestroyTicketRequest(const DestroyTicketRequest& from);
+
+  inline DestroyTicketRequest& operator=(const DestroyTicketRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DestroyTicketRequest& default_instance();
+
+  void Swap(DestroyTicketRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  DestroyTicketRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DestroyTicketRequest& from);
+  void MergeFrom(const DestroyTicketRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional string ticket_id = 3;
+  inline bool has_ticket_id() const;
+  inline void clear_ticket_id();
+  static const int kTicketIdFieldNumber = 3;
+  inline const ::std::string& ticket_id() const;
+  inline void set_ticket_id(const ::std::string& value);
+  inline void set_ticket_id(const char* value);
+  inline void set_ticket_id(const char* value, size_t size);
+  inline ::std::string* mutable_ticket_id();
+  inline ::std::string* release_ticket_id();
+  inline void set_allocated_ticket_id(::std::string* ticket_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.DestroyTicketRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_ticket_id();
+  inline void clear_has_ticket_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::std::string* ticket_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static DestroyTicketRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RedeemTicketRequest : public ::google::protobuf::Message {
+ public:
+  RedeemTicketRequest();
+  virtual ~RedeemTicketRequest();
+
+  RedeemTicketRequest(const RedeemTicketRequest& from);
+
+  inline RedeemTicketRequest& operator=(const RedeemTicketRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RedeemTicketRequest& default_instance();
+
+  void Swap(RedeemTicketRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  RedeemTicketRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RedeemTicketRequest& from);
+  void MergeFrom(const RedeemTicketRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional string ticket_id = 3;
+  inline bool has_ticket_id() const;
+  inline void clear_ticket_id();
+  static const int kTicketIdFieldNumber = 3;
+  inline const ::std::string& ticket_id() const;
+  inline void set_ticket_id(const ::std::string& value);
+  inline void set_ticket_id(const char* value);
+  inline void set_ticket_id(const char* value, size_t size);
+  inline ::std::string* mutable_ticket_id();
+  inline ::std::string* release_ticket_id();
+  inline void set_allocated_ticket_id(::std::string* ticket_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.RedeemTicketRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_ticket_id();
+  inline void clear_has_ticket_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::std::string* ticket_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static RedeemTicketRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetTicketRequest : public ::google::protobuf::Message {
+ public:
+  GetTicketRequest();
+  virtual ~GetTicketRequest();
+
+  GetTicketRequest(const GetTicketRequest& from);
+
+  inline GetTicketRequest& operator=(const GetTicketRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetTicketRequest& default_instance();
+
+  void Swap(GetTicketRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetTicketRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetTicketRequest& from);
+  void MergeFrom(const GetTicketRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional string ticket_id = 3;
+  inline bool has_ticket_id() const;
+  inline void clear_ticket_id();
+  static const int kTicketIdFieldNumber = 3;
+  inline const ::std::string& ticket_id() const;
+  inline void set_ticket_id(const ::std::string& value);
+  inline void set_ticket_id(const char* value);
+  inline void set_ticket_id(const char* value, size_t size);
+  inline ::std::string* mutable_ticket_id();
+  inline ::std::string* release_ticket_id();
+  inline void set_allocated_ticket_id(::std::string* ticket_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetTicketRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_ticket_id();
+  inline void clear_has_ticket_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::std::string* ticket_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetTicketRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetTicketResponse : public ::google::protobuf::Message {
+ public:
+  GetTicketResponse();
+  virtual ~GetTicketResponse();
+
+  GetTicketResponse(const GetTicketResponse& from);
+
+  inline GetTicketResponse& operator=(const GetTicketResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetTicketResponse& default_instance();
+
+  void Swap(GetTicketResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetTicketResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetTicketResponse& from);
+  void MergeFrom(const GetTicketResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  inline bool has_ticket() const;
+  inline void clear_ticket();
+  static const int kTicketFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubTicket& ticket() const;
+  inline ::bgs::protocol::club::v1::ClubTicket* mutable_ticket();
+  inline ::bgs::protocol::club::v1::ClubTicket* release_ticket();
+  inline void set_allocated_ticket(::bgs::protocol::club::v1::ClubTicket* ticket);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetTicketResponse)
+ private:
+  inline void set_has_ticket();
+  inline void clear_has_ticket();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubTicket* ticket_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetTicketResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetTicketsRequest : public ::google::protobuf::Message {
+ public:
+  GetTicketsRequest();
+  virtual ~GetTicketsRequest();
+
+  GetTicketsRequest(const GetTicketsRequest& from);
+
+  inline GetTicketsRequest& operator=(const GetTicketsRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetTicketsRequest& default_instance();
+
+  void Swap(GetTicketsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetTicketsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetTicketsRequest& from);
+  void MergeFrom(const GetTicketsRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 continuation = 3;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 3;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetTicketsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetTicketsRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetTicketsResponse : public ::google::protobuf::Message {
+ public:
+  GetTicketsResponse();
+  virtual ~GetTicketsResponse();
+
+  GetTicketsResponse(const GetTicketsResponse& from);
+
+  inline GetTicketsResponse& operator=(const GetTicketsResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetTicketsResponse& default_instance();
+
+  void Swap(GetTicketsResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetTicketsResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetTicketsResponse& from);
+  void MergeFrom(const GetTicketsResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.ClubTicket ticket = 1;
+  inline int ticket_size() const;
+  inline void clear_ticket();
+  static const int kTicketFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubTicket& ticket(int index) const;
+  inline ::bgs::protocol::club::v1::ClubTicket* mutable_ticket(int index);
+  inline ::bgs::protocol::club::v1::ClubTicket* add_ticket();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubTicket >&
+      ticket() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubTicket >*
+      mutable_ticket();
+
+  // optional uint64 continuation = 2;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 2;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetTicketsResponse)
+ private:
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubTicket > ticket_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetTicketsResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AddBanRequest : public ::google::protobuf::Message {
+ public:
+  AddBanRequest();
+  virtual ~AddBanRequest();
+
+  AddBanRequest(const AddBanRequest& from);
+
+  inline AddBanRequest& operator=(const AddBanRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AddBanRequest& default_instance();
+
+  void Swap(AddBanRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AddBanRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AddBanRequest& from);
+  void MergeFrom(const AddBanRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.AddBanOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::AddBanOptions& options() const;
+  inline ::bgs::protocol::club::v1::AddBanOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::AddBanOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::AddBanOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.AddBanRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::AddBanOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static AddBanRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RemoveBanRequest : public ::google::protobuf::Message {
+ public:
+  RemoveBanRequest();
+  virtual ~RemoveBanRequest();
+
+  RemoveBanRequest(const RemoveBanRequest& from);
+
+  inline RemoveBanRequest& operator=(const RemoveBanRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RemoveBanRequest& default_instance();
+
+  void Swap(RemoveBanRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  RemoveBanRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RemoveBanRequest& from);
+  void MergeFrom(const RemoveBanRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberId& target_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_target_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.RemoveBanRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::MemberId* target_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static RemoveBanRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetBanRequest : public ::google::protobuf::Message {
+ public:
+  GetBanRequest();
+  virtual ~GetBanRequest();
+
+  GetBanRequest(const GetBanRequest& from);
+
+  inline GetBanRequest& operator=(const GetBanRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetBanRequest& default_instance();
+
+  void Swap(GetBanRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetBanRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetBanRequest& from);
+  void MergeFrom(const GetBanRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 3;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberId& target_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_target_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetBanRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::MemberId* target_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetBanRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetBanResponse : public ::google::protobuf::Message {
+ public:
+  GetBanResponse();
+  virtual ~GetBanResponse();
+
+  GetBanResponse(const GetBanResponse& from);
+
+  inline GetBanResponse& operator=(const GetBanResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetBanResponse& default_instance();
+
+  void Swap(GetBanResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetBanResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetBanResponse& from);
+  void MergeFrom(const GetBanResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.ClubBan ban = 1;
+  inline bool has_ban() const;
+  inline void clear_ban();
+  static const int kBanFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubBan& ban() const;
+  inline ::bgs::protocol::club::v1::ClubBan* mutable_ban();
+  inline ::bgs::protocol::club::v1::ClubBan* release_ban();
+  inline void set_allocated_ban(::bgs::protocol::club::v1::ClubBan* ban);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetBanResponse)
+ private:
+  inline void set_has_ban();
+  inline void clear_has_ban();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::ClubBan* ban_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetBanResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetBansRequest : public ::google::protobuf::Message {
+ public:
+  GetBansRequest();
+  virtual ~GetBansRequest();
+
+  GetBansRequest(const GetBansRequest& from);
+
+  inline GetBansRequest& operator=(const GetBansRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetBansRequest& default_instance();
+
+  void Swap(GetBansRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetBansRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetBansRequest& from);
+  void MergeFrom(const GetBansRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 continuation = 3;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 3;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetBansRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetBansRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetBansResponse : public ::google::protobuf::Message {
+ public:
+  GetBansResponse();
+  virtual ~GetBansResponse();
+
+  GetBansResponse(const GetBansResponse& from);
+
+  inline GetBansResponse& operator=(const GetBansResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetBansResponse& default_instance();
+
+  void Swap(GetBansResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetBansResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetBansResponse& from);
+  void MergeFrom(const GetBansResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.ClubBan ban = 1;
+  inline int ban_size() const;
+  inline void clear_ban();
+  static const int kBanFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubBan& ban(int index) const;
+  inline ::bgs::protocol::club::v1::ClubBan* mutable_ban(int index);
+  inline ::bgs::protocol::club::v1::ClubBan* add_ban();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubBan >&
+      ban() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubBan >*
+      mutable_ban();
+
+  // optional uint64 continuation = 2;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 2;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetBansResponse)
+ private:
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubBan > ban_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetBansResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SubscribeStreamRequest : public ::google::protobuf::Message {
+ public:
+  SubscribeStreamRequest();
+  virtual ~SubscribeStreamRequest();
+
+  SubscribeStreamRequest(const SubscribeStreamRequest& from);
+
+  inline SubscribeStreamRequest& operator=(const SubscribeStreamRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubscribeStreamRequest& default_instance();
+
+  void Swap(SubscribeStreamRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeStreamRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeStreamRequest& from);
+  void MergeFrom(const SubscribeStreamRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // repeated uint64 stream_id = 3;
+  inline int stream_id_size() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id(int index) const;
+  inline void set_stream_id(int index, ::google::protobuf::uint64 value);
+  inline void add_stream_id(::google::protobuf::uint64 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+      stream_id() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+      mutable_stream_id();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SubscribeStreamRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > stream_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeStreamRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UnsubscribeStreamRequest : public ::google::protobuf::Message {
+ public:
+  UnsubscribeStreamRequest();
+  virtual ~UnsubscribeStreamRequest();
+
+  UnsubscribeStreamRequest(const UnsubscribeStreamRequest& from);
+
+  inline UnsubscribeStreamRequest& operator=(const UnsubscribeStreamRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UnsubscribeStreamRequest& default_instance();
+
+  void Swap(UnsubscribeStreamRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsubscribeStreamRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsubscribeStreamRequest& from);
+  void MergeFrom(const UnsubscribeStreamRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // repeated uint64 stream_id = 3;
+  inline int stream_id_size() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id(int index) const;
+  inline void set_stream_id(int index, ::google::protobuf::uint64 value);
+  inline void add_stream_id(::google::protobuf::uint64 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+      stream_id() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+      mutable_stream_id();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UnsubscribeStreamRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > stream_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsubscribeStreamRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateStreamRequest : public ::google::protobuf::Message {
+ public:
+  CreateStreamRequest();
+  virtual ~CreateStreamRequest();
+
+  CreateStreamRequest(const CreateStreamRequest& from);
+
+  inline CreateStreamRequest& operator=(const CreateStreamRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateStreamRequest& default_instance();
+
+  void Swap(CreateStreamRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateStreamRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateStreamRequest& from);
+  void MergeFrom(const CreateStreamRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.CreateStreamOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::CreateStreamOptions& options() const;
+  inline ::bgs::protocol::club::v1::CreateStreamOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::CreateStreamOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::CreateStreamOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateStreamRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::club::v1::CreateStreamOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateStreamRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API DestroyStreamRequest : public ::google::protobuf::Message {
+ public:
+  DestroyStreamRequest();
+  virtual ~DestroyStreamRequest();
+
+  DestroyStreamRequest(const DestroyStreamRequest& from);
+
+  inline DestroyStreamRequest& operator=(const DestroyStreamRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DestroyStreamRequest& default_instance();
+
+  void Swap(DestroyStreamRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  DestroyStreamRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DestroyStreamRequest& from);
+  void MergeFrom(const DestroyStreamRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.DestroyStreamRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static DestroyStreamRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamRequest : public ::google::protobuf::Message {
+ public:
+  GetStreamRequest();
+  virtual ~GetStreamRequest();
+
+  GetStreamRequest(const GetStreamRequest& from);
+
+  inline GetStreamRequest& operator=(const GetStreamRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamRequest& default_instance();
+
+  void Swap(GetStreamRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamRequest& from);
+  void MergeFrom(const GetStreamRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetStreamRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamResponse : public ::google::protobuf::Message {
+ public:
+  GetStreamResponse();
+  virtual ~GetStreamResponse();
+
+  GetStreamResponse(const GetStreamResponse& from);
+
+  inline GetStreamResponse& operator=(const GetStreamResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamResponse& default_instance();
+
+  void Swap(GetStreamResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamResponse& from);
+  void MergeFrom(const GetStreamResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.Stream stream = 1;
+  inline bool has_stream() const;
+  inline void clear_stream();
+  static const int kStreamFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::Stream& stream() const;
+  inline ::bgs::protocol::club::v1::Stream* mutable_stream();
+  inline ::bgs::protocol::club::v1::Stream* release_stream();
+  inline void set_allocated_stream(::bgs::protocol::club::v1::Stream* stream);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetStreamResponse)
+ private:
+  inline void set_has_stream();
+  inline void clear_has_stream();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::Stream* stream_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamsRequest : public ::google::protobuf::Message {
+ public:
+  GetStreamsRequest();
+  virtual ~GetStreamsRequest();
+
+  GetStreamsRequest(const GetStreamsRequest& from);
+
+  inline GetStreamsRequest& operator=(const GetStreamsRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamsRequest& default_instance();
+
+  void Swap(GetStreamsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamsRequest& from);
+  void MergeFrom(const GetStreamsRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 continuation = 3;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 3;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetStreamsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamsRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamsResponse : public ::google::protobuf::Message {
+ public:
+  GetStreamsResponse();
+  virtual ~GetStreamsResponse();
+
+  GetStreamsResponse(const GetStreamsResponse& from);
+
+  inline GetStreamsResponse& operator=(const GetStreamsResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamsResponse& default_instance();
+
+  void Swap(GetStreamsResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamsResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamsResponse& from);
+  void MergeFrom(const GetStreamsResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.Stream stream = 1;
+  inline int stream_size() const;
+  inline void clear_stream();
+  static const int kStreamFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::Stream& stream(int index) const;
+  inline ::bgs::protocol::club::v1::Stream* mutable_stream(int index);
+  inline ::bgs::protocol::club::v1::Stream* add_stream();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Stream >&
+      stream() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Stream >*
+      mutable_stream();
+
+  // repeated .bgs.protocol.club.v1.StreamView view = 2;
+  inline int view_size() const;
+  inline void clear_view();
+  static const int kViewFieldNumber = 2;
+  inline const ::bgs::protocol::club::v1::StreamView& view(int index) const;
+  inline ::bgs::protocol::club::v1::StreamView* mutable_view(int index);
+  inline ::bgs::protocol::club::v1::StreamView* add_view();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamView >&
+      view() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamView >*
+      mutable_view();
+
+  // optional uint64 continuation = 3;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 3;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetStreamsResponse)
+ private:
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Stream > stream_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamView > view_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamsResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UpdateStreamStateRequest : public ::google::protobuf::Message {
+ public:
+  UpdateStreamStateRequest();
+  virtual ~UpdateStreamStateRequest();
+
+  UpdateStreamStateRequest(const UpdateStreamStateRequest& from);
+
+  inline UpdateStreamStateRequest& operator=(const UpdateStreamStateRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UpdateStreamStateRequest& default_instance();
+
+  void Swap(UpdateStreamStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateStreamStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateStreamStateRequest& from);
+  void MergeFrom(const UpdateStreamStateRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.StreamStateOptions options = 5;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::StreamStateOptions& options() const;
+  inline ::bgs::protocol::club::v1::StreamStateOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::StreamStateOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::StreamStateOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.UpdateStreamStateRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::club::v1::StreamStateOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateStreamStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SetStreamFocusRequest : public ::google::protobuf::Message {
+ public:
+  SetStreamFocusRequest();
+  virtual ~SetStreamFocusRequest();
+
+  SetStreamFocusRequest(const SetStreamFocusRequest& from);
+
+  inline SetStreamFocusRequest& operator=(const SetStreamFocusRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SetStreamFocusRequest& default_instance();
+
+  void Swap(SetStreamFocusRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SetStreamFocusRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SetStreamFocusRequest& from);
+  void MergeFrom(const SetStreamFocusRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional bool focus = 4;
+  inline bool has_focus() const;
+  inline void clear_focus();
+  static const int kFocusFieldNumber = 4;
+  inline bool focus() const;
+  inline void set_focus(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SetStreamFocusRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_focus();
+  inline void clear_has_focus();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  bool focus_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static SetStreamFocusRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateMessageRequest : public ::google::protobuf::Message {
+ public:
+  CreateMessageRequest();
+  virtual ~CreateMessageRequest();
+
+  CreateMessageRequest(const CreateMessageRequest& from);
+
+  inline CreateMessageRequest& operator=(const CreateMessageRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateMessageRequest& default_instance();
+
+  void Swap(CreateMessageRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateMessageRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateMessageRequest& from);
+  void MergeFrom(const CreateMessageRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.CreateMessageOptions options = 4;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::CreateMessageOptions& options() const;
+  inline ::bgs::protocol::club::v1::CreateMessageOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::CreateMessageOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::CreateMessageOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateMessageRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::club::v1::CreateMessageOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateMessageRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateMessageResponse : public ::google::protobuf::Message {
+ public:
+  CreateMessageResponse();
+  virtual ~CreateMessageResponse();
+
+  CreateMessageResponse(const CreateMessageResponse& from);
+
+  inline CreateMessageResponse& operator=(const CreateMessageResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateMessageResponse& default_instance();
+
+  void Swap(CreateMessageResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateMessageResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateMessageResponse& from);
+  void MergeFrom(const CreateMessageResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+  inline bool has_message() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::StreamMessage& message() const;
+  inline ::bgs::protocol::club::v1::StreamMessage* mutable_message();
+  inline ::bgs::protocol::club::v1::StreamMessage* release_message();
+  inline void set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateMessageResponse)
+ private:
+  inline void set_has_message();
+  inline void clear_has_message();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::StreamMessage* message_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateMessageResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API DestroyMessageRequest : public ::google::protobuf::Message {
+ public:
+  DestroyMessageRequest();
+  virtual ~DestroyMessageRequest();
+
+  DestroyMessageRequest(const DestroyMessageRequest& from);
+
+  inline DestroyMessageRequest& operator=(const DestroyMessageRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DestroyMessageRequest& default_instance();
+
+  void Swap(DestroyMessageRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  DestroyMessageRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DestroyMessageRequest& from);
+  void MergeFrom(const DestroyMessageRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.MessageId message_id = 4;
+  inline bool has_message_id() const;
+  inline void clear_message_id();
+  static const int kMessageIdFieldNumber = 4;
+  inline const ::bgs::protocol::MessageId& message_id() const;
+  inline ::bgs::protocol::MessageId* mutable_message_id();
+  inline ::bgs::protocol::MessageId* release_message_id();
+  inline void set_allocated_message_id(::bgs::protocol::MessageId* message_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.DestroyMessageRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_message_id();
+  inline void clear_has_message_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::MessageId* message_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static DestroyMessageRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API DestroyMessageResponse : public ::google::protobuf::Message {
+ public:
+  DestroyMessageResponse();
+  virtual ~DestroyMessageResponse();
+
+  DestroyMessageResponse(const DestroyMessageResponse& from);
+
+  inline DestroyMessageResponse& operator=(const DestroyMessageResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DestroyMessageResponse& default_instance();
+
+  void Swap(DestroyMessageResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  DestroyMessageResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DestroyMessageResponse& from);
+  void MergeFrom(const DestroyMessageResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+  inline bool has_message() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::StreamMessage& message() const;
+  inline ::bgs::protocol::club::v1::StreamMessage* mutable_message();
+  inline ::bgs::protocol::club::v1::StreamMessage* release_message();
+  inline void set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.DestroyMessageResponse)
+ private:
+  inline void set_has_message();
+  inline void clear_has_message();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::StreamMessage* message_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static DestroyMessageResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API EditMessageRequest : public ::google::protobuf::Message {
+ public:
+  EditMessageRequest();
+  virtual ~EditMessageRequest();
+
+  EditMessageRequest(const EditMessageRequest& from);
+
+  inline EditMessageRequest& operator=(const EditMessageRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EditMessageRequest& default_instance();
+
+  void Swap(EditMessageRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  EditMessageRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const EditMessageRequest& from);
+  void MergeFrom(const EditMessageRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.MessageId message_id = 4;
+  inline bool has_message_id() const;
+  inline void clear_message_id();
+  static const int kMessageIdFieldNumber = 4;
+  inline const ::bgs::protocol::MessageId& message_id() const;
+  inline ::bgs::protocol::MessageId* mutable_message_id();
+  inline ::bgs::protocol::MessageId* release_message_id();
+  inline void set_allocated_message_id(::bgs::protocol::MessageId* message_id);
+
+  // optional .bgs.protocol.club.v1.CreateMessageOptions options = 5;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::CreateMessageOptions& options() const;
+  inline ::bgs::protocol::club::v1::CreateMessageOptions* mutable_options();
+  inline ::bgs::protocol::club::v1::CreateMessageOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::club::v1::CreateMessageOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.EditMessageRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_message_id();
+  inline void clear_has_message_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::MessageId* message_id_;
+  ::bgs::protocol::club::v1::CreateMessageOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static EditMessageRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API EditMessageResponse : public ::google::protobuf::Message {
+ public:
+  EditMessageResponse();
+  virtual ~EditMessageResponse();
+
+  EditMessageResponse(const EditMessageResponse& from);
+
+  inline EditMessageResponse& operator=(const EditMessageResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EditMessageResponse& default_instance();
+
+  void Swap(EditMessageResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  EditMessageResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const EditMessageResponse& from);
+  void MergeFrom(const EditMessageResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.StreamMessage message = 1;
+  inline bool has_message() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::StreamMessage& message() const;
+  inline ::bgs::protocol::club::v1::StreamMessage* mutable_message();
+  inline ::bgs::protocol::club::v1::StreamMessage* release_message();
+  inline void set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.EditMessageResponse)
+ private:
+  inline void set_has_message();
+  inline void clear_has_message();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::StreamMessage* message_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static EditMessageResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SetMessagePinnedRequest : public ::google::protobuf::Message {
+ public:
+  SetMessagePinnedRequest();
+  virtual ~SetMessagePinnedRequest();
+
+  SetMessagePinnedRequest(const SetMessagePinnedRequest& from);
+
+  inline SetMessagePinnedRequest& operator=(const SetMessagePinnedRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SetMessagePinnedRequest& default_instance();
+
+  void Swap(SetMessagePinnedRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SetMessagePinnedRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SetMessagePinnedRequest& from);
+  void MergeFrom(const SetMessagePinnedRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SetMessagePinnedRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static SetMessagePinnedRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SetTypingIndicatorRequest : public ::google::protobuf::Message {
+ public:
+  SetTypingIndicatorRequest();
+  virtual ~SetTypingIndicatorRequest();
+
+  SetTypingIndicatorRequest(const SetTypingIndicatorRequest& from);
+
+  inline SetTypingIndicatorRequest& operator=(const SetTypingIndicatorRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SetTypingIndicatorRequest& default_instance();
+
+  void Swap(SetTypingIndicatorRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SetTypingIndicatorRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SetTypingIndicatorRequest& from);
+  void MergeFrom(const SetTypingIndicatorRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.TypingIndicator indicator = 4;
+  inline bool has_indicator() const;
+  inline void clear_indicator();
+  static const int kIndicatorFieldNumber = 4;
+  inline ::bgs::protocol::TypingIndicator indicator() const;
+  inline void set_indicator(::bgs::protocol::TypingIndicator value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.SetTypingIndicatorRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_indicator();
+  inline void clear_has_indicator();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  int indicator_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static SetTypingIndicatorRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AdvanceStreamViewTimeRequest : public ::google::protobuf::Message {
+ public:
+  AdvanceStreamViewTimeRequest();
+  virtual ~AdvanceStreamViewTimeRequest();
+
+  AdvanceStreamViewTimeRequest(const AdvanceStreamViewTimeRequest& from);
+
+  inline AdvanceStreamViewTimeRequest& operator=(const AdvanceStreamViewTimeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AdvanceStreamViewTimeRequest& default_instance();
+
+  void Swap(AdvanceStreamViewTimeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AdvanceStreamViewTimeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AdvanceStreamViewTimeRequest& from);
+  void MergeFrom(const AdvanceStreamViewTimeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id_deprecated = 3 [deprecated = true];
+  inline bool has_stream_id_deprecated() const PROTOBUF_DEPRECATED;
+  inline void clear_stream_id_deprecated() PROTOBUF_DEPRECATED;
+  static const int kStreamIdDeprecatedFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id_deprecated() const PROTOBUF_DEPRECATED;
+  inline void set_stream_id_deprecated(::google::protobuf::uint64 value) PROTOBUF_DEPRECATED;
+
+  // repeated uint64 stream_id = 4 [packed = true];
+  inline int stream_id_size() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 stream_id(int index) const;
+  inline void set_stream_id(int index, ::google::protobuf::uint64 value);
+  inline void add_stream_id(::google::protobuf::uint64 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+      stream_id() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+      mutable_stream_id();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id_deprecated();
+  inline void clear_has_stream_id_deprecated();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_deprecated_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > stream_id_;
+  mutable int _stream_id_cached_byte_size_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static AdvanceStreamViewTimeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AdvanceStreamMentionViewTimeRequest : public ::google::protobuf::Message {
+ public:
+  AdvanceStreamMentionViewTimeRequest();
+  virtual ~AdvanceStreamMentionViewTimeRequest();
+
+  AdvanceStreamMentionViewTimeRequest(const AdvanceStreamMentionViewTimeRequest& from);
+
+  inline AdvanceStreamMentionViewTimeRequest& operator=(const AdvanceStreamMentionViewTimeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AdvanceStreamMentionViewTimeRequest& default_instance();
+
+  void Swap(AdvanceStreamMentionViewTimeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AdvanceStreamMentionViewTimeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AdvanceStreamMentionViewTimeRequest& from);
+  void MergeFrom(const AdvanceStreamMentionViewTimeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static AdvanceStreamMentionViewTimeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AdvanceActivityViewTimeRequest : public ::google::protobuf::Message {
+ public:
+  AdvanceActivityViewTimeRequest();
+  virtual ~AdvanceActivityViewTimeRequest();
+
+  AdvanceActivityViewTimeRequest(const AdvanceActivityViewTimeRequest& from);
+
+  inline AdvanceActivityViewTimeRequest& operator=(const AdvanceActivityViewTimeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AdvanceActivityViewTimeRequest& default_instance();
+
+  void Swap(AdvanceActivityViewTimeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AdvanceActivityViewTimeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AdvanceActivityViewTimeRequest& from);
+  void MergeFrom(const AdvanceActivityViewTimeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static AdvanceActivityViewTimeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamHistoryRequest : public ::google::protobuf::Message {
+ public:
+  GetStreamHistoryRequest();
+  virtual ~GetStreamHistoryRequest();
+
+  GetStreamHistoryRequest(const GetStreamHistoryRequest& from);
+
+  inline GetStreamHistoryRequest& operator=(const GetStreamHistoryRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamHistoryRequest& default_instance();
+
+  void Swap(GetStreamHistoryRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamHistoryRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamHistoryRequest& from);
+  void MergeFrom(const GetStreamHistoryRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.GetEventOptions options = 4;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 4;
+  inline const ::bgs::protocol::GetEventOptions& options() const;
+  inline ::bgs::protocol::GetEventOptions* mutable_options();
+  inline ::bgs::protocol::GetEventOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::GetEventOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetStreamHistoryRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::GetEventOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamHistoryRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamHistoryResponse : public ::google::protobuf::Message {
+ public:
+  GetStreamHistoryResponse();
+  virtual ~GetStreamHistoryResponse();
+
+  GetStreamHistoryResponse(const GetStreamHistoryResponse& from);
+
+  inline GetStreamHistoryResponse& operator=(const GetStreamHistoryResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamHistoryResponse& default_instance();
+
+  void Swap(GetStreamHistoryResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamHistoryResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamHistoryResponse& from);
+  void MergeFrom(const GetStreamHistoryResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+  inline int message_size() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::StreamMessage& message(int index) const;
+  inline ::bgs::protocol::club::v1::StreamMessage* mutable_message(int index);
+  inline ::bgs::protocol::club::v1::StreamMessage* add_message();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage >&
+      message() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage >*
+      mutable_message();
+
+  // optional uint64 continuation = 2;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 2;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetStreamHistoryResponse)
+ private:
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage > message_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamHistoryResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetClubActivityRequest : public ::google::protobuf::Message {
+ public:
+  GetClubActivityRequest();
+  virtual ~GetClubActivityRequest();
+
+  GetClubActivityRequest(const GetClubActivityRequest& from);
+
+  inline GetClubActivityRequest& operator=(const GetClubActivityRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetClubActivityRequest& default_instance();
+
+  void Swap(GetClubActivityRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetClubActivityRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetClubActivityRequest& from);
+  void MergeFrom(const GetClubActivityRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.GetEventOptions options = 3;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::GetEventOptions& options() const;
+  inline ::bgs::protocol::GetEventOptions* mutable_options();
+  inline ::bgs::protocol::GetEventOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::GetEventOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetClubActivityRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::bgs::protocol::GetEventOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetClubActivityRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetClubActivityResponse : public ::google::protobuf::Message {
+ public:
+  GetClubActivityResponse();
+  virtual ~GetClubActivityResponse();
+
+  GetClubActivityResponse(const GetClubActivityResponse& from);
+
+  inline GetClubActivityResponse& operator=(const GetClubActivityResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetClubActivityResponse& default_instance();
+
+  void Swap(GetClubActivityResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetClubActivityResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetClubActivityResponse& from);
+  void MergeFrom(const GetClubActivityResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 continuation = 2;
+  inline bool has_continuation() const;
+  inline void clear_continuation();
+  static const int kContinuationFieldNumber = 2;
+  inline ::google::protobuf::uint64 continuation() const;
+  inline void set_continuation(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetClubActivityResponse)
+ private:
+  inline void set_has_continuation();
+  inline void clear_has_continuation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 continuation_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetClubActivityResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamVoiceTokenRequest : public ::google::protobuf::Message {
+ public:
+  GetStreamVoiceTokenRequest();
+  virtual ~GetStreamVoiceTokenRequest();
+
+  GetStreamVoiceTokenRequest(const GetStreamVoiceTokenRequest& from);
+
+  inline GetStreamVoiceTokenRequest& operator=(const GetStreamVoiceTokenRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamVoiceTokenRequest& default_instance();
+
+  void Swap(GetStreamVoiceTokenRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamVoiceTokenRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamVoiceTokenRequest& from);
+  void MergeFrom(const GetStreamVoiceTokenRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetStreamVoiceTokenRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamVoiceTokenRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API GetStreamVoiceTokenResponse : public ::google::protobuf::Message {
+ public:
+  GetStreamVoiceTokenResponse();
+  virtual ~GetStreamVoiceTokenResponse();
+
+  GetStreamVoiceTokenResponse(const GetStreamVoiceTokenResponse& from);
+
+  inline GetStreamVoiceTokenResponse& operator=(const GetStreamVoiceTokenResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetStreamVoiceTokenResponse& default_instance();
+
+  void Swap(GetStreamVoiceTokenResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetStreamVoiceTokenResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetStreamVoiceTokenResponse& from);
+  void MergeFrom(const GetStreamVoiceTokenResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string channel_uri = 1;
+  inline bool has_channel_uri() const;
+  inline void clear_channel_uri();
+  static const int kChannelUriFieldNumber = 1;
+  inline const ::std::string& channel_uri() const;
+  inline void set_channel_uri(const ::std::string& value);
+  inline void set_channel_uri(const char* value);
+  inline void set_channel_uri(const char* value, size_t size);
+  inline ::std::string* mutable_channel_uri();
+  inline ::std::string* release_channel_uri();
+  inline void set_allocated_channel_uri(::std::string* channel_uri);
+
+  // optional .bgs.protocol.VoiceCredentials credentials = 2;
+  inline bool has_credentials() const;
+  inline void clear_credentials();
+  static const int kCredentialsFieldNumber = 2;
+  inline const ::bgs::protocol::VoiceCredentials& credentials() const;
+  inline ::bgs::protocol::VoiceCredentials* mutable_credentials();
+  inline ::bgs::protocol::VoiceCredentials* release_credentials();
+  inline void set_allocated_credentials(::bgs::protocol::VoiceCredentials* credentials);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.GetStreamVoiceTokenResponse)
+ private:
+  inline void set_has_channel_uri();
+  inline void clear_has_channel_uri();
+  inline void set_has_credentials();
+  inline void clear_has_credentials();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* channel_uri_;
+  ::bgs::protocol::VoiceCredentials* credentials_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetStreamVoiceTokenResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API KickFromStreamVoiceRequest : public ::google::protobuf::Message {
+ public:
+  KickFromStreamVoiceRequest();
+  virtual ~KickFromStreamVoiceRequest();
+
+  KickFromStreamVoiceRequest(const KickFromStreamVoiceRequest& from);
+
+  inline KickFromStreamVoiceRequest& operator=(const KickFromStreamVoiceRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const KickFromStreamVoiceRequest& default_instance();
+
+  void Swap(KickFromStreamVoiceRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  KickFromStreamVoiceRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const KickFromStreamVoiceRequest& from);
+  void MergeFrom(const KickFromStreamVoiceRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& agent_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_agent_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id);
+
+  // optional uint64 club_id = 2;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 3;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.club.v1.MemberId target_id = 4;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::MemberId& target_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_target_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.KickFromStreamVoiceRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* agent_id_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::club::v1::MemberId* target_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frequest_2eproto();
+  friend void protobuf_AssignDesc_club_5frequest_2eproto();
+  friend void protobuf_ShutdownFile_club_5frequest_2eproto();
+
+  void InitAsDefaultInstance();
+  static KickFromStreamVoiceRequest* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// SubscribeRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SubscribeRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscribeRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool SubscribeRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscribeRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscribeRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscribeRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SubscribeRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeRequest.club_id)
+  return club_id_;
+}
+inline void SubscribeRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SubscribeRequest.club_id)
+}
+
+// -------------------------------------------------------------------
+
+// UnsubscribeRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool UnsubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UnsubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnsubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnsubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UnsubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnsubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UnsubscribeRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool UnsubscribeRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnsubscribeRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnsubscribeRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnsubscribeRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 UnsubscribeRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnsubscribeRequest.club_id)
+  return club_id_;
+}
+inline void UnsubscribeRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UnsubscribeRequest.club_id)
+}
+
+// -------------------------------------------------------------------
+
+// CreateRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool CreateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& CreateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void CreateRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateRequest.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubCreateOptions options = 2;
+inline bool CreateRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CreateRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CreateRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CreateRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::ClubCreateOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::ClubCreateOptions& CreateRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::ClubCreateOptions* CreateRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::ClubCreateOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::ClubCreateOptions* CreateRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::ClubCreateOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void CreateRequest::set_allocated_options(::bgs::protocol::club::v1::ClubCreateOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// CreateResponse
+
+// optional uint64 club_id = 1;
+inline bool CreateResponse::has_club_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateResponse::set_has_club_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateResponse::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateResponse::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 CreateResponse::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateResponse.club_id)
+  return club_id_;
+}
+inline void CreateResponse::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateResponse.club_id)
+}
+
+// -------------------------------------------------------------------
+
+// DestroyRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool DestroyRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DestroyRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DestroyRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DestroyRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& DestroyRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DestroyRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.DestroyRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DestroyRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void DestroyRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.DestroyRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool DestroyRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DestroyRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DestroyRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DestroyRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 DestroyRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyRequest.club_id)
+  return club_id_;
+}
+inline void DestroyRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DestroyRequest.club_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetDescriptionRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetDescriptionRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetDescriptionRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetDescriptionRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetDescriptionRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetDescriptionRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetDescriptionRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetDescriptionRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetDescriptionRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetDescriptionRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetDescriptionRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetDescriptionRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetDescriptionRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetDescriptionRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetDescriptionRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetDescriptionRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetDescriptionRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetDescriptionRequest.club_id)
+  return club_id_;
+}
+inline void GetDescriptionRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetDescriptionRequest.club_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetDescriptionResponse
+
+// optional .bgs.protocol.club.v1.ClubDescription club = 1;
+inline bool GetDescriptionResponse::has_club() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetDescriptionResponse::set_has_club() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetDescriptionResponse::clear_has_club() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetDescriptionResponse::clear_club() {
+  if (club_ != NULL) club_->::bgs::protocol::club::v1::ClubDescription::Clear();
+  clear_has_club();
+}
+inline const ::bgs::protocol::club::v1::ClubDescription& GetDescriptionResponse::club() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetDescriptionResponse.club)
+  return club_ != NULL ? *club_ : *default_instance_->club_;
+}
+inline ::bgs::protocol::club::v1::ClubDescription* GetDescriptionResponse::mutable_club() {
+  set_has_club();
+  if (club_ == NULL) club_ = new ::bgs::protocol::club::v1::ClubDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetDescriptionResponse.club)
+  return club_;
+}
+inline ::bgs::protocol::club::v1::ClubDescription* GetDescriptionResponse::release_club() {
+  clear_has_club();
+  ::bgs::protocol::club::v1::ClubDescription* temp = club_;
+  club_ = NULL;
+  return temp;
+}
+inline void GetDescriptionResponse::set_allocated_club(::bgs::protocol::club::v1::ClubDescription* club) {
+  delete club_;
+  club_ = club;
+  if (club) {
+    set_has_club();
+  } else {
+    clear_has_club();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetDescriptionResponse.club)
+}
+
+// -------------------------------------------------------------------
+
+// GetClubTypeRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetClubTypeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetClubTypeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetClubTypeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetClubTypeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetClubTypeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetClubTypeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetClubTypeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetClubTypeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetClubTypeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetClubTypeRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetClubTypeRequest.agent_id)
+}
+
+// optional .bgs.protocol.club.v1.UniqueClubType type = 2;
+inline bool GetClubTypeRequest::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetClubTypeRequest::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetClubTypeRequest::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetClubTypeRequest::clear_type() {
+  if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+  clear_has_type();
+}
+inline const ::bgs::protocol::club::v1::UniqueClubType& GetClubTypeRequest::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetClubTypeRequest.type)
+  return type_ != NULL ? *type_ : *default_instance_->type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* GetClubTypeRequest::mutable_type() {
+  set_has_type();
+  if (type_ == NULL) type_ = new ::bgs::protocol::club::v1::UniqueClubType;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetClubTypeRequest.type)
+  return type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* GetClubTypeRequest::release_type() {
+  clear_has_type();
+  ::bgs::protocol::club::v1::UniqueClubType* temp = type_;
+  type_ = NULL;
+  return temp;
+}
+inline void GetClubTypeRequest::set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type) {
+  delete type_;
+  type_ = type;
+  if (type) {
+    set_has_type();
+  } else {
+    clear_has_type();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetClubTypeRequest.type)
+}
+
+// -------------------------------------------------------------------
+
+// GetClubTypeResponse
+
+// optional .bgs.protocol.club.v1.UniqueClubType type = 1;
+inline bool GetClubTypeResponse::has_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetClubTypeResponse::set_has_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetClubTypeResponse::clear_has_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetClubTypeResponse::clear_type() {
+  if (type_ != NULL) type_->::bgs::protocol::club::v1::UniqueClubType::Clear();
+  clear_has_type();
+}
+inline const ::bgs::protocol::club::v1::UniqueClubType& GetClubTypeResponse::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetClubTypeResponse.type)
+  return type_ != NULL ? *type_ : *default_instance_->type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* GetClubTypeResponse::mutable_type() {
+  set_has_type();
+  if (type_ == NULL) type_ = new ::bgs::protocol::club::v1::UniqueClubType;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetClubTypeResponse.type)
+  return type_;
+}
+inline ::bgs::protocol::club::v1::UniqueClubType* GetClubTypeResponse::release_type() {
+  clear_has_type();
+  ::bgs::protocol::club::v1::UniqueClubType* temp = type_;
+  type_ = NULL;
+  return temp;
+}
+inline void GetClubTypeResponse::set_allocated_type(::bgs::protocol::club::v1::UniqueClubType* type) {
+  delete type_;
+  type_ = type;
+  if (type) {
+    set_has_type();
+  } else {
+    clear_has_type();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetClubTypeResponse.type)
+}
+
+// optional .bgs.protocol.club.v1.ClubRoleSet role_set = 2;
+inline bool GetClubTypeResponse::has_role_set() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetClubTypeResponse::set_has_role_set() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetClubTypeResponse::clear_has_role_set() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetClubTypeResponse::clear_role_set() {
+  if (role_set_ != NULL) role_set_->::bgs::protocol::club::v1::ClubRoleSet::Clear();
+  clear_has_role_set();
+}
+inline const ::bgs::protocol::club::v1::ClubRoleSet& GetClubTypeResponse::role_set() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetClubTypeResponse.role_set)
+  return role_set_ != NULL ? *role_set_ : *default_instance_->role_set_;
+}
+inline ::bgs::protocol::club::v1::ClubRoleSet* GetClubTypeResponse::mutable_role_set() {
+  set_has_role_set();
+  if (role_set_ == NULL) role_set_ = new ::bgs::protocol::club::v1::ClubRoleSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetClubTypeResponse.role_set)
+  return role_set_;
+}
+inline ::bgs::protocol::club::v1::ClubRoleSet* GetClubTypeResponse::release_role_set() {
+  clear_has_role_set();
+  ::bgs::protocol::club::v1::ClubRoleSet* temp = role_set_;
+  role_set_ = NULL;
+  return temp;
+}
+inline void GetClubTypeResponse::set_allocated_role_set(::bgs::protocol::club::v1::ClubRoleSet* role_set) {
+  delete role_set_;
+  role_set_ = role_set;
+  if (role_set) {
+    set_has_role_set();
+  } else {
+    clear_has_role_set();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetClubTypeResponse.role_set)
+}
+
+// optional .bgs.protocol.club.v1.ClubTypeRangeSet range_set = 3;
+inline bool GetClubTypeResponse::has_range_set() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetClubTypeResponse::set_has_range_set() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetClubTypeResponse::clear_has_range_set() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetClubTypeResponse::clear_range_set() {
+  if (range_set_ != NULL) range_set_->::bgs::protocol::club::v1::ClubTypeRangeSet::Clear();
+  clear_has_range_set();
+}
+inline const ::bgs::protocol::club::v1::ClubTypeRangeSet& GetClubTypeResponse::range_set() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetClubTypeResponse.range_set)
+  return range_set_ != NULL ? *range_set_ : *default_instance_->range_set_;
+}
+inline ::bgs::protocol::club::v1::ClubTypeRangeSet* GetClubTypeResponse::mutable_range_set() {
+  set_has_range_set();
+  if (range_set_ == NULL) range_set_ = new ::bgs::protocol::club::v1::ClubTypeRangeSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetClubTypeResponse.range_set)
+  return range_set_;
+}
+inline ::bgs::protocol::club::v1::ClubTypeRangeSet* GetClubTypeResponse::release_range_set() {
+  clear_has_range_set();
+  ::bgs::protocol::club::v1::ClubTypeRangeSet* temp = range_set_;
+  range_set_ = NULL;
+  return temp;
+}
+inline void GetClubTypeResponse::set_allocated_range_set(::bgs::protocol::club::v1::ClubTypeRangeSet* range_set) {
+  delete range_set_;
+  range_set_ = range_set;
+  if (range_set) {
+    set_has_range_set();
+  } else {
+    clear_has_range_set();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetClubTypeResponse.range_set)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateClubStateRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool UpdateClubStateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateClubStateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateClubStateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateClubStateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UpdateClubStateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateClubStateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateClubStateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateClubStateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateClubStateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateClubStateRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateClubStateRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool UpdateClubStateRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateClubStateRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateClubStateRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateClubStateRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 UpdateClubStateRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateClubStateRequest.club_id)
+  return club_id_;
+}
+inline void UpdateClubStateRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UpdateClubStateRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubStateOptions options = 3;
+inline bool UpdateClubStateRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateClubStateRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateClubStateRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateClubStateRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::ClubStateOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::ClubStateOptions& UpdateClubStateRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateClubStateRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::ClubStateOptions* UpdateClubStateRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::ClubStateOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateClubStateRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::ClubStateOptions* UpdateClubStateRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::ClubStateOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void UpdateClubStateRequest::set_allocated_options(::bgs::protocol::club::v1::ClubStateOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateClubStateRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateClubSettingsRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool UpdateClubSettingsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateClubSettingsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateClubSettingsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateClubSettingsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UpdateClubSettingsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateClubSettingsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateClubSettingsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateClubSettingsRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateClubSettingsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateClubSettingsRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateClubSettingsRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool UpdateClubSettingsRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateClubSettingsRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateClubSettingsRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateClubSettingsRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 UpdateClubSettingsRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateClubSettingsRequest.club_id)
+  return club_id_;
+}
+inline void UpdateClubSettingsRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UpdateClubSettingsRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.ClubSettingsOptions options = 3;
+inline bool UpdateClubSettingsRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateClubSettingsRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateClubSettingsRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateClubSettingsRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::ClubSettingsOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::ClubSettingsOptions& UpdateClubSettingsRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateClubSettingsRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::ClubSettingsOptions* UpdateClubSettingsRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::ClubSettingsOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateClubSettingsRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::ClubSettingsOptions* UpdateClubSettingsRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::ClubSettingsOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void UpdateClubSettingsRequest::set_allocated_options(::bgs::protocol::club::v1::ClubSettingsOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateClubSettingsRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// JoinRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool JoinRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void JoinRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void JoinRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void JoinRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& JoinRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.JoinRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* JoinRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.JoinRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* JoinRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void JoinRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.JoinRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool JoinRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void JoinRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void JoinRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void JoinRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 JoinRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.JoinRequest.club_id)
+  return club_id_;
+}
+inline void JoinRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.JoinRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.CreateMemberOptions options = 3;
+inline bool JoinRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void JoinRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void JoinRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void JoinRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateMemberOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::CreateMemberOptions& JoinRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.JoinRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::CreateMemberOptions* JoinRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::CreateMemberOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.JoinRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::CreateMemberOptions* JoinRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::CreateMemberOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void JoinRequest::set_allocated_options(::bgs::protocol::club::v1::CreateMemberOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.JoinRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// LeaveRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool LeaveRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void LeaveRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void LeaveRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void LeaveRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& LeaveRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.LeaveRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* LeaveRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.LeaveRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* LeaveRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void LeaveRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.LeaveRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool LeaveRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void LeaveRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void LeaveRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void LeaveRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 LeaveRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.LeaveRequest.club_id)
+  return club_id_;
+}
+inline void LeaveRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.LeaveRequest.club_id)
+}
+
+// -------------------------------------------------------------------
+
+// KickRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool KickRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void KickRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void KickRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void KickRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& KickRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.KickRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* KickRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.KickRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* KickRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void KickRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.KickRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool KickRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void KickRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void KickRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void KickRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 KickRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.KickRequest.club_id)
+  return club_id_;
+}
+inline void KickRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.KickRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId target_id = 3;
+inline bool KickRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void KickRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void KickRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void KickRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& KickRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.KickRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* KickRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.KickRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* KickRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::club::v1::MemberId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void KickRequest::set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.KickRequest.target_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetMemberRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetMemberRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetMemberRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetMemberRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetMemberRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetMemberRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetMemberRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetMemberRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetMemberRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetMemberRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetMemberRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetMemberRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetMemberRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetMemberRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetMemberRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetMemberRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetMemberRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetMemberRequest.club_id)
+  return club_id_;
+}
+inline void GetMemberRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetMemberRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 3;
+inline bool GetMemberRequest::has_member_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetMemberRequest::set_has_member_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetMemberRequest::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetMemberRequest::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetMemberRequest::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetMemberRequest.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetMemberRequest::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetMemberRequest.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetMemberRequest::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void GetMemberRequest::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetMemberRequest.member_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetMemberResponse
+
+// optional .bgs.protocol.club.v1.Member member = 1;
+inline bool GetMemberResponse::has_member() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetMemberResponse::set_has_member() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetMemberResponse::clear_has_member() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetMemberResponse::clear_member() {
+  if (member_ != NULL) member_->::bgs::protocol::club::v1::Member::Clear();
+  clear_has_member();
+}
+inline const ::bgs::protocol::club::v1::Member& GetMemberResponse::member() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetMemberResponse.member)
+  return member_ != NULL ? *member_ : *default_instance_->member_;
+}
+inline ::bgs::protocol::club::v1::Member* GetMemberResponse::mutable_member() {
+  set_has_member();
+  if (member_ == NULL) member_ = new ::bgs::protocol::club::v1::Member;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetMemberResponse.member)
+  return member_;
+}
+inline ::bgs::protocol::club::v1::Member* GetMemberResponse::release_member() {
+  clear_has_member();
+  ::bgs::protocol::club::v1::Member* temp = member_;
+  member_ = NULL;
+  return temp;
+}
+inline void GetMemberResponse::set_allocated_member(::bgs::protocol::club::v1::Member* member) {
+  delete member_;
+  member_ = member;
+  if (member) {
+    set_has_member();
+  } else {
+    clear_has_member();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetMemberResponse.member)
+}
+
+// -------------------------------------------------------------------
+
+// GetMembersRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetMembersRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetMembersRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetMembersRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetMembersRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetMembersRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetMembersRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetMembersRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetMembersRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetMembersRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetMembersRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetMembersRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetMembersRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetMembersRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetMembersRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetMembersRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetMembersRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetMembersRequest.club_id)
+  return club_id_;
+}
+inline void GetMembersRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetMembersRequest.club_id)
+}
+
+// optional uint64 continuation = 4;
+inline bool GetMembersRequest::has_continuation() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetMembersRequest::set_has_continuation() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetMembersRequest::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetMembersRequest::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetMembersRequest::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetMembersRequest.continuation)
+  return continuation_;
+}
+inline void GetMembersRequest::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetMembersRequest.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// GetMembersResponse
+
+// repeated .bgs.protocol.club.v1.Member member = 1;
+inline int GetMembersResponse::member_size() const {
+  return member_.size();
+}
+inline void GetMembersResponse::clear_member() {
+  member_.Clear();
+}
+inline const ::bgs::protocol::club::v1::Member& GetMembersResponse::member(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetMembersResponse.member)
+  return member_.Get(index);
+}
+inline ::bgs::protocol::club::v1::Member* GetMembersResponse::mutable_member(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetMembersResponse.member)
+  return member_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::Member* GetMembersResponse::add_member() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.GetMembersResponse.member)
+  return member_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member >&
+GetMembersResponse::member() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.GetMembersResponse.member)
+  return member_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Member >*
+GetMembersResponse::mutable_member() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.GetMembersResponse.member)
+  return &member_;
+}
+
+// optional uint64 continuation = 2;
+inline bool GetMembersResponse::has_continuation() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetMembersResponse::set_has_continuation() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetMembersResponse::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetMembersResponse::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetMembersResponse::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetMembersResponse.continuation)
+  return continuation_;
+}
+inline void GetMembersResponse::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetMembersResponse.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateMemberStateRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool UpdateMemberStateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateMemberStateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateMemberStateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateMemberStateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UpdateMemberStateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateMemberStateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateMemberStateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateMemberStateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateMemberStateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateMemberStateRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateMemberStateRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool UpdateMemberStateRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateMemberStateRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateMemberStateRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateMemberStateRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 UpdateMemberStateRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateMemberStateRequest.club_id)
+  return club_id_;
+}
+inline void UpdateMemberStateRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UpdateMemberStateRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 3;
+inline bool UpdateMemberStateRequest::has_member_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateMemberStateRequest::set_has_member_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateMemberStateRequest::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateMemberStateRequest::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UpdateMemberStateRequest::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateMemberStateRequest.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateMemberStateRequest::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateMemberStateRequest.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateMemberStateRequest::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void UpdateMemberStateRequest::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateMemberStateRequest.member_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberStateOptions options = 5;
+inline bool UpdateMemberStateRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void UpdateMemberStateRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void UpdateMemberStateRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void UpdateMemberStateRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::MemberStateOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::MemberStateOptions& UpdateMemberStateRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateMemberStateRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::MemberStateOptions* UpdateMemberStateRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::MemberStateOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateMemberStateRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::MemberStateOptions* UpdateMemberStateRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::MemberStateOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void UpdateMemberStateRequest::set_allocated_options(::bgs::protocol::club::v1::MemberStateOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateMemberStateRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateSubscriberStateRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool UpdateSubscriberStateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateSubscriberStateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateSubscriberStateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateSubscriberStateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UpdateSubscriberStateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateSubscriberStateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateSubscriberStateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateSubscriberStateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateSubscriberStateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateSubscriberStateRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateSubscriberStateRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool UpdateSubscriberStateRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateSubscriberStateRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateSubscriberStateRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateSubscriberStateRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 UpdateSubscriberStateRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateSubscriberStateRequest.club_id)
+  return club_id_;
+}
+inline void UpdateSubscriberStateRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UpdateSubscriberStateRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.SubscriberStateOptions options = 3;
+inline bool UpdateSubscriberStateRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateSubscriberStateRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateSubscriberStateRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateSubscriberStateRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::SubscriberStateOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::SubscriberStateOptions& UpdateSubscriberStateRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateSubscriberStateRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::SubscriberStateOptions* UpdateSubscriberStateRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::SubscriberStateOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateSubscriberStateRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::SubscriberStateOptions* UpdateSubscriberStateRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::SubscriberStateOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void UpdateSubscriberStateRequest::set_allocated_options(::bgs::protocol::club::v1::SubscriberStateOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateSubscriberStateRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// AssignRoleRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool AssignRoleRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AssignRoleRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AssignRoleRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AssignRoleRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& AssignRoleRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AssignRoleRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AssignRoleRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AssignRoleRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AssignRoleRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AssignRoleRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AssignRoleRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool AssignRoleRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AssignRoleRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AssignRoleRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AssignRoleRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 AssignRoleRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AssignRoleRequest.club_id)
+  return club_id_;
+}
+inline void AssignRoleRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AssignRoleRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+inline bool AssignRoleRequest::has_assignment() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AssignRoleRequest::set_has_assignment() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AssignRoleRequest::clear_has_assignment() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AssignRoleRequest::clear_assignment() {
+  if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::RoleAssignment::Clear();
+  clear_has_assignment();
+}
+inline const ::bgs::protocol::club::v1::RoleAssignment& AssignRoleRequest::assignment() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AssignRoleRequest.assignment)
+  return assignment_ != NULL ? *assignment_ : *default_instance_->assignment_;
+}
+inline ::bgs::protocol::club::v1::RoleAssignment* AssignRoleRequest::mutable_assignment() {
+  set_has_assignment();
+  if (assignment_ == NULL) assignment_ = new ::bgs::protocol::club::v1::RoleAssignment;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AssignRoleRequest.assignment)
+  return assignment_;
+}
+inline ::bgs::protocol::club::v1::RoleAssignment* AssignRoleRequest::release_assignment() {
+  clear_has_assignment();
+  ::bgs::protocol::club::v1::RoleAssignment* temp = assignment_;
+  assignment_ = NULL;
+  return temp;
+}
+inline void AssignRoleRequest::set_allocated_assignment(::bgs::protocol::club::v1::RoleAssignment* assignment) {
+  delete assignment_;
+  assignment_ = assignment;
+  if (assignment) {
+    set_has_assignment();
+  } else {
+    clear_has_assignment();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AssignRoleRequest.assignment)
+}
+
+// -------------------------------------------------------------------
+
+// UnassignRoleRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool UnassignRoleRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnassignRoleRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnassignRoleRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnassignRoleRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UnassignRoleRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnassignRoleRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnassignRoleRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UnassignRoleRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnassignRoleRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnassignRoleRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UnassignRoleRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool UnassignRoleRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnassignRoleRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnassignRoleRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnassignRoleRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 UnassignRoleRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnassignRoleRequest.club_id)
+  return club_id_;
+}
+inline void UnassignRoleRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UnassignRoleRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.RoleAssignment assignment = 3;
+inline bool UnassignRoleRequest::has_assignment() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UnassignRoleRequest::set_has_assignment() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UnassignRoleRequest::clear_has_assignment() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UnassignRoleRequest::clear_assignment() {
+  if (assignment_ != NULL) assignment_->::bgs::protocol::club::v1::RoleAssignment::Clear();
+  clear_has_assignment();
+}
+inline const ::bgs::protocol::club::v1::RoleAssignment& UnassignRoleRequest::assignment() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnassignRoleRequest.assignment)
+  return assignment_ != NULL ? *assignment_ : *default_instance_->assignment_;
+}
+inline ::bgs::protocol::club::v1::RoleAssignment* UnassignRoleRequest::mutable_assignment() {
+  set_has_assignment();
+  if (assignment_ == NULL) assignment_ = new ::bgs::protocol::club::v1::RoleAssignment;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UnassignRoleRequest.assignment)
+  return assignment_;
+}
+inline ::bgs::protocol::club::v1::RoleAssignment* UnassignRoleRequest::release_assignment() {
+  clear_has_assignment();
+  ::bgs::protocol::club::v1::RoleAssignment* temp = assignment_;
+  assignment_ = NULL;
+  return temp;
+}
+inline void UnassignRoleRequest::set_allocated_assignment(::bgs::protocol::club::v1::RoleAssignment* assignment) {
+  delete assignment_;
+  assignment_ = assignment;
+  if (assignment) {
+    set_has_assignment();
+  } else {
+    clear_has_assignment();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UnassignRoleRequest.assignment)
+}
+
+// -------------------------------------------------------------------
+
+// SendInvitationRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SendInvitationRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendInvitationRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendInvitationRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SendInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SendInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendInvitationRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SendInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SendInvitationRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SendInvitationRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool SendInvitationRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SendInvitationRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SendInvitationRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SendInvitationRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SendInvitationRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendInvitationRequest.club_id)
+  return club_id_;
+}
+inline void SendInvitationRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SendInvitationRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.SendInvitationOptions options = 3;
+inline bool SendInvitationRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SendInvitationRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SendInvitationRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SendInvitationRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::SendInvitationOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::SendInvitationOptions& SendInvitationRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendInvitationRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::SendInvitationOptions* SendInvitationRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::SendInvitationOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendInvitationRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::SendInvitationOptions* SendInvitationRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::SendInvitationOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void SendInvitationRequest::set_allocated_options(::bgs::protocol::club::v1::SendInvitationOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SendInvitationRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// AcceptInvitationRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool AcceptInvitationRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AcceptInvitationRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AcceptInvitationRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AcceptInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& AcceptInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AcceptInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AcceptInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AcceptInvitationRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AcceptInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AcceptInvitationRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AcceptInvitationRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool AcceptInvitationRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AcceptInvitationRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AcceptInvitationRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AcceptInvitationRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 AcceptInvitationRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AcceptInvitationRequest.club_id)
+  return club_id_;
+}
+inline void AcceptInvitationRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AcceptInvitationRequest.club_id)
+}
+
+// optional fixed64 invitation_id = 3;
+inline bool AcceptInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AcceptInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AcceptInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AcceptInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 AcceptInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AcceptInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void AcceptInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AcceptInvitationRequest.invitation_id)
+}
+
+// -------------------------------------------------------------------
+
+// DeclineInvitationRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool DeclineInvitationRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DeclineInvitationRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DeclineInvitationRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DeclineInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& DeclineInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DeclineInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DeclineInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.DeclineInvitationRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DeclineInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void DeclineInvitationRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.DeclineInvitationRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool DeclineInvitationRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DeclineInvitationRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DeclineInvitationRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DeclineInvitationRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 DeclineInvitationRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DeclineInvitationRequest.club_id)
+  return club_id_;
+}
+inline void DeclineInvitationRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DeclineInvitationRequest.club_id)
+}
+
+// optional fixed64 invitation_id = 3;
+inline bool DeclineInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void DeclineInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void DeclineInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void DeclineInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 DeclineInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DeclineInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void DeclineInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DeclineInvitationRequest.invitation_id)
+}
+
+// -------------------------------------------------------------------
+
+// RevokeInvitationRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool RevokeInvitationRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RevokeInvitationRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RevokeInvitationRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RevokeInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& RevokeInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RevokeInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RevokeInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.RevokeInvitationRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RevokeInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void RevokeInvitationRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.RevokeInvitationRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool RevokeInvitationRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RevokeInvitationRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RevokeInvitationRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RevokeInvitationRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 RevokeInvitationRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RevokeInvitationRequest.club_id)
+  return club_id_;
+}
+inline void RevokeInvitationRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.RevokeInvitationRequest.club_id)
+}
+
+// optional fixed64 invitation_id = 3;
+inline bool RevokeInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RevokeInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RevokeInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RevokeInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 RevokeInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RevokeInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void RevokeInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.RevokeInvitationRequest.invitation_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetInvitationRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetInvitationRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetInvitationRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetInvitationRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetInvitationRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetInvitationRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetInvitationRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetInvitationRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetInvitationRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetInvitationRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetInvitationRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetInvitationRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetInvitationRequest.club_id)
+  return club_id_;
+}
+inline void GetInvitationRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetInvitationRequest.club_id)
+}
+
+// optional fixed64 invitation_id = 3;
+inline bool GetInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 GetInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void GetInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetInvitationRequest.invitation_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetInvitationResponse
+
+// optional .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+inline bool GetInvitationResponse::has_invitation() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetInvitationResponse::set_has_invitation() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetInvitationResponse::clear_has_invitation() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetInvitationResponse::clear_invitation() {
+  if (invitation_ != NULL) invitation_->::bgs::protocol::club::v1::ClubInvitation::Clear();
+  clear_has_invitation();
+}
+inline const ::bgs::protocol::club::v1::ClubInvitation& GetInvitationResponse::invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetInvitationResponse.invitation)
+  return invitation_ != NULL ? *invitation_ : *default_instance_->invitation_;
+}
+inline ::bgs::protocol::club::v1::ClubInvitation* GetInvitationResponse::mutable_invitation() {
+  set_has_invitation();
+  if (invitation_ == NULL) invitation_ = new ::bgs::protocol::club::v1::ClubInvitation;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetInvitationResponse.invitation)
+  return invitation_;
+}
+inline ::bgs::protocol::club::v1::ClubInvitation* GetInvitationResponse::release_invitation() {
+  clear_has_invitation();
+  ::bgs::protocol::club::v1::ClubInvitation* temp = invitation_;
+  invitation_ = NULL;
+  return temp;
+}
+inline void GetInvitationResponse::set_allocated_invitation(::bgs::protocol::club::v1::ClubInvitation* invitation) {
+  delete invitation_;
+  invitation_ = invitation;
+  if (invitation) {
+    set_has_invitation();
+  } else {
+    clear_has_invitation();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetInvitationResponse.invitation)
+}
+
+// -------------------------------------------------------------------
+
+// GetInvitationsRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetInvitationsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetInvitationsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetInvitationsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetInvitationsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetInvitationsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetInvitationsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetInvitationsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetInvitationsRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetInvitationsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetInvitationsRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetInvitationsRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetInvitationsRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetInvitationsRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetInvitationsRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetInvitationsRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetInvitationsRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetInvitationsRequest.club_id)
+  return club_id_;
+}
+inline void GetInvitationsRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetInvitationsRequest.club_id)
+}
+
+// optional uint64 continuation = 3;
+inline bool GetInvitationsRequest::has_continuation() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetInvitationsRequest::set_has_continuation() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetInvitationsRequest::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetInvitationsRequest::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetInvitationsRequest::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetInvitationsRequest.continuation)
+  return continuation_;
+}
+inline void GetInvitationsRequest::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetInvitationsRequest.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// GetInvitationsResponse
+
+// repeated .bgs.protocol.club.v1.ClubInvitation invitation = 1;
+inline int GetInvitationsResponse::invitation_size() const {
+  return invitation_.size();
+}
+inline void GetInvitationsResponse::clear_invitation() {
+  invitation_.Clear();
+}
+inline const ::bgs::protocol::club::v1::ClubInvitation& GetInvitationsResponse::invitation(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetInvitationsResponse.invitation)
+  return invitation_.Get(index);
+}
+inline ::bgs::protocol::club::v1::ClubInvitation* GetInvitationsResponse::mutable_invitation(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetInvitationsResponse.invitation)
+  return invitation_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::ClubInvitation* GetInvitationsResponse::add_invitation() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.GetInvitationsResponse.invitation)
+  return invitation_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation >&
+GetInvitationsResponse::invitation() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.GetInvitationsResponse.invitation)
+  return invitation_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubInvitation >*
+GetInvitationsResponse::mutable_invitation() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.GetInvitationsResponse.invitation)
+  return &invitation_;
+}
+
+// optional uint64 continuation = 2;
+inline bool GetInvitationsResponse::has_continuation() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetInvitationsResponse::set_has_continuation() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetInvitationsResponse::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetInvitationsResponse::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetInvitationsResponse::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetInvitationsResponse.continuation)
+  return continuation_;
+}
+inline void GetInvitationsResponse::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetInvitationsResponse.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// SendSuggestionRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SendSuggestionRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendSuggestionRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendSuggestionRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendSuggestionRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SendSuggestionRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendSuggestionRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SendSuggestionRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendSuggestionRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SendSuggestionRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SendSuggestionRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SendSuggestionRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool SendSuggestionRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SendSuggestionRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SendSuggestionRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SendSuggestionRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SendSuggestionRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendSuggestionRequest.club_id)
+  return club_id_;
+}
+inline void SendSuggestionRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SendSuggestionRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.SendSuggestionOptions options = 3;
+inline bool SendSuggestionRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SendSuggestionRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SendSuggestionRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SendSuggestionRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::SendSuggestionOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::SendSuggestionOptions& SendSuggestionRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SendSuggestionRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::SendSuggestionOptions* SendSuggestionRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::SendSuggestionOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SendSuggestionRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::SendSuggestionOptions* SendSuggestionRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::SendSuggestionOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void SendSuggestionRequest::set_allocated_options(::bgs::protocol::club::v1::SendSuggestionOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SendSuggestionRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// AcceptSuggestionRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool AcceptSuggestionRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AcceptSuggestionRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AcceptSuggestionRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AcceptSuggestionRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& AcceptSuggestionRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AcceptSuggestionRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AcceptSuggestionRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AcceptSuggestionRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AcceptSuggestionRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AcceptSuggestionRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AcceptSuggestionRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool AcceptSuggestionRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AcceptSuggestionRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AcceptSuggestionRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AcceptSuggestionRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 AcceptSuggestionRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AcceptSuggestionRequest.club_id)
+  return club_id_;
+}
+inline void AcceptSuggestionRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AcceptSuggestionRequest.club_id)
+}
+
+// optional fixed64 suggestion_id = 3;
+inline bool AcceptSuggestionRequest::has_suggestion_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AcceptSuggestionRequest::set_has_suggestion_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AcceptSuggestionRequest::clear_has_suggestion_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AcceptSuggestionRequest::clear_suggestion_id() {
+  suggestion_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_suggestion_id();
+}
+inline ::google::protobuf::uint64 AcceptSuggestionRequest::suggestion_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AcceptSuggestionRequest.suggestion_id)
+  return suggestion_id_;
+}
+inline void AcceptSuggestionRequest::set_suggestion_id(::google::protobuf::uint64 value) {
+  set_has_suggestion_id();
+  suggestion_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AcceptSuggestionRequest.suggestion_id)
+}
+
+// -------------------------------------------------------------------
+
+// DeclineSuggestionRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool DeclineSuggestionRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DeclineSuggestionRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DeclineSuggestionRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DeclineSuggestionRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& DeclineSuggestionRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DeclineSuggestionRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DeclineSuggestionRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.DeclineSuggestionRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DeclineSuggestionRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void DeclineSuggestionRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.DeclineSuggestionRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool DeclineSuggestionRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DeclineSuggestionRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DeclineSuggestionRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DeclineSuggestionRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 DeclineSuggestionRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DeclineSuggestionRequest.club_id)
+  return club_id_;
+}
+inline void DeclineSuggestionRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DeclineSuggestionRequest.club_id)
+}
+
+// optional fixed64 suggestion_id = 3;
+inline bool DeclineSuggestionRequest::has_suggestion_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void DeclineSuggestionRequest::set_has_suggestion_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void DeclineSuggestionRequest::clear_has_suggestion_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void DeclineSuggestionRequest::clear_suggestion_id() {
+  suggestion_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_suggestion_id();
+}
+inline ::google::protobuf::uint64 DeclineSuggestionRequest::suggestion_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DeclineSuggestionRequest.suggestion_id)
+  return suggestion_id_;
+}
+inline void DeclineSuggestionRequest::set_suggestion_id(::google::protobuf::uint64 value) {
+  set_has_suggestion_id();
+  suggestion_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DeclineSuggestionRequest.suggestion_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetSuggestionRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetSuggestionRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetSuggestionRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetSuggestionRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetSuggestionRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetSuggestionRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetSuggestionRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetSuggestionRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetSuggestionRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetSuggestionRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetSuggestionRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetSuggestionRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetSuggestionRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetSuggestionRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetSuggestionRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetSuggestionRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetSuggestionRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetSuggestionRequest.club_id)
+  return club_id_;
+}
+inline void GetSuggestionRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetSuggestionRequest.club_id)
+}
+
+// optional fixed64 suggestion_id = 3;
+inline bool GetSuggestionRequest::has_suggestion_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetSuggestionRequest::set_has_suggestion_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetSuggestionRequest::clear_has_suggestion_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetSuggestionRequest::clear_suggestion_id() {
+  suggestion_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_suggestion_id();
+}
+inline ::google::protobuf::uint64 GetSuggestionRequest::suggestion_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetSuggestionRequest.suggestion_id)
+  return suggestion_id_;
+}
+inline void GetSuggestionRequest::set_suggestion_id(::google::protobuf::uint64 value) {
+  set_has_suggestion_id();
+  suggestion_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetSuggestionRequest.suggestion_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetSuggestionResponse
+
+// optional .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+inline bool GetSuggestionResponse::has_suggestion() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetSuggestionResponse::set_has_suggestion() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetSuggestionResponse::clear_has_suggestion() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetSuggestionResponse::clear_suggestion() {
+  if (suggestion_ != NULL) suggestion_->::bgs::protocol::club::v1::ClubSuggestion::Clear();
+  clear_has_suggestion();
+}
+inline const ::bgs::protocol::club::v1::ClubSuggestion& GetSuggestionResponse::suggestion() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetSuggestionResponse.suggestion)
+  return suggestion_ != NULL ? *suggestion_ : *default_instance_->suggestion_;
+}
+inline ::bgs::protocol::club::v1::ClubSuggestion* GetSuggestionResponse::mutable_suggestion() {
+  set_has_suggestion();
+  if (suggestion_ == NULL) suggestion_ = new ::bgs::protocol::club::v1::ClubSuggestion;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetSuggestionResponse.suggestion)
+  return suggestion_;
+}
+inline ::bgs::protocol::club::v1::ClubSuggestion* GetSuggestionResponse::release_suggestion() {
+  clear_has_suggestion();
+  ::bgs::protocol::club::v1::ClubSuggestion* temp = suggestion_;
+  suggestion_ = NULL;
+  return temp;
+}
+inline void GetSuggestionResponse::set_allocated_suggestion(::bgs::protocol::club::v1::ClubSuggestion* suggestion) {
+  delete suggestion_;
+  suggestion_ = suggestion;
+  if (suggestion) {
+    set_has_suggestion();
+  } else {
+    clear_has_suggestion();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetSuggestionResponse.suggestion)
+}
+
+// -------------------------------------------------------------------
+
+// GetSuggestionsRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetSuggestionsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetSuggestionsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetSuggestionsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetSuggestionsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetSuggestionsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetSuggestionsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetSuggestionsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetSuggestionsRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetSuggestionsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetSuggestionsRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetSuggestionsRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetSuggestionsRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetSuggestionsRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetSuggestionsRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetSuggestionsRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetSuggestionsRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetSuggestionsRequest.club_id)
+  return club_id_;
+}
+inline void GetSuggestionsRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetSuggestionsRequest.club_id)
+}
+
+// optional uint64 continuation = 3;
+inline bool GetSuggestionsRequest::has_continuation() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetSuggestionsRequest::set_has_continuation() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetSuggestionsRequest::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetSuggestionsRequest::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetSuggestionsRequest::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetSuggestionsRequest.continuation)
+  return continuation_;
+}
+inline void GetSuggestionsRequest::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetSuggestionsRequest.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// GetSuggestionsResponse
+
+// repeated .bgs.protocol.club.v1.ClubSuggestion suggestion = 1;
+inline int GetSuggestionsResponse::suggestion_size() const {
+  return suggestion_.size();
+}
+inline void GetSuggestionsResponse::clear_suggestion() {
+  suggestion_.Clear();
+}
+inline const ::bgs::protocol::club::v1::ClubSuggestion& GetSuggestionsResponse::suggestion(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetSuggestionsResponse.suggestion)
+  return suggestion_.Get(index);
+}
+inline ::bgs::protocol::club::v1::ClubSuggestion* GetSuggestionsResponse::mutable_suggestion(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetSuggestionsResponse.suggestion)
+  return suggestion_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::ClubSuggestion* GetSuggestionsResponse::add_suggestion() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.GetSuggestionsResponse.suggestion)
+  return suggestion_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubSuggestion >&
+GetSuggestionsResponse::suggestion() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.GetSuggestionsResponse.suggestion)
+  return suggestion_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubSuggestion >*
+GetSuggestionsResponse::mutable_suggestion() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.GetSuggestionsResponse.suggestion)
+  return &suggestion_;
+}
+
+// optional uint64 continuation = 2;
+inline bool GetSuggestionsResponse::has_continuation() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetSuggestionsResponse::set_has_continuation() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetSuggestionsResponse::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetSuggestionsResponse::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetSuggestionsResponse::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetSuggestionsResponse.continuation)
+  return continuation_;
+}
+inline void GetSuggestionsResponse::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetSuggestionsResponse.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// CreateTicketRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool CreateTicketRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateTicketRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateTicketRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateTicketRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& CreateTicketRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateTicketRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateTicketRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateTicketRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateTicketRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void CreateTicketRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateTicketRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool CreateTicketRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CreateTicketRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CreateTicketRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CreateTicketRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 CreateTicketRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateTicketRequest.club_id)
+  return club_id_;
+}
+inline void CreateTicketRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateTicketRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.CreateTicketOptions options = 3;
+inline bool CreateTicketRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CreateTicketRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CreateTicketRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CreateTicketRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateTicketOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::CreateTicketOptions& CreateTicketRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateTicketRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::CreateTicketOptions* CreateTicketRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::CreateTicketOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateTicketRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::CreateTicketOptions* CreateTicketRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::CreateTicketOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void CreateTicketRequest::set_allocated_options(::bgs::protocol::club::v1::CreateTicketOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateTicketRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// CreateTicketResponse
+
+// optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+inline bool CreateTicketResponse::has_ticket() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateTicketResponse::set_has_ticket() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateTicketResponse::clear_has_ticket() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateTicketResponse::clear_ticket() {
+  if (ticket_ != NULL) ticket_->::bgs::protocol::club::v1::ClubTicket::Clear();
+  clear_has_ticket();
+}
+inline const ::bgs::protocol::club::v1::ClubTicket& CreateTicketResponse::ticket() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateTicketResponse.ticket)
+  return ticket_ != NULL ? *ticket_ : *default_instance_->ticket_;
+}
+inline ::bgs::protocol::club::v1::ClubTicket* CreateTicketResponse::mutable_ticket() {
+  set_has_ticket();
+  if (ticket_ == NULL) ticket_ = new ::bgs::protocol::club::v1::ClubTicket;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateTicketResponse.ticket)
+  return ticket_;
+}
+inline ::bgs::protocol::club::v1::ClubTicket* CreateTicketResponse::release_ticket() {
+  clear_has_ticket();
+  ::bgs::protocol::club::v1::ClubTicket* temp = ticket_;
+  ticket_ = NULL;
+  return temp;
+}
+inline void CreateTicketResponse::set_allocated_ticket(::bgs::protocol::club::v1::ClubTicket* ticket) {
+  delete ticket_;
+  ticket_ = ticket;
+  if (ticket) {
+    set_has_ticket();
+  } else {
+    clear_has_ticket();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateTicketResponse.ticket)
+}
+
+// -------------------------------------------------------------------
+
+// DestroyTicketRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool DestroyTicketRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DestroyTicketRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DestroyTicketRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DestroyTicketRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& DestroyTicketRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyTicketRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DestroyTicketRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.DestroyTicketRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DestroyTicketRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void DestroyTicketRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.DestroyTicketRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool DestroyTicketRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DestroyTicketRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DestroyTicketRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DestroyTicketRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 DestroyTicketRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyTicketRequest.club_id)
+  return club_id_;
+}
+inline void DestroyTicketRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DestroyTicketRequest.club_id)
+}
+
+// optional string ticket_id = 3;
+inline bool DestroyTicketRequest::has_ticket_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void DestroyTicketRequest::set_has_ticket_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void DestroyTicketRequest::clear_has_ticket_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void DestroyTicketRequest::clear_ticket_id() {
+  if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_->clear();
+  }
+  clear_has_ticket_id();
+}
+inline const ::std::string& DestroyTicketRequest::ticket_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyTicketRequest.ticket_id)
+  return *ticket_id_;
+}
+inline void DestroyTicketRequest::set_ticket_id(const ::std::string& value) {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  ticket_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DestroyTicketRequest.ticket_id)
+}
+inline void DestroyTicketRequest::set_ticket_id(const char* value) {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  ticket_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.DestroyTicketRequest.ticket_id)
+}
+inline void DestroyTicketRequest::set_ticket_id(const char* value, size_t size) {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  ticket_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.DestroyTicketRequest.ticket_id)
+}
+inline ::std::string* DestroyTicketRequest::mutable_ticket_id() {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.DestroyTicketRequest.ticket_id)
+  return ticket_id_;
+}
+inline ::std::string* DestroyTicketRequest::release_ticket_id() {
+  clear_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = ticket_id_;
+    ticket_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void DestroyTicketRequest::set_allocated_ticket_id(::std::string* ticket_id) {
+  if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ticket_id_;
+  }
+  if (ticket_id) {
+    set_has_ticket_id();
+    ticket_id_ = ticket_id;
+  } else {
+    clear_has_ticket_id();
+    ticket_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.DestroyTicketRequest.ticket_id)
+}
+
+// -------------------------------------------------------------------
+
+// RedeemTicketRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool RedeemTicketRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RedeemTicketRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RedeemTicketRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RedeemTicketRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& RedeemTicketRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RedeemTicketRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RedeemTicketRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.RedeemTicketRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RedeemTicketRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void RedeemTicketRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.RedeemTicketRequest.agent_id)
+}
+
+// optional string ticket_id = 3;
+inline bool RedeemTicketRequest::has_ticket_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RedeemTicketRequest::set_has_ticket_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RedeemTicketRequest::clear_has_ticket_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RedeemTicketRequest::clear_ticket_id() {
+  if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_->clear();
+  }
+  clear_has_ticket_id();
+}
+inline const ::std::string& RedeemTicketRequest::ticket_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RedeemTicketRequest.ticket_id)
+  return *ticket_id_;
+}
+inline void RedeemTicketRequest::set_ticket_id(const ::std::string& value) {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  ticket_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.RedeemTicketRequest.ticket_id)
+}
+inline void RedeemTicketRequest::set_ticket_id(const char* value) {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  ticket_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.RedeemTicketRequest.ticket_id)
+}
+inline void RedeemTicketRequest::set_ticket_id(const char* value, size_t size) {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  ticket_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.RedeemTicketRequest.ticket_id)
+}
+inline ::std::string* RedeemTicketRequest::mutable_ticket_id() {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.RedeemTicketRequest.ticket_id)
+  return ticket_id_;
+}
+inline ::std::string* RedeemTicketRequest::release_ticket_id() {
+  clear_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = ticket_id_;
+    ticket_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void RedeemTicketRequest::set_allocated_ticket_id(::std::string* ticket_id) {
+  if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ticket_id_;
+  }
+  if (ticket_id) {
+    set_has_ticket_id();
+    ticket_id_ = ticket_id;
+  } else {
+    clear_has_ticket_id();
+    ticket_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.RedeemTicketRequest.ticket_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetTicketRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetTicketRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetTicketRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetTicketRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetTicketRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetTicketRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetTicketRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetTicketRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetTicketRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetTicketRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetTicketRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetTicketRequest.agent_id)
+}
+
+// optional string ticket_id = 3;
+inline bool GetTicketRequest::has_ticket_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetTicketRequest::set_has_ticket_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetTicketRequest::clear_has_ticket_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetTicketRequest::clear_ticket_id() {
+  if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_->clear();
+  }
+  clear_has_ticket_id();
+}
+inline const ::std::string& GetTicketRequest::ticket_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetTicketRequest.ticket_id)
+  return *ticket_id_;
+}
+inline void GetTicketRequest::set_ticket_id(const ::std::string& value) {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  ticket_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetTicketRequest.ticket_id)
+}
+inline void GetTicketRequest::set_ticket_id(const char* value) {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  ticket_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.GetTicketRequest.ticket_id)
+}
+inline void GetTicketRequest::set_ticket_id(const char* value, size_t size) {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  ticket_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.GetTicketRequest.ticket_id)
+}
+inline ::std::string* GetTicketRequest::mutable_ticket_id() {
+  set_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ticket_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetTicketRequest.ticket_id)
+  return ticket_id_;
+}
+inline ::std::string* GetTicketRequest::release_ticket_id() {
+  clear_has_ticket_id();
+  if (ticket_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = ticket_id_;
+    ticket_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GetTicketRequest::set_allocated_ticket_id(::std::string* ticket_id) {
+  if (ticket_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ticket_id_;
+  }
+  if (ticket_id) {
+    set_has_ticket_id();
+    ticket_id_ = ticket_id;
+  } else {
+    clear_has_ticket_id();
+    ticket_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetTicketRequest.ticket_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetTicketResponse
+
+// optional .bgs.protocol.club.v1.ClubTicket ticket = 1;
+inline bool GetTicketResponse::has_ticket() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetTicketResponse::set_has_ticket() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetTicketResponse::clear_has_ticket() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetTicketResponse::clear_ticket() {
+  if (ticket_ != NULL) ticket_->::bgs::protocol::club::v1::ClubTicket::Clear();
+  clear_has_ticket();
+}
+inline const ::bgs::protocol::club::v1::ClubTicket& GetTicketResponse::ticket() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetTicketResponse.ticket)
+  return ticket_ != NULL ? *ticket_ : *default_instance_->ticket_;
+}
+inline ::bgs::protocol::club::v1::ClubTicket* GetTicketResponse::mutable_ticket() {
+  set_has_ticket();
+  if (ticket_ == NULL) ticket_ = new ::bgs::protocol::club::v1::ClubTicket;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetTicketResponse.ticket)
+  return ticket_;
+}
+inline ::bgs::protocol::club::v1::ClubTicket* GetTicketResponse::release_ticket() {
+  clear_has_ticket();
+  ::bgs::protocol::club::v1::ClubTicket* temp = ticket_;
+  ticket_ = NULL;
+  return temp;
+}
+inline void GetTicketResponse::set_allocated_ticket(::bgs::protocol::club::v1::ClubTicket* ticket) {
+  delete ticket_;
+  ticket_ = ticket;
+  if (ticket) {
+    set_has_ticket();
+  } else {
+    clear_has_ticket();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetTicketResponse.ticket)
+}
+
+// -------------------------------------------------------------------
+
+// GetTicketsRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetTicketsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetTicketsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetTicketsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetTicketsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetTicketsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetTicketsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetTicketsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetTicketsRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetTicketsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetTicketsRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetTicketsRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetTicketsRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetTicketsRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetTicketsRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetTicketsRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetTicketsRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetTicketsRequest.club_id)
+  return club_id_;
+}
+inline void GetTicketsRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetTicketsRequest.club_id)
+}
+
+// optional uint64 continuation = 3;
+inline bool GetTicketsRequest::has_continuation() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetTicketsRequest::set_has_continuation() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetTicketsRequest::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetTicketsRequest::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetTicketsRequest::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetTicketsRequest.continuation)
+  return continuation_;
+}
+inline void GetTicketsRequest::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetTicketsRequest.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// GetTicketsResponse
+
+// repeated .bgs.protocol.club.v1.ClubTicket ticket = 1;
+inline int GetTicketsResponse::ticket_size() const {
+  return ticket_.size();
+}
+inline void GetTicketsResponse::clear_ticket() {
+  ticket_.Clear();
+}
+inline const ::bgs::protocol::club::v1::ClubTicket& GetTicketsResponse::ticket(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetTicketsResponse.ticket)
+  return ticket_.Get(index);
+}
+inline ::bgs::protocol::club::v1::ClubTicket* GetTicketsResponse::mutable_ticket(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetTicketsResponse.ticket)
+  return ticket_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::ClubTicket* GetTicketsResponse::add_ticket() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.GetTicketsResponse.ticket)
+  return ticket_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubTicket >&
+GetTicketsResponse::ticket() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.GetTicketsResponse.ticket)
+  return ticket_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubTicket >*
+GetTicketsResponse::mutable_ticket() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.GetTicketsResponse.ticket)
+  return &ticket_;
+}
+
+// optional uint64 continuation = 2;
+inline bool GetTicketsResponse::has_continuation() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetTicketsResponse::set_has_continuation() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetTicketsResponse::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetTicketsResponse::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetTicketsResponse::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetTicketsResponse.continuation)
+  return continuation_;
+}
+inline void GetTicketsResponse::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetTicketsResponse.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// AddBanRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool AddBanRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AddBanRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AddBanRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AddBanRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& AddBanRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AddBanRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AddBanRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AddBanRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AddBanRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AddBanRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AddBanRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool AddBanRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AddBanRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AddBanRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AddBanRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 AddBanRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AddBanRequest.club_id)
+  return club_id_;
+}
+inline void AddBanRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AddBanRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.AddBanOptions options = 3;
+inline bool AddBanRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AddBanRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AddBanRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AddBanRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::AddBanOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::AddBanOptions& AddBanRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AddBanRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::AddBanOptions* AddBanRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::AddBanOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AddBanRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::AddBanOptions* AddBanRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::AddBanOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void AddBanRequest::set_allocated_options(::bgs::protocol::club::v1::AddBanOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AddBanRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// RemoveBanRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool RemoveBanRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RemoveBanRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RemoveBanRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RemoveBanRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& RemoveBanRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RemoveBanRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RemoveBanRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.RemoveBanRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RemoveBanRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void RemoveBanRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.RemoveBanRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool RemoveBanRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RemoveBanRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RemoveBanRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RemoveBanRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 RemoveBanRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RemoveBanRequest.club_id)
+  return club_id_;
+}
+inline void RemoveBanRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.RemoveBanRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId target_id = 3;
+inline bool RemoveBanRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RemoveBanRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RemoveBanRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RemoveBanRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& RemoveBanRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.RemoveBanRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RemoveBanRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.RemoveBanRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* RemoveBanRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::club::v1::MemberId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void RemoveBanRequest::set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.RemoveBanRequest.target_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetBanRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetBanRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetBanRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetBanRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetBanRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetBanRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetBanRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetBanRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetBanRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetBanRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetBanRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetBanRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetBanRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetBanRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetBanRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetBanRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetBanRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetBanRequest.club_id)
+  return club_id_;
+}
+inline void GetBanRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetBanRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId target_id = 3;
+inline bool GetBanRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetBanRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetBanRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetBanRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetBanRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetBanRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetBanRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetBanRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetBanRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::club::v1::MemberId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void GetBanRequest::set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetBanRequest.target_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetBanResponse
+
+// optional .bgs.protocol.club.v1.ClubBan ban = 1;
+inline bool GetBanResponse::has_ban() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetBanResponse::set_has_ban() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetBanResponse::clear_has_ban() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetBanResponse::clear_ban() {
+  if (ban_ != NULL) ban_->::bgs::protocol::club::v1::ClubBan::Clear();
+  clear_has_ban();
+}
+inline const ::bgs::protocol::club::v1::ClubBan& GetBanResponse::ban() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetBanResponse.ban)
+  return ban_ != NULL ? *ban_ : *default_instance_->ban_;
+}
+inline ::bgs::protocol::club::v1::ClubBan* GetBanResponse::mutable_ban() {
+  set_has_ban();
+  if (ban_ == NULL) ban_ = new ::bgs::protocol::club::v1::ClubBan;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetBanResponse.ban)
+  return ban_;
+}
+inline ::bgs::protocol::club::v1::ClubBan* GetBanResponse::release_ban() {
+  clear_has_ban();
+  ::bgs::protocol::club::v1::ClubBan* temp = ban_;
+  ban_ = NULL;
+  return temp;
+}
+inline void GetBanResponse::set_allocated_ban(::bgs::protocol::club::v1::ClubBan* ban) {
+  delete ban_;
+  ban_ = ban;
+  if (ban) {
+    set_has_ban();
+  } else {
+    clear_has_ban();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetBanResponse.ban)
+}
+
+// -------------------------------------------------------------------
+
+// GetBansRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetBansRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetBansRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetBansRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetBansRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetBansRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetBansRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetBansRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetBansRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetBansRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetBansRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetBansRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetBansRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetBansRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetBansRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetBansRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetBansRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetBansRequest.club_id)
+  return club_id_;
+}
+inline void GetBansRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetBansRequest.club_id)
+}
+
+// optional uint64 continuation = 3;
+inline bool GetBansRequest::has_continuation() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetBansRequest::set_has_continuation() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetBansRequest::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetBansRequest::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetBansRequest::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetBansRequest.continuation)
+  return continuation_;
+}
+inline void GetBansRequest::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetBansRequest.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// GetBansResponse
+
+// repeated .bgs.protocol.club.v1.ClubBan ban = 1;
+inline int GetBansResponse::ban_size() const {
+  return ban_.size();
+}
+inline void GetBansResponse::clear_ban() {
+  ban_.Clear();
+}
+inline const ::bgs::protocol::club::v1::ClubBan& GetBansResponse::ban(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetBansResponse.ban)
+  return ban_.Get(index);
+}
+inline ::bgs::protocol::club::v1::ClubBan* GetBansResponse::mutable_ban(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetBansResponse.ban)
+  return ban_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::ClubBan* GetBansResponse::add_ban() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.GetBansResponse.ban)
+  return ban_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubBan >&
+GetBansResponse::ban() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.GetBansResponse.ban)
+  return ban_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubBan >*
+GetBansResponse::mutable_ban() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.GetBansResponse.ban)
+  return &ban_;
+}
+
+// optional uint64 continuation = 2;
+inline bool GetBansResponse::has_continuation() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetBansResponse::set_has_continuation() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetBansResponse::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetBansResponse::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetBansResponse::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetBansResponse.continuation)
+  return continuation_;
+}
+inline void GetBansResponse::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetBansResponse.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// SubscribeStreamRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SubscribeStreamRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeStreamRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeStreamRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeStreamRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SubscribeStreamRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeStreamRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscribeStreamRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SubscribeStreamRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SubscribeStreamRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SubscribeStreamRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SubscribeStreamRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool SubscribeStreamRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscribeStreamRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscribeStreamRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscribeStreamRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SubscribeStreamRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeStreamRequest.club_id)
+  return club_id_;
+}
+inline void SubscribeStreamRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SubscribeStreamRequest.club_id)
+}
+
+// repeated uint64 stream_id = 3;
+inline int SubscribeStreamRequest::stream_id_size() const {
+  return stream_id_.size();
+}
+inline void SubscribeStreamRequest::clear_stream_id() {
+  stream_id_.Clear();
+}
+inline ::google::protobuf::uint64 SubscribeStreamRequest::stream_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SubscribeStreamRequest.stream_id)
+  return stream_id_.Get(index);
+}
+inline void SubscribeStreamRequest::set_stream_id(int index, ::google::protobuf::uint64 value) {
+  stream_id_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SubscribeStreamRequest.stream_id)
+}
+inline void SubscribeStreamRequest::add_stream_id(::google::protobuf::uint64 value) {
+  stream_id_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.SubscribeStreamRequest.stream_id)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+SubscribeStreamRequest::stream_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.SubscribeStreamRequest.stream_id)
+  return stream_id_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+SubscribeStreamRequest::mutable_stream_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.SubscribeStreamRequest.stream_id)
+  return &stream_id_;
+}
+
+// -------------------------------------------------------------------
+
+// UnsubscribeStreamRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool UnsubscribeStreamRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsubscribeStreamRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsubscribeStreamRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsubscribeStreamRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UnsubscribeStreamRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnsubscribeStreamRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnsubscribeStreamRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UnsubscribeStreamRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UnsubscribeStreamRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeStreamRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UnsubscribeStreamRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool UnsubscribeStreamRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnsubscribeStreamRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnsubscribeStreamRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnsubscribeStreamRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 UnsubscribeStreamRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnsubscribeStreamRequest.club_id)
+  return club_id_;
+}
+inline void UnsubscribeStreamRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UnsubscribeStreamRequest.club_id)
+}
+
+// repeated uint64 stream_id = 3;
+inline int UnsubscribeStreamRequest::stream_id_size() const {
+  return stream_id_.size();
+}
+inline void UnsubscribeStreamRequest::clear_stream_id() {
+  stream_id_.Clear();
+}
+inline ::google::protobuf::uint64 UnsubscribeStreamRequest::stream_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UnsubscribeStreamRequest.stream_id)
+  return stream_id_.Get(index);
+}
+inline void UnsubscribeStreamRequest::set_stream_id(int index, ::google::protobuf::uint64 value) {
+  stream_id_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UnsubscribeStreamRequest.stream_id)
+}
+inline void UnsubscribeStreamRequest::add_stream_id(::google::protobuf::uint64 value) {
+  stream_id_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.UnsubscribeStreamRequest.stream_id)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+UnsubscribeStreamRequest::stream_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.UnsubscribeStreamRequest.stream_id)
+  return stream_id_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+UnsubscribeStreamRequest::mutable_stream_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.UnsubscribeStreamRequest.stream_id)
+  return &stream_id_;
+}
+
+// -------------------------------------------------------------------
+
+// CreateStreamRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool CreateStreamRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateStreamRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateStreamRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateStreamRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& CreateStreamRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateStreamRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateStreamRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateStreamRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateStreamRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void CreateStreamRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateStreamRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool CreateStreamRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CreateStreamRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CreateStreamRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CreateStreamRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 CreateStreamRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateStreamRequest.club_id)
+  return club_id_;
+}
+inline void CreateStreamRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateStreamRequest.club_id)
+}
+
+// optional .bgs.protocol.club.v1.CreateStreamOptions options = 3;
+inline bool CreateStreamRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CreateStreamRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CreateStreamRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CreateStreamRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateStreamOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::CreateStreamOptions& CreateStreamRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateStreamRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::CreateStreamOptions* CreateStreamRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::CreateStreamOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateStreamRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::CreateStreamOptions* CreateStreamRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::CreateStreamOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void CreateStreamRequest::set_allocated_options(::bgs::protocol::club::v1::CreateStreamOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateStreamRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// DestroyStreamRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool DestroyStreamRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DestroyStreamRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DestroyStreamRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DestroyStreamRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& DestroyStreamRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyStreamRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DestroyStreamRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.DestroyStreamRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DestroyStreamRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void DestroyStreamRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.DestroyStreamRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool DestroyStreamRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DestroyStreamRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DestroyStreamRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DestroyStreamRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 DestroyStreamRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyStreamRequest.club_id)
+  return club_id_;
+}
+inline void DestroyStreamRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DestroyStreamRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool DestroyStreamRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void DestroyStreamRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void DestroyStreamRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void DestroyStreamRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 DestroyStreamRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyStreamRequest.stream_id)
+  return stream_id_;
+}
+inline void DestroyStreamRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DestroyStreamRequest.stream_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetStreamRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetStreamRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetStreamRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetStreamRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetStreamRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetStreamRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetStreamRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetStreamRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetStreamRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetStreamRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetStreamRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetStreamRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetStreamRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetStreamRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamRequest.club_id)
+  return club_id_;
+}
+inline void GetStreamRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool GetStreamRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetStreamRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetStreamRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetStreamRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 GetStreamRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamRequest.stream_id)
+  return stream_id_;
+}
+inline void GetStreamRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamRequest.stream_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamResponse
+
+// optional .bgs.protocol.club.v1.Stream stream = 1;
+inline bool GetStreamResponse::has_stream() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetStreamResponse::set_has_stream() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetStreamResponse::clear_has_stream() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetStreamResponse::clear_stream() {
+  if (stream_ != NULL) stream_->::bgs::protocol::club::v1::Stream::Clear();
+  clear_has_stream();
+}
+inline const ::bgs::protocol::club::v1::Stream& GetStreamResponse::stream() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamResponse.stream)
+  return stream_ != NULL ? *stream_ : *default_instance_->stream_;
+}
+inline ::bgs::protocol::club::v1::Stream* GetStreamResponse::mutable_stream() {
+  set_has_stream();
+  if (stream_ == NULL) stream_ = new ::bgs::protocol::club::v1::Stream;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamResponse.stream)
+  return stream_;
+}
+inline ::bgs::protocol::club::v1::Stream* GetStreamResponse::release_stream() {
+  clear_has_stream();
+  ::bgs::protocol::club::v1::Stream* temp = stream_;
+  stream_ = NULL;
+  return temp;
+}
+inline void GetStreamResponse::set_allocated_stream(::bgs::protocol::club::v1::Stream* stream) {
+  delete stream_;
+  stream_ = stream;
+  if (stream) {
+    set_has_stream();
+  } else {
+    clear_has_stream();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetStreamResponse.stream)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamsRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetStreamsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetStreamsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetStreamsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetStreamsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetStreamsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetStreamsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamsRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetStreamsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetStreamsRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetStreamsRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetStreamsRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetStreamsRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetStreamsRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetStreamsRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetStreamsRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamsRequest.club_id)
+  return club_id_;
+}
+inline void GetStreamsRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamsRequest.club_id)
+}
+
+// optional uint64 continuation = 3;
+inline bool GetStreamsRequest::has_continuation() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetStreamsRequest::set_has_continuation() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetStreamsRequest::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetStreamsRequest::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetStreamsRequest::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamsRequest.continuation)
+  return continuation_;
+}
+inline void GetStreamsRequest::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamsRequest.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamsResponse
+
+// repeated .bgs.protocol.club.v1.Stream stream = 1;
+inline int GetStreamsResponse::stream_size() const {
+  return stream_.size();
+}
+inline void GetStreamsResponse::clear_stream() {
+  stream_.Clear();
+}
+inline const ::bgs::protocol::club::v1::Stream& GetStreamsResponse::stream(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamsResponse.stream)
+  return stream_.Get(index);
+}
+inline ::bgs::protocol::club::v1::Stream* GetStreamsResponse::mutable_stream(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamsResponse.stream)
+  return stream_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::Stream* GetStreamsResponse::add_stream() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.GetStreamsResponse.stream)
+  return stream_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Stream >&
+GetStreamsResponse::stream() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.GetStreamsResponse.stream)
+  return stream_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::Stream >*
+GetStreamsResponse::mutable_stream() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.GetStreamsResponse.stream)
+  return &stream_;
+}
+
+// repeated .bgs.protocol.club.v1.StreamView view = 2;
+inline int GetStreamsResponse::view_size() const {
+  return view_.size();
+}
+inline void GetStreamsResponse::clear_view() {
+  view_.Clear();
+}
+inline const ::bgs::protocol::club::v1::StreamView& GetStreamsResponse::view(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamsResponse.view)
+  return view_.Get(index);
+}
+inline ::bgs::protocol::club::v1::StreamView* GetStreamsResponse::mutable_view(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamsResponse.view)
+  return view_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::StreamView* GetStreamsResponse::add_view() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.GetStreamsResponse.view)
+  return view_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamView >&
+GetStreamsResponse::view() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.GetStreamsResponse.view)
+  return view_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamView >*
+GetStreamsResponse::mutable_view() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.GetStreamsResponse.view)
+  return &view_;
+}
+
+// optional uint64 continuation = 3;
+inline bool GetStreamsResponse::has_continuation() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetStreamsResponse::set_has_continuation() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetStreamsResponse::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetStreamsResponse::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetStreamsResponse::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamsResponse.continuation)
+  return continuation_;
+}
+inline void GetStreamsResponse::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamsResponse.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateStreamStateRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool UpdateStreamStateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateStreamStateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateStreamStateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateStreamStateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& UpdateStreamStateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateStreamStateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateStreamStateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateStreamStateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* UpdateStreamStateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateStreamStateRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateStreamStateRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool UpdateStreamStateRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateStreamStateRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateStreamStateRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateStreamStateRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 UpdateStreamStateRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateStreamStateRequest.club_id)
+  return club_id_;
+}
+inline void UpdateStreamStateRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UpdateStreamStateRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool UpdateStreamStateRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateStreamStateRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateStreamStateRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateStreamStateRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 UpdateStreamStateRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateStreamStateRequest.stream_id)
+  return stream_id_;
+}
+inline void UpdateStreamStateRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.UpdateStreamStateRequest.stream_id)
+}
+
+// optional .bgs.protocol.club.v1.StreamStateOptions options = 5;
+inline bool UpdateStreamStateRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void UpdateStreamStateRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void UpdateStreamStateRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void UpdateStreamStateRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::StreamStateOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::StreamStateOptions& UpdateStreamStateRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.UpdateStreamStateRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::StreamStateOptions* UpdateStreamStateRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::StreamStateOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.UpdateStreamStateRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::StreamStateOptions* UpdateStreamStateRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::StreamStateOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void UpdateStreamStateRequest::set_allocated_options(::bgs::protocol::club::v1::StreamStateOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.UpdateStreamStateRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// SetStreamFocusRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SetStreamFocusRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SetStreamFocusRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SetStreamFocusRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SetStreamFocusRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SetStreamFocusRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetStreamFocusRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SetStreamFocusRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SetStreamFocusRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SetStreamFocusRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SetStreamFocusRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SetStreamFocusRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool SetStreamFocusRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SetStreamFocusRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SetStreamFocusRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SetStreamFocusRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SetStreamFocusRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetStreamFocusRequest.club_id)
+  return club_id_;
+}
+inline void SetStreamFocusRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SetStreamFocusRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool SetStreamFocusRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SetStreamFocusRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SetStreamFocusRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SetStreamFocusRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 SetStreamFocusRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetStreamFocusRequest.stream_id)
+  return stream_id_;
+}
+inline void SetStreamFocusRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SetStreamFocusRequest.stream_id)
+}
+
+// optional bool focus = 4;
+inline bool SetStreamFocusRequest::has_focus() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SetStreamFocusRequest::set_has_focus() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SetStreamFocusRequest::clear_has_focus() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SetStreamFocusRequest::clear_focus() {
+  focus_ = false;
+  clear_has_focus();
+}
+inline bool SetStreamFocusRequest::focus() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetStreamFocusRequest.focus)
+  return focus_;
+}
+inline void SetStreamFocusRequest::set_focus(bool value) {
+  set_has_focus();
+  focus_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SetStreamFocusRequest.focus)
+}
+
+// -------------------------------------------------------------------
+
+// CreateMessageRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool CreateMessageRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateMessageRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateMessageRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateMessageRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& CreateMessageRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateMessageRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateMessageRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateMessageRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* CreateMessageRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void CreateMessageRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateMessageRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool CreateMessageRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CreateMessageRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CreateMessageRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CreateMessageRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 CreateMessageRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateMessageRequest.club_id)
+  return club_id_;
+}
+inline void CreateMessageRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateMessageRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool CreateMessageRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CreateMessageRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CreateMessageRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CreateMessageRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 CreateMessageRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateMessageRequest.stream_id)
+  return stream_id_;
+}
+inline void CreateMessageRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateMessageRequest.stream_id)
+}
+
+// optional .bgs.protocol.club.v1.CreateMessageOptions options = 4;
+inline bool CreateMessageRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void CreateMessageRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void CreateMessageRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void CreateMessageRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateMessageOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::CreateMessageOptions& CreateMessageRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateMessageRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::CreateMessageOptions* CreateMessageRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::CreateMessageOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateMessageRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::CreateMessageOptions* CreateMessageRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::CreateMessageOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void CreateMessageRequest::set_allocated_options(::bgs::protocol::club::v1::CreateMessageOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateMessageRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// CreateMessageResponse
+
+// optional .bgs.protocol.club.v1.StreamMessage message = 1;
+inline bool CreateMessageResponse::has_message() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateMessageResponse::set_has_message() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateMessageResponse::clear_has_message() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateMessageResponse::clear_message() {
+  if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+  clear_has_message();
+}
+inline const ::bgs::protocol::club::v1::StreamMessage& CreateMessageResponse::message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateMessageResponse.message)
+  return message_ != NULL ? *message_ : *default_instance_->message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* CreateMessageResponse::mutable_message() {
+  set_has_message();
+  if (message_ == NULL) message_ = new ::bgs::protocol::club::v1::StreamMessage;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateMessageResponse.message)
+  return message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* CreateMessageResponse::release_message() {
+  clear_has_message();
+  ::bgs::protocol::club::v1::StreamMessage* temp = message_;
+  message_ = NULL;
+  return temp;
+}
+inline void CreateMessageResponse::set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message) {
+  delete message_;
+  message_ = message;
+  if (message) {
+    set_has_message();
+  } else {
+    clear_has_message();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateMessageResponse.message)
+}
+
+// -------------------------------------------------------------------
+
+// DestroyMessageRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool DestroyMessageRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DestroyMessageRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DestroyMessageRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DestroyMessageRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& DestroyMessageRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyMessageRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DestroyMessageRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.DestroyMessageRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* DestroyMessageRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void DestroyMessageRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.DestroyMessageRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool DestroyMessageRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DestroyMessageRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DestroyMessageRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DestroyMessageRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 DestroyMessageRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyMessageRequest.club_id)
+  return club_id_;
+}
+inline void DestroyMessageRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DestroyMessageRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool DestroyMessageRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void DestroyMessageRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void DestroyMessageRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void DestroyMessageRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 DestroyMessageRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyMessageRequest.stream_id)
+  return stream_id_;
+}
+inline void DestroyMessageRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.DestroyMessageRequest.stream_id)
+}
+
+// optional .bgs.protocol.MessageId message_id = 4;
+inline bool DestroyMessageRequest::has_message_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void DestroyMessageRequest::set_has_message_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void DestroyMessageRequest::clear_has_message_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void DestroyMessageRequest::clear_message_id() {
+  if (message_id_ != NULL) message_id_->::bgs::protocol::MessageId::Clear();
+  clear_has_message_id();
+}
+inline const ::bgs::protocol::MessageId& DestroyMessageRequest::message_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyMessageRequest.message_id)
+  return message_id_ != NULL ? *message_id_ : *default_instance_->message_id_;
+}
+inline ::bgs::protocol::MessageId* DestroyMessageRequest::mutable_message_id() {
+  set_has_message_id();
+  if (message_id_ == NULL) message_id_ = new ::bgs::protocol::MessageId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.DestroyMessageRequest.message_id)
+  return message_id_;
+}
+inline ::bgs::protocol::MessageId* DestroyMessageRequest::release_message_id() {
+  clear_has_message_id();
+  ::bgs::protocol::MessageId* temp = message_id_;
+  message_id_ = NULL;
+  return temp;
+}
+inline void DestroyMessageRequest::set_allocated_message_id(::bgs::protocol::MessageId* message_id) {
+  delete message_id_;
+  message_id_ = message_id;
+  if (message_id) {
+    set_has_message_id();
+  } else {
+    clear_has_message_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.DestroyMessageRequest.message_id)
+}
+
+// -------------------------------------------------------------------
+
+// DestroyMessageResponse
+
+// optional .bgs.protocol.club.v1.StreamMessage message = 1;
+inline bool DestroyMessageResponse::has_message() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DestroyMessageResponse::set_has_message() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DestroyMessageResponse::clear_has_message() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DestroyMessageResponse::clear_message() {
+  if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+  clear_has_message();
+}
+inline const ::bgs::protocol::club::v1::StreamMessage& DestroyMessageResponse::message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.DestroyMessageResponse.message)
+  return message_ != NULL ? *message_ : *default_instance_->message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* DestroyMessageResponse::mutable_message() {
+  set_has_message();
+  if (message_ == NULL) message_ = new ::bgs::protocol::club::v1::StreamMessage;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.DestroyMessageResponse.message)
+  return message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* DestroyMessageResponse::release_message() {
+  clear_has_message();
+  ::bgs::protocol::club::v1::StreamMessage* temp = message_;
+  message_ = NULL;
+  return temp;
+}
+inline void DestroyMessageResponse::set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message) {
+  delete message_;
+  message_ = message;
+  if (message) {
+    set_has_message();
+  } else {
+    clear_has_message();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.DestroyMessageResponse.message)
+}
+
+// -------------------------------------------------------------------
+
+// EditMessageRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool EditMessageRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EditMessageRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EditMessageRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EditMessageRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& EditMessageRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.EditMessageRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* EditMessageRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.EditMessageRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* EditMessageRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void EditMessageRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.EditMessageRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool EditMessageRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EditMessageRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EditMessageRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EditMessageRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 EditMessageRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.EditMessageRequest.club_id)
+  return club_id_;
+}
+inline void EditMessageRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.EditMessageRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool EditMessageRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void EditMessageRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void EditMessageRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void EditMessageRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 EditMessageRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.EditMessageRequest.stream_id)
+  return stream_id_;
+}
+inline void EditMessageRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.EditMessageRequest.stream_id)
+}
+
+// optional .bgs.protocol.MessageId message_id = 4;
+inline bool EditMessageRequest::has_message_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void EditMessageRequest::set_has_message_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void EditMessageRequest::clear_has_message_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void EditMessageRequest::clear_message_id() {
+  if (message_id_ != NULL) message_id_->::bgs::protocol::MessageId::Clear();
+  clear_has_message_id();
+}
+inline const ::bgs::protocol::MessageId& EditMessageRequest::message_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.EditMessageRequest.message_id)
+  return message_id_ != NULL ? *message_id_ : *default_instance_->message_id_;
+}
+inline ::bgs::protocol::MessageId* EditMessageRequest::mutable_message_id() {
+  set_has_message_id();
+  if (message_id_ == NULL) message_id_ = new ::bgs::protocol::MessageId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.EditMessageRequest.message_id)
+  return message_id_;
+}
+inline ::bgs::protocol::MessageId* EditMessageRequest::release_message_id() {
+  clear_has_message_id();
+  ::bgs::protocol::MessageId* temp = message_id_;
+  message_id_ = NULL;
+  return temp;
+}
+inline void EditMessageRequest::set_allocated_message_id(::bgs::protocol::MessageId* message_id) {
+  delete message_id_;
+  message_id_ = message_id;
+  if (message_id) {
+    set_has_message_id();
+  } else {
+    clear_has_message_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.EditMessageRequest.message_id)
+}
+
+// optional .bgs.protocol.club.v1.CreateMessageOptions options = 5;
+inline bool EditMessageRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void EditMessageRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void EditMessageRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void EditMessageRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::club::v1::CreateMessageOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::club::v1::CreateMessageOptions& EditMessageRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.EditMessageRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::club::v1::CreateMessageOptions* EditMessageRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::club::v1::CreateMessageOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.EditMessageRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::club::v1::CreateMessageOptions* EditMessageRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::club::v1::CreateMessageOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void EditMessageRequest::set_allocated_options(::bgs::protocol::club::v1::CreateMessageOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.EditMessageRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// EditMessageResponse
+
+// optional .bgs.protocol.club.v1.StreamMessage message = 1;
+inline bool EditMessageResponse::has_message() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EditMessageResponse::set_has_message() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EditMessageResponse::clear_has_message() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EditMessageResponse::clear_message() {
+  if (message_ != NULL) message_->::bgs::protocol::club::v1::StreamMessage::Clear();
+  clear_has_message();
+}
+inline const ::bgs::protocol::club::v1::StreamMessage& EditMessageResponse::message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.EditMessageResponse.message)
+  return message_ != NULL ? *message_ : *default_instance_->message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* EditMessageResponse::mutable_message() {
+  set_has_message();
+  if (message_ == NULL) message_ = new ::bgs::protocol::club::v1::StreamMessage;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.EditMessageResponse.message)
+  return message_;
+}
+inline ::bgs::protocol::club::v1::StreamMessage* EditMessageResponse::release_message() {
+  clear_has_message();
+  ::bgs::protocol::club::v1::StreamMessage* temp = message_;
+  message_ = NULL;
+  return temp;
+}
+inline void EditMessageResponse::set_allocated_message(::bgs::protocol::club::v1::StreamMessage* message) {
+  delete message_;
+  message_ = message;
+  if (message) {
+    set_has_message();
+  } else {
+    clear_has_message();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.EditMessageResponse.message)
+}
+
+// -------------------------------------------------------------------
+
+// SetMessagePinnedRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SetMessagePinnedRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SetMessagePinnedRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SetMessagePinnedRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SetMessagePinnedRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SetMessagePinnedRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetMessagePinnedRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SetMessagePinnedRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SetMessagePinnedRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SetMessagePinnedRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SetMessagePinnedRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SetMessagePinnedRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool SetMessagePinnedRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SetMessagePinnedRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SetMessagePinnedRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SetMessagePinnedRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SetMessagePinnedRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetMessagePinnedRequest.club_id)
+  return club_id_;
+}
+inline void SetMessagePinnedRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SetMessagePinnedRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool SetMessagePinnedRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SetMessagePinnedRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SetMessagePinnedRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SetMessagePinnedRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 SetMessagePinnedRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetMessagePinnedRequest.stream_id)
+  return stream_id_;
+}
+inline void SetMessagePinnedRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SetMessagePinnedRequest.stream_id)
+}
+
+// -------------------------------------------------------------------
+
+// SetTypingIndicatorRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool SetTypingIndicatorRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SetTypingIndicatorRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SetTypingIndicatorRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SetTypingIndicatorRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& SetTypingIndicatorRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetTypingIndicatorRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SetTypingIndicatorRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.SetTypingIndicatorRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* SetTypingIndicatorRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SetTypingIndicatorRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.SetTypingIndicatorRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool SetTypingIndicatorRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SetTypingIndicatorRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SetTypingIndicatorRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SetTypingIndicatorRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 SetTypingIndicatorRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetTypingIndicatorRequest.club_id)
+  return club_id_;
+}
+inline void SetTypingIndicatorRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SetTypingIndicatorRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool SetTypingIndicatorRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SetTypingIndicatorRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SetTypingIndicatorRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SetTypingIndicatorRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 SetTypingIndicatorRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetTypingIndicatorRequest.stream_id)
+  return stream_id_;
+}
+inline void SetTypingIndicatorRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SetTypingIndicatorRequest.stream_id)
+}
+
+// optional .bgs.protocol.TypingIndicator indicator = 4;
+inline bool SetTypingIndicatorRequest::has_indicator() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SetTypingIndicatorRequest::set_has_indicator() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SetTypingIndicatorRequest::clear_has_indicator() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SetTypingIndicatorRequest::clear_indicator() {
+  indicator_ = 0;
+  clear_has_indicator();
+}
+inline ::bgs::protocol::TypingIndicator SetTypingIndicatorRequest::indicator() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.SetTypingIndicatorRequest.indicator)
+  return static_cast< ::bgs::protocol::TypingIndicator >(indicator_);
+}
+inline void SetTypingIndicatorRequest::set_indicator(::bgs::protocol::TypingIndicator value) {
+  assert(::bgs::protocol::TypingIndicator_IsValid(value));
+  set_has_indicator();
+  indicator_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.SetTypingIndicatorRequest.indicator)
+}
+
+// -------------------------------------------------------------------
+
+// AdvanceStreamViewTimeRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool AdvanceStreamViewTimeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AdvanceStreamViewTimeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AdvanceStreamViewTimeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AdvanceStreamViewTimeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& AdvanceStreamViewTimeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AdvanceStreamViewTimeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AdvanceStreamViewTimeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AdvanceStreamViewTimeRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool AdvanceStreamViewTimeRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AdvanceStreamViewTimeRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AdvanceStreamViewTimeRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AdvanceStreamViewTimeRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 AdvanceStreamViewTimeRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.club_id)
+  return club_id_;
+}
+inline void AdvanceStreamViewTimeRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.club_id)
+}
+
+// optional uint64 stream_id_deprecated = 3 [deprecated = true];
+inline bool AdvanceStreamViewTimeRequest::has_stream_id_deprecated() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AdvanceStreamViewTimeRequest::set_has_stream_id_deprecated() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AdvanceStreamViewTimeRequest::clear_has_stream_id_deprecated() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AdvanceStreamViewTimeRequest::clear_stream_id_deprecated() {
+  stream_id_deprecated_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id_deprecated();
+}
+inline ::google::protobuf::uint64 AdvanceStreamViewTimeRequest::stream_id_deprecated() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.stream_id_deprecated)
+  return stream_id_deprecated_;
+}
+inline void AdvanceStreamViewTimeRequest::set_stream_id_deprecated(::google::protobuf::uint64 value) {
+  set_has_stream_id_deprecated();
+  stream_id_deprecated_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.stream_id_deprecated)
+}
+
+// repeated uint64 stream_id = 4 [packed = true];
+inline int AdvanceStreamViewTimeRequest::stream_id_size() const {
+  return stream_id_.size();
+}
+inline void AdvanceStreamViewTimeRequest::clear_stream_id() {
+  stream_id_.Clear();
+}
+inline ::google::protobuf::uint64 AdvanceStreamViewTimeRequest::stream_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.stream_id)
+  return stream_id_.Get(index);
+}
+inline void AdvanceStreamViewTimeRequest::set_stream_id(int index, ::google::protobuf::uint64 value) {
+  stream_id_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.stream_id)
+}
+inline void AdvanceStreamViewTimeRequest::add_stream_id(::google::protobuf::uint64 value) {
+  stream_id_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.stream_id)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+AdvanceStreamViewTimeRequest::stream_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.stream_id)
+  return stream_id_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+AdvanceStreamViewTimeRequest::mutable_stream_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.AdvanceStreamViewTimeRequest.stream_id)
+  return &stream_id_;
+}
+
+// -------------------------------------------------------------------
+
+// AdvanceStreamMentionViewTimeRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool AdvanceStreamMentionViewTimeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AdvanceStreamMentionViewTimeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AdvanceStreamMentionViewTimeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AdvanceStreamMentionViewTimeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& AdvanceStreamMentionViewTimeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AdvanceStreamMentionViewTimeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AdvanceStreamMentionViewTimeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AdvanceStreamMentionViewTimeRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool AdvanceStreamMentionViewTimeRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AdvanceStreamMentionViewTimeRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AdvanceStreamMentionViewTimeRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AdvanceStreamMentionViewTimeRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 AdvanceStreamMentionViewTimeRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest.club_id)
+  return club_id_;
+}
+inline void AdvanceStreamMentionViewTimeRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool AdvanceStreamMentionViewTimeRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AdvanceStreamMentionViewTimeRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AdvanceStreamMentionViewTimeRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AdvanceStreamMentionViewTimeRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 AdvanceStreamMentionViewTimeRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest.stream_id)
+  return stream_id_;
+}
+inline void AdvanceStreamMentionViewTimeRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AdvanceStreamMentionViewTimeRequest.stream_id)
+}
+
+// -------------------------------------------------------------------
+
+// AdvanceActivityViewTimeRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool AdvanceActivityViewTimeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AdvanceActivityViewTimeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AdvanceActivityViewTimeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AdvanceActivityViewTimeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& AdvanceActivityViewTimeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AdvanceActivityViewTimeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* AdvanceActivityViewTimeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AdvanceActivityViewTimeRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool AdvanceActivityViewTimeRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AdvanceActivityViewTimeRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AdvanceActivityViewTimeRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AdvanceActivityViewTimeRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 AdvanceActivityViewTimeRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest.club_id)
+  return club_id_;
+}
+inline void AdvanceActivityViewTimeRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.AdvanceActivityViewTimeRequest.club_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamHistoryRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetStreamHistoryRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetStreamHistoryRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetStreamHistoryRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetStreamHistoryRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetStreamHistoryRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamHistoryRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetStreamHistoryRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamHistoryRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetStreamHistoryRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetStreamHistoryRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetStreamHistoryRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetStreamHistoryRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetStreamHistoryRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetStreamHistoryRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetStreamHistoryRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetStreamHistoryRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamHistoryRequest.club_id)
+  return club_id_;
+}
+inline void GetStreamHistoryRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamHistoryRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool GetStreamHistoryRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetStreamHistoryRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetStreamHistoryRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetStreamHistoryRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 GetStreamHistoryRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamHistoryRequest.stream_id)
+  return stream_id_;
+}
+inline void GetStreamHistoryRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamHistoryRequest.stream_id)
+}
+
+// optional .bgs.protocol.GetEventOptions options = 4;
+inline bool GetStreamHistoryRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GetStreamHistoryRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GetStreamHistoryRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GetStreamHistoryRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::GetEventOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::GetEventOptions& GetStreamHistoryRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamHistoryRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::GetEventOptions* GetStreamHistoryRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::GetEventOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamHistoryRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::GetEventOptions* GetStreamHistoryRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::GetEventOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void GetStreamHistoryRequest::set_allocated_options(::bgs::protocol::GetEventOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetStreamHistoryRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamHistoryResponse
+
+// repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+inline int GetStreamHistoryResponse::message_size() const {
+  return message_.size();
+}
+inline void GetStreamHistoryResponse::clear_message() {
+  message_.Clear();
+}
+inline const ::bgs::protocol::club::v1::StreamMessage& GetStreamHistoryResponse::message(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamHistoryResponse.message)
+  return message_.Get(index);
+}
+inline ::bgs::protocol::club::v1::StreamMessage* GetStreamHistoryResponse::mutable_message(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamHistoryResponse.message)
+  return message_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::StreamMessage* GetStreamHistoryResponse::add_message() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.GetStreamHistoryResponse.message)
+  return message_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage >&
+GetStreamHistoryResponse::message() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.GetStreamHistoryResponse.message)
+  return message_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage >*
+GetStreamHistoryResponse::mutable_message() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.GetStreamHistoryResponse.message)
+  return &message_;
+}
+
+// optional uint64 continuation = 2;
+inline bool GetStreamHistoryResponse::has_continuation() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetStreamHistoryResponse::set_has_continuation() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetStreamHistoryResponse::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetStreamHistoryResponse::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetStreamHistoryResponse::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamHistoryResponse.continuation)
+  return continuation_;
+}
+inline void GetStreamHistoryResponse::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamHistoryResponse.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// GetClubActivityRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetClubActivityRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetClubActivityRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetClubActivityRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetClubActivityRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetClubActivityRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetClubActivityRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetClubActivityRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetClubActivityRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetClubActivityRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetClubActivityRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetClubActivityRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetClubActivityRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetClubActivityRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetClubActivityRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetClubActivityRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetClubActivityRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetClubActivityRequest.club_id)
+  return club_id_;
+}
+inline void GetClubActivityRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetClubActivityRequest.club_id)
+}
+
+// optional .bgs.protocol.GetEventOptions options = 3;
+inline bool GetClubActivityRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetClubActivityRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetClubActivityRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetClubActivityRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::GetEventOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::GetEventOptions& GetClubActivityRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetClubActivityRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::GetEventOptions* GetClubActivityRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::GetEventOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetClubActivityRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::GetEventOptions* GetClubActivityRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::GetEventOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void GetClubActivityRequest::set_allocated_options(::bgs::protocol::GetEventOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetClubActivityRequest.options)
+}
+
+// -------------------------------------------------------------------
+
+// GetClubActivityResponse
+
+// optional uint64 continuation = 2;
+inline bool GetClubActivityResponse::has_continuation() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetClubActivityResponse::set_has_continuation() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetClubActivityResponse::clear_has_continuation() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetClubActivityResponse::clear_continuation() {
+  continuation_ = GOOGLE_ULONGLONG(0);
+  clear_has_continuation();
+}
+inline ::google::protobuf::uint64 GetClubActivityResponse::continuation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetClubActivityResponse.continuation)
+  return continuation_;
+}
+inline void GetClubActivityResponse::set_continuation(::google::protobuf::uint64 value) {
+  set_has_continuation();
+  continuation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetClubActivityResponse.continuation)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamVoiceTokenRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool GetStreamVoiceTokenRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetStreamVoiceTokenRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetStreamVoiceTokenRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetStreamVoiceTokenRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& GetStreamVoiceTokenRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamVoiceTokenRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetStreamVoiceTokenRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamVoiceTokenRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* GetStreamVoiceTokenRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetStreamVoiceTokenRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetStreamVoiceTokenRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool GetStreamVoiceTokenRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetStreamVoiceTokenRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetStreamVoiceTokenRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetStreamVoiceTokenRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 GetStreamVoiceTokenRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamVoiceTokenRequest.club_id)
+  return club_id_;
+}
+inline void GetStreamVoiceTokenRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamVoiceTokenRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool GetStreamVoiceTokenRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetStreamVoiceTokenRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetStreamVoiceTokenRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetStreamVoiceTokenRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 GetStreamVoiceTokenRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamVoiceTokenRequest.stream_id)
+  return stream_id_;
+}
+inline void GetStreamVoiceTokenRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamVoiceTokenRequest.stream_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetStreamVoiceTokenResponse
+
+// optional string channel_uri = 1;
+inline bool GetStreamVoiceTokenResponse::has_channel_uri() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetStreamVoiceTokenResponse::set_has_channel_uri() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetStreamVoiceTokenResponse::clear_has_channel_uri() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetStreamVoiceTokenResponse::clear_channel_uri() {
+  if (channel_uri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_uri_->clear();
+  }
+  clear_has_channel_uri();
+}
+inline const ::std::string& GetStreamVoiceTokenResponse::channel_uri() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamVoiceTokenResponse.channel_uri)
+  return *channel_uri_;
+}
+inline void GetStreamVoiceTokenResponse::set_channel_uri(const ::std::string& value) {
+  set_has_channel_uri();
+  if (channel_uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_uri_ = new ::std::string;
+  }
+  channel_uri_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.GetStreamVoiceTokenResponse.channel_uri)
+}
+inline void GetStreamVoiceTokenResponse::set_channel_uri(const char* value) {
+  set_has_channel_uri();
+  if (channel_uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_uri_ = new ::std::string;
+  }
+  channel_uri_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.GetStreamVoiceTokenResponse.channel_uri)
+}
+inline void GetStreamVoiceTokenResponse::set_channel_uri(const char* value, size_t size) {
+  set_has_channel_uri();
+  if (channel_uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_uri_ = new ::std::string;
+  }
+  channel_uri_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.GetStreamVoiceTokenResponse.channel_uri)
+}
+inline ::std::string* GetStreamVoiceTokenResponse::mutable_channel_uri() {
+  set_has_channel_uri();
+  if (channel_uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_uri_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamVoiceTokenResponse.channel_uri)
+  return channel_uri_;
+}
+inline ::std::string* GetStreamVoiceTokenResponse::release_channel_uri() {
+  clear_has_channel_uri();
+  if (channel_uri_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = channel_uri_;
+    channel_uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GetStreamVoiceTokenResponse::set_allocated_channel_uri(::std::string* channel_uri) {
+  if (channel_uri_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete channel_uri_;
+  }
+  if (channel_uri) {
+    set_has_channel_uri();
+    channel_uri_ = channel_uri;
+  } else {
+    clear_has_channel_uri();
+    channel_uri_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetStreamVoiceTokenResponse.channel_uri)
+}
+
+// optional .bgs.protocol.VoiceCredentials credentials = 2;
+inline bool GetStreamVoiceTokenResponse::has_credentials() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetStreamVoiceTokenResponse::set_has_credentials() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetStreamVoiceTokenResponse::clear_has_credentials() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetStreamVoiceTokenResponse::clear_credentials() {
+  if (credentials_ != NULL) credentials_->::bgs::protocol::VoiceCredentials::Clear();
+  clear_has_credentials();
+}
+inline const ::bgs::protocol::VoiceCredentials& GetStreamVoiceTokenResponse::credentials() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.GetStreamVoiceTokenResponse.credentials)
+  return credentials_ != NULL ? *credentials_ : *default_instance_->credentials_;
+}
+inline ::bgs::protocol::VoiceCredentials* GetStreamVoiceTokenResponse::mutable_credentials() {
+  set_has_credentials();
+  if (credentials_ == NULL) credentials_ = new ::bgs::protocol::VoiceCredentials;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.GetStreamVoiceTokenResponse.credentials)
+  return credentials_;
+}
+inline ::bgs::protocol::VoiceCredentials* GetStreamVoiceTokenResponse::release_credentials() {
+  clear_has_credentials();
+  ::bgs::protocol::VoiceCredentials* temp = credentials_;
+  credentials_ = NULL;
+  return temp;
+}
+inline void GetStreamVoiceTokenResponse::set_allocated_credentials(::bgs::protocol::VoiceCredentials* credentials) {
+  delete credentials_;
+  credentials_ = credentials;
+  if (credentials) {
+    set_has_credentials();
+  } else {
+    clear_has_credentials();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.GetStreamVoiceTokenResponse.credentials)
+}
+
+// -------------------------------------------------------------------
+
+// KickFromStreamVoiceRequest
+
+// optional .bgs.protocol.club.v1.MemberId agent_id = 1;
+inline bool KickFromStreamVoiceRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void KickFromStreamVoiceRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void KickFromStreamVoiceRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void KickFromStreamVoiceRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& KickFromStreamVoiceRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.KickFromStreamVoiceRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* KickFromStreamVoiceRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.KickFromStreamVoiceRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* KickFromStreamVoiceRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::club::v1::MemberId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void KickFromStreamVoiceRequest::set_allocated_agent_id(::bgs::protocol::club::v1::MemberId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.KickFromStreamVoiceRequest.agent_id)
+}
+
+// optional uint64 club_id = 2;
+inline bool KickFromStreamVoiceRequest::has_club_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void KickFromStreamVoiceRequest::set_has_club_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void KickFromStreamVoiceRequest::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void KickFromStreamVoiceRequest::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 KickFromStreamVoiceRequest::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.KickFromStreamVoiceRequest.club_id)
+  return club_id_;
+}
+inline void KickFromStreamVoiceRequest::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.KickFromStreamVoiceRequest.club_id)
+}
+
+// optional uint64 stream_id = 3;
+inline bool KickFromStreamVoiceRequest::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void KickFromStreamVoiceRequest::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void KickFromStreamVoiceRequest::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void KickFromStreamVoiceRequest::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 KickFromStreamVoiceRequest::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.KickFromStreamVoiceRequest.stream_id)
+  return stream_id_;
+}
+inline void KickFromStreamVoiceRequest::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.KickFromStreamVoiceRequest.stream_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId target_id = 4;
+inline bool KickFromStreamVoiceRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void KickFromStreamVoiceRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void KickFromStreamVoiceRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void KickFromStreamVoiceRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& KickFromStreamVoiceRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.KickFromStreamVoiceRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* KickFromStreamVoiceRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.KickFromStreamVoiceRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* KickFromStreamVoiceRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::club::v1::MemberId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void KickFromStreamVoiceRequest::set_allocated_target_id(::bgs::protocol::club::v1::MemberId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.KickFromStreamVoiceRequest.target_id)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5frequest_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_role.pb.cc b/src/server/proto/Client/club_role.pb.cc
new file mode 100644
index 00000000000..538765634c8
--- /dev/null
+++ b/src/server/proto/Client/club_role.pb.cc
@@ -0,0 +1,2967 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_role.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_role.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ClubPrivilegeSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubPrivilegeSet_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubRole_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubRole_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubRoleSet_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubRoleSet_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5frole_2eproto() {
+  protobuf_AddDesc_club_5frole_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_role.proto");
+  GOOGLE_CHECK(file != NULL);
+  ClubPrivilegeSet_descriptor_ = file->message_type(0);
+  static const int ClubPrivilegeSet_offsets_[47] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_destroy_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_avatar_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_broadcast_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_privacy_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_kick_member_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_own_member_attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_other_member_attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_own_voice_state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_own_presence_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_own_whisper_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_own_member_note_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_other_member_note_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_use_voice_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_voice_mute_member_for_all_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_get_invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_send_invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_send_guest_invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_revoke_own_invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_revoke_other_invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_get_suggestion_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_suggest_member_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_approve_member_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_get_ticket_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_create_ticket_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_destroy_ticket_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_get_ban_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_add_ban_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_remove_ban_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_create_stream_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_destroy_stream_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_stream_position_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_stream_attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_stream_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_stream_subject_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_stream_access_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_set_stream_voice_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_create_message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_destroy_own_message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_destroy_other_message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_edit_own_message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_pin_message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_mention_all_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_mention_here_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, can_mention_member_),
+  };
+  ClubPrivilegeSet_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubPrivilegeSet_descriptor_,
+      ClubPrivilegeSet::default_instance_,
+      ClubPrivilegeSet_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubPrivilegeSet, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubPrivilegeSet));
+  ClubRole_descriptor_ = file->message_type(1);
+  static const int ClubRole_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRole, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRole, state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRole, privilege_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRole, always_grant_stream_access_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRole, allow_in_club_slot_),
+  };
+  ClubRole_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubRole_descriptor_,
+      ClubRole::default_instance_,
+      ClubRole_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRole, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRole, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubRole));
+  ClubRoleSet_descriptor_ = file->message_type(2);
+  static const int ClubRoleSet_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRoleSet, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRoleSet, default_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRoleSet, assignment_respects_relegation_chain_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRoleSet, subtype_),
+  };
+  ClubRoleSet_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubRoleSet_descriptor_,
+      ClubRoleSet::default_instance_,
+      ClubRoleSet_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRoleSet, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubRoleSet, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubRoleSet));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5frole_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubPrivilegeSet_descriptor_, &ClubPrivilegeSet::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubRole_descriptor_, &ClubRole::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubRoleSet_descriptor_, &ClubRoleSet::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5frole_2eproto() {
+  delete ClubPrivilegeSet::default_instance_;
+  delete ClubPrivilegeSet_reflection_;
+  delete ClubRole::default_instance_;
+  delete ClubRole_reflection_;
+  delete ClubRoleSet::default_instance_;
+  delete ClubRoleSet_reflection_;
+}
+
+void protobuf_AddDesc_club_5frole_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_role_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\017club_role.proto\022\024bgs.protocol.club.v1\032"
+    "\020role_types.proto\"\224\013\n\020ClubPrivilegeSet\022\023"
+    "\n\013can_destroy\030\001 \001(\010\022\031\n\021can_set_attribute"
+    "\030\n \001(\010\022\024\n\014can_set_name\030\013 \001(\010\022\033\n\023can_set_"
+    "description\030\014 \001(\010\022\026\n\016can_set_avatar\030\r \001("
+    "\010\022\031\n\021can_set_broadcast\030\016 \001(\010\022\035\n\025can_set_"
+    "privacy_level\030\017 \001(\010\022\027\n\017can_kick_member\030\036"
+    " \001(\010\022$\n\034can_set_own_member_attribute\030\037 \001"
+    "(\010\022&\n\036can_set_other_member_attribute\030  \001"
+    "(\010\022\037\n\027can_set_own_voice_state\030! \001(\010\022\"\n\032c"
+    "an_set_own_presence_level\030\" \001(\010\022!\n\031can_s"
+    "et_own_whisper_level\030# \001(\010\022\037\n\027can_set_ow"
+    "n_member_note\030$ \001(\010\022!\n\031can_set_other_mem"
+    "ber_note\030% \001(\010\022\025\n\rcan_use_voice\0302 \001(\010\022%\n"
+    "\035can_voice_mute_member_for_all\0303 \001(\010\022\032\n\022"
+    "can_get_invitation\030F \001(\010\022\033\n\023can_send_inv"
+    "itation\030G \001(\010\022!\n\031can_send_guest_invitati"
+    "on\030H \001(\010\022!\n\031can_revoke_own_invitation\030I "
+    "\001(\010\022#\n\033can_revoke_other_invitation\030J \001(\010"
+    "\022\032\n\022can_get_suggestion\030Z \001(\010\022\032\n\022can_sugg"
+    "est_member\030[ \001(\010\022\032\n\022can_approve_member\030\\"
+    " \001(\010\022\026\n\016can_get_ticket\030n \001(\010\022\031\n\021can_crea"
+    "te_ticket\030o \001(\010\022\032\n\022can_destroy_ticket\030p "
+    "\001(\010\022\024\n\013can_get_ban\030\202\001 \001(\010\022\024\n\013can_add_ban"
+    "\030\203\001 \001(\010\022\027\n\016can_remove_ban\030\204\001 \001(\010\022\032\n\021can_"
+    "create_stream\030\214\001 \001(\010\022\033\n\022can_destroy_stre"
+    "am\030\215\001 \001(\010\022 \n\027can_set_stream_position\030\216\001 "
+    "\001(\010\022!\n\030can_set_stream_attribute\030\217\001 \001(\010\022\034"
+    "\n\023can_set_stream_name\030\220\001 \001(\010\022\037\n\026can_set_"
+    "stream_subject\030\221\001 \001(\010\022\036\n\025can_set_stream_"
+    "access\030\222\001 \001(\010\022#\n\032can_set_stream_voice_le"
+    "vel\030\223\001 \001(\010\022\033\n\022can_create_message\030\264\001 \001(\010\022"
+    " \n\027can_destroy_own_message\030\265\001 \001(\010\022\"\n\031can"
+    "_destroy_other_message\030\266\001 \001(\010\022\035\n\024can_edi"
+    "t_own_message\030\267\001 \001(\010\022\030\n\017can_pin_message\030"
+    "\270\001 \001(\010\022\030\n\017can_mention_all\030\271\001 \001(\010\022\031\n\020can_"
+    "mention_here\030\272\001 \001(\010\022\033\n\022can_mention_membe"
+    "r\030\273\001 \001(\010\"\271\001\n\010ClubRole\022\n\n\002id\030\001 \001(\r\022&\n\005sta"
+    "te\030\002 \001(\0132\027.bgs.protocol.RoleState\0229\n\tpri"
+    "vilege\030\003 \001(\0132&.bgs.protocol.club.v1.Club"
+    "PrivilegeSet\022\"\n\032always_grant_stream_acce"
+    "ss\030\004 \001(\010\022\032\n\022allow_in_club_slot\030\005 \001(\010\"\224\001\n"
+    "\013ClubRoleSet\022,\n\004role\030\001 \003(\0132\036.bgs.protoco"
+    "l.club.v1.ClubRole\022\030\n\014default_role\030\005 \003(\r"
+    "B\002\020\001\022,\n$assignment_respects_relegation_c"
+    "hain\030\006 \001(\010\022\017\n\007subtype\030\007 \001(\tB\002H\001", 1831);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_role.proto", &protobuf_RegisterTypes);
+  ClubPrivilegeSet::default_instance_ = new ClubPrivilegeSet();
+  ClubRole::default_instance_ = new ClubRole();
+  ClubRoleSet::default_instance_ = new ClubRoleSet();
+  ClubPrivilegeSet::default_instance_->InitAsDefaultInstance();
+  ClubRole::default_instance_->InitAsDefaultInstance();
+  ClubRoleSet::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5frole_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5frole_2eproto {
+  StaticDescriptorInitializer_club_5frole_2eproto() {
+    protobuf_AddDesc_club_5frole_2eproto();
+  }
+} static_descriptor_initializer_club_5frole_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubPrivilegeSet::kCanDestroyFieldNumber;
+const int ClubPrivilegeSet::kCanSetAttributeFieldNumber;
+const int ClubPrivilegeSet::kCanSetNameFieldNumber;
+const int ClubPrivilegeSet::kCanSetDescriptionFieldNumber;
+const int ClubPrivilegeSet::kCanSetAvatarFieldNumber;
+const int ClubPrivilegeSet::kCanSetBroadcastFieldNumber;
+const int ClubPrivilegeSet::kCanSetPrivacyLevelFieldNumber;
+const int ClubPrivilegeSet::kCanKickMemberFieldNumber;
+const int ClubPrivilegeSet::kCanSetOwnMemberAttributeFieldNumber;
+const int ClubPrivilegeSet::kCanSetOtherMemberAttributeFieldNumber;
+const int ClubPrivilegeSet::kCanSetOwnVoiceStateFieldNumber;
+const int ClubPrivilegeSet::kCanSetOwnPresenceLevelFieldNumber;
+const int ClubPrivilegeSet::kCanSetOwnWhisperLevelFieldNumber;
+const int ClubPrivilegeSet::kCanSetOwnMemberNoteFieldNumber;
+const int ClubPrivilegeSet::kCanSetOtherMemberNoteFieldNumber;
+const int ClubPrivilegeSet::kCanUseVoiceFieldNumber;
+const int ClubPrivilegeSet::kCanVoiceMuteMemberForAllFieldNumber;
+const int ClubPrivilegeSet::kCanGetInvitationFieldNumber;
+const int ClubPrivilegeSet::kCanSendInvitationFieldNumber;
+const int ClubPrivilegeSet::kCanSendGuestInvitationFieldNumber;
+const int ClubPrivilegeSet::kCanRevokeOwnInvitationFieldNumber;
+const int ClubPrivilegeSet::kCanRevokeOtherInvitationFieldNumber;
+const int ClubPrivilegeSet::kCanGetSuggestionFieldNumber;
+const int ClubPrivilegeSet::kCanSuggestMemberFieldNumber;
+const int ClubPrivilegeSet::kCanApproveMemberFieldNumber;
+const int ClubPrivilegeSet::kCanGetTicketFieldNumber;
+const int ClubPrivilegeSet::kCanCreateTicketFieldNumber;
+const int ClubPrivilegeSet::kCanDestroyTicketFieldNumber;
+const int ClubPrivilegeSet::kCanGetBanFieldNumber;
+const int ClubPrivilegeSet::kCanAddBanFieldNumber;
+const int ClubPrivilegeSet::kCanRemoveBanFieldNumber;
+const int ClubPrivilegeSet::kCanCreateStreamFieldNumber;
+const int ClubPrivilegeSet::kCanDestroyStreamFieldNumber;
+const int ClubPrivilegeSet::kCanSetStreamPositionFieldNumber;
+const int ClubPrivilegeSet::kCanSetStreamAttributeFieldNumber;
+const int ClubPrivilegeSet::kCanSetStreamNameFieldNumber;
+const int ClubPrivilegeSet::kCanSetStreamSubjectFieldNumber;
+const int ClubPrivilegeSet::kCanSetStreamAccessFieldNumber;
+const int ClubPrivilegeSet::kCanSetStreamVoiceLevelFieldNumber;
+const int ClubPrivilegeSet::kCanCreateMessageFieldNumber;
+const int ClubPrivilegeSet::kCanDestroyOwnMessageFieldNumber;
+const int ClubPrivilegeSet::kCanDestroyOtherMessageFieldNumber;
+const int ClubPrivilegeSet::kCanEditOwnMessageFieldNumber;
+const int ClubPrivilegeSet::kCanPinMessageFieldNumber;
+const int ClubPrivilegeSet::kCanMentionAllFieldNumber;
+const int ClubPrivilegeSet::kCanMentionHereFieldNumber;
+const int ClubPrivilegeSet::kCanMentionMemberFieldNumber;
+#endif  // !_MSC_VER
+
+ClubPrivilegeSet::ClubPrivilegeSet()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubPrivilegeSet)
+}
+
+void ClubPrivilegeSet::InitAsDefaultInstance() {
+}
+
+ClubPrivilegeSet::ClubPrivilegeSet(const ClubPrivilegeSet& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubPrivilegeSet)
+}
+
+void ClubPrivilegeSet::SharedCtor() {
+  _cached_size_ = 0;
+  can_destroy_ = false;
+  can_set_attribute_ = false;
+  can_set_name_ = false;
+  can_set_description_ = false;
+  can_set_avatar_ = false;
+  can_set_broadcast_ = false;
+  can_set_privacy_level_ = false;
+  can_kick_member_ = false;
+  can_set_own_member_attribute_ = false;
+  can_set_other_member_attribute_ = false;
+  can_set_own_voice_state_ = false;
+  can_set_own_presence_level_ = false;
+  can_set_own_whisper_level_ = false;
+  can_set_own_member_note_ = false;
+  can_set_other_member_note_ = false;
+  can_use_voice_ = false;
+  can_voice_mute_member_for_all_ = false;
+  can_get_invitation_ = false;
+  can_send_invitation_ = false;
+  can_send_guest_invitation_ = false;
+  can_revoke_own_invitation_ = false;
+  can_revoke_other_invitation_ = false;
+  can_get_suggestion_ = false;
+  can_suggest_member_ = false;
+  can_approve_member_ = false;
+  can_get_ticket_ = false;
+  can_create_ticket_ = false;
+  can_destroy_ticket_ = false;
+  can_get_ban_ = false;
+  can_add_ban_ = false;
+  can_remove_ban_ = false;
+  can_create_stream_ = false;
+  can_destroy_stream_ = false;
+  can_set_stream_position_ = false;
+  can_set_stream_attribute_ = false;
+  can_set_stream_name_ = false;
+  can_set_stream_subject_ = false;
+  can_set_stream_access_ = false;
+  can_set_stream_voice_level_ = false;
+  can_create_message_ = false;
+  can_destroy_own_message_ = false;
+  can_destroy_other_message_ = false;
+  can_edit_own_message_ = false;
+  can_pin_message_ = false;
+  can_mention_all_ = false;
+  can_mention_here_ = false;
+  can_mention_member_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubPrivilegeSet::~ClubPrivilegeSet() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubPrivilegeSet)
+  SharedDtor();
+}
+
+void ClubPrivilegeSet::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ClubPrivilegeSet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubPrivilegeSet::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubPrivilegeSet_descriptor_;
+}
+
+const ClubPrivilegeSet& ClubPrivilegeSet::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frole_2eproto();
+  return *default_instance_;
+}
+
+ClubPrivilegeSet* ClubPrivilegeSet::default_instance_ = NULL;
+
+ClubPrivilegeSet* ClubPrivilegeSet::New() const {
+  return new ClubPrivilegeSet;
+}
+
+void ClubPrivilegeSet::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClubPrivilegeSet*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(can_destroy_, can_kick_member_);
+  }
+  if (_has_bits_[8 / 32] & 65280) {
+    ZR_(can_set_own_member_attribute_, can_use_voice_);
+  }
+  if (_has_bits_[16 / 32] & 16711680) {
+    ZR_(can_voice_mute_member_for_all_, can_suggest_member_);
+  }
+  if (_has_bits_[24 / 32] & 4278190080) {
+    ZR_(can_approve_member_, can_create_stream_);
+  }
+  if (_has_bits_[32 / 32] & 255) {
+    ZR_(can_destroy_stream_, can_create_message_);
+  }
+  if (_has_bits_[40 / 32] & 32512) {
+    ZR_(can_destroy_own_message_, can_mention_member_);
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubPrivilegeSet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubPrivilegeSet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool can_destroy = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_destroy_)));
+          set_has_can_destroy();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_can_set_attribute;
+        break;
+      }
+
+      // optional bool can_set_attribute = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_can_set_attribute:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_attribute_)));
+          set_has_can_set_attribute();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(88)) goto parse_can_set_name;
+        break;
+      }
+
+      // optional bool can_set_name = 11;
+      case 11: {
+        if (tag == 88) {
+         parse_can_set_name:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_name_)));
+          set_has_can_set_name();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(96)) goto parse_can_set_description;
+        break;
+      }
+
+      // optional bool can_set_description = 12;
+      case 12: {
+        if (tag == 96) {
+         parse_can_set_description:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_description_)));
+          set_has_can_set_description();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(104)) goto parse_can_set_avatar;
+        break;
+      }
+
+      // optional bool can_set_avatar = 13;
+      case 13: {
+        if (tag == 104) {
+         parse_can_set_avatar:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_avatar_)));
+          set_has_can_set_avatar();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(112)) goto parse_can_set_broadcast;
+        break;
+      }
+
+      // optional bool can_set_broadcast = 14;
+      case 14: {
+        if (tag == 112) {
+         parse_can_set_broadcast:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_broadcast_)));
+          set_has_can_set_broadcast();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(120)) goto parse_can_set_privacy_level;
+        break;
+      }
+
+      // optional bool can_set_privacy_level = 15;
+      case 15: {
+        if (tag == 120) {
+         parse_can_set_privacy_level:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_privacy_level_)));
+          set_has_can_set_privacy_level();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(240)) goto parse_can_kick_member;
+        break;
+      }
+
+      // optional bool can_kick_member = 30;
+      case 30: {
+        if (tag == 240) {
+         parse_can_kick_member:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_kick_member_)));
+          set_has_can_kick_member();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(248)) goto parse_can_set_own_member_attribute;
+        break;
+      }
+
+      // optional bool can_set_own_member_attribute = 31;
+      case 31: {
+        if (tag == 248) {
+         parse_can_set_own_member_attribute:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_own_member_attribute_)));
+          set_has_can_set_own_member_attribute();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(256)) goto parse_can_set_other_member_attribute;
+        break;
+      }
+
+      // optional bool can_set_other_member_attribute = 32;
+      case 32: {
+        if (tag == 256) {
+         parse_can_set_other_member_attribute:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_other_member_attribute_)));
+          set_has_can_set_other_member_attribute();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(264)) goto parse_can_set_own_voice_state;
+        break;
+      }
+
+      // optional bool can_set_own_voice_state = 33;
+      case 33: {
+        if (tag == 264) {
+         parse_can_set_own_voice_state:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_own_voice_state_)));
+          set_has_can_set_own_voice_state();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(272)) goto parse_can_set_own_presence_level;
+        break;
+      }
+
+      // optional bool can_set_own_presence_level = 34;
+      case 34: {
+        if (tag == 272) {
+         parse_can_set_own_presence_level:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_own_presence_level_)));
+          set_has_can_set_own_presence_level();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(280)) goto parse_can_set_own_whisper_level;
+        break;
+      }
+
+      // optional bool can_set_own_whisper_level = 35;
+      case 35: {
+        if (tag == 280) {
+         parse_can_set_own_whisper_level:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_own_whisper_level_)));
+          set_has_can_set_own_whisper_level();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(288)) goto parse_can_set_own_member_note;
+        break;
+      }
+
+      // optional bool can_set_own_member_note = 36;
+      case 36: {
+        if (tag == 288) {
+         parse_can_set_own_member_note:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_own_member_note_)));
+          set_has_can_set_own_member_note();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(296)) goto parse_can_set_other_member_note;
+        break;
+      }
+
+      // optional bool can_set_other_member_note = 37;
+      case 37: {
+        if (tag == 296) {
+         parse_can_set_other_member_note:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_other_member_note_)));
+          set_has_can_set_other_member_note();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(400)) goto parse_can_use_voice;
+        break;
+      }
+
+      // optional bool can_use_voice = 50;
+      case 50: {
+        if (tag == 400) {
+         parse_can_use_voice:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_use_voice_)));
+          set_has_can_use_voice();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(408)) goto parse_can_voice_mute_member_for_all;
+        break;
+      }
+
+      // optional bool can_voice_mute_member_for_all = 51;
+      case 51: {
+        if (tag == 408) {
+         parse_can_voice_mute_member_for_all:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_voice_mute_member_for_all_)));
+          set_has_can_voice_mute_member_for_all();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(560)) goto parse_can_get_invitation;
+        break;
+      }
+
+      // optional bool can_get_invitation = 70;
+      case 70: {
+        if (tag == 560) {
+         parse_can_get_invitation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_get_invitation_)));
+          set_has_can_get_invitation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(568)) goto parse_can_send_invitation;
+        break;
+      }
+
+      // optional bool can_send_invitation = 71;
+      case 71: {
+        if (tag == 568) {
+         parse_can_send_invitation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_send_invitation_)));
+          set_has_can_send_invitation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(576)) goto parse_can_send_guest_invitation;
+        break;
+      }
+
+      // optional bool can_send_guest_invitation = 72;
+      case 72: {
+        if (tag == 576) {
+         parse_can_send_guest_invitation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_send_guest_invitation_)));
+          set_has_can_send_guest_invitation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(584)) goto parse_can_revoke_own_invitation;
+        break;
+      }
+
+      // optional bool can_revoke_own_invitation = 73;
+      case 73: {
+        if (tag == 584) {
+         parse_can_revoke_own_invitation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_revoke_own_invitation_)));
+          set_has_can_revoke_own_invitation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(592)) goto parse_can_revoke_other_invitation;
+        break;
+      }
+
+      // optional bool can_revoke_other_invitation = 74;
+      case 74: {
+        if (tag == 592) {
+         parse_can_revoke_other_invitation:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_revoke_other_invitation_)));
+          set_has_can_revoke_other_invitation();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(720)) goto parse_can_get_suggestion;
+        break;
+      }
+
+      // optional bool can_get_suggestion = 90;
+      case 90: {
+        if (tag == 720) {
+         parse_can_get_suggestion:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_get_suggestion_)));
+          set_has_can_get_suggestion();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(728)) goto parse_can_suggest_member;
+        break;
+      }
+
+      // optional bool can_suggest_member = 91;
+      case 91: {
+        if (tag == 728) {
+         parse_can_suggest_member:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_suggest_member_)));
+          set_has_can_suggest_member();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(736)) goto parse_can_approve_member;
+        break;
+      }
+
+      // optional bool can_approve_member = 92;
+      case 92: {
+        if (tag == 736) {
+         parse_can_approve_member:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_approve_member_)));
+          set_has_can_approve_member();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(880)) goto parse_can_get_ticket;
+        break;
+      }
+
+      // optional bool can_get_ticket = 110;
+      case 110: {
+        if (tag == 880) {
+         parse_can_get_ticket:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_get_ticket_)));
+          set_has_can_get_ticket();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(888)) goto parse_can_create_ticket;
+        break;
+      }
+
+      // optional bool can_create_ticket = 111;
+      case 111: {
+        if (tag == 888) {
+         parse_can_create_ticket:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_create_ticket_)));
+          set_has_can_create_ticket();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(896)) goto parse_can_destroy_ticket;
+        break;
+      }
+
+      // optional bool can_destroy_ticket = 112;
+      case 112: {
+        if (tag == 896) {
+         parse_can_destroy_ticket:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_destroy_ticket_)));
+          set_has_can_destroy_ticket();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1040)) goto parse_can_get_ban;
+        break;
+      }
+
+      // optional bool can_get_ban = 130;
+      case 130: {
+        if (tag == 1040) {
+         parse_can_get_ban:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_get_ban_)));
+          set_has_can_get_ban();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1048)) goto parse_can_add_ban;
+        break;
+      }
+
+      // optional bool can_add_ban = 131;
+      case 131: {
+        if (tag == 1048) {
+         parse_can_add_ban:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_add_ban_)));
+          set_has_can_add_ban();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1056)) goto parse_can_remove_ban;
+        break;
+      }
+
+      // optional bool can_remove_ban = 132;
+      case 132: {
+        if (tag == 1056) {
+         parse_can_remove_ban:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_remove_ban_)));
+          set_has_can_remove_ban();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1120)) goto parse_can_create_stream;
+        break;
+      }
+
+      // optional bool can_create_stream = 140;
+      case 140: {
+        if (tag == 1120) {
+         parse_can_create_stream:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_create_stream_)));
+          set_has_can_create_stream();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1128)) goto parse_can_destroy_stream;
+        break;
+      }
+
+      // optional bool can_destroy_stream = 141;
+      case 141: {
+        if (tag == 1128) {
+         parse_can_destroy_stream:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_destroy_stream_)));
+          set_has_can_destroy_stream();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1136)) goto parse_can_set_stream_position;
+        break;
+      }
+
+      // optional bool can_set_stream_position = 142;
+      case 142: {
+        if (tag == 1136) {
+         parse_can_set_stream_position:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_stream_position_)));
+          set_has_can_set_stream_position();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1144)) goto parse_can_set_stream_attribute;
+        break;
+      }
+
+      // optional bool can_set_stream_attribute = 143;
+      case 143: {
+        if (tag == 1144) {
+         parse_can_set_stream_attribute:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_stream_attribute_)));
+          set_has_can_set_stream_attribute();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1152)) goto parse_can_set_stream_name;
+        break;
+      }
+
+      // optional bool can_set_stream_name = 144;
+      case 144: {
+        if (tag == 1152) {
+         parse_can_set_stream_name:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_stream_name_)));
+          set_has_can_set_stream_name();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1160)) goto parse_can_set_stream_subject;
+        break;
+      }
+
+      // optional bool can_set_stream_subject = 145;
+      case 145: {
+        if (tag == 1160) {
+         parse_can_set_stream_subject:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_stream_subject_)));
+          set_has_can_set_stream_subject();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1168)) goto parse_can_set_stream_access;
+        break;
+      }
+
+      // optional bool can_set_stream_access = 146;
+      case 146: {
+        if (tag == 1168) {
+         parse_can_set_stream_access:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_stream_access_)));
+          set_has_can_set_stream_access();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1176)) goto parse_can_set_stream_voice_level;
+        break;
+      }
+
+      // optional bool can_set_stream_voice_level = 147;
+      case 147: {
+        if (tag == 1176) {
+         parse_can_set_stream_voice_level:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_set_stream_voice_level_)));
+          set_has_can_set_stream_voice_level();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1440)) goto parse_can_create_message;
+        break;
+      }
+
+      // optional bool can_create_message = 180;
+      case 180: {
+        if (tag == 1440) {
+         parse_can_create_message:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_create_message_)));
+          set_has_can_create_message();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1448)) goto parse_can_destroy_own_message;
+        break;
+      }
+
+      // optional bool can_destroy_own_message = 181;
+      case 181: {
+        if (tag == 1448) {
+         parse_can_destroy_own_message:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_destroy_own_message_)));
+          set_has_can_destroy_own_message();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1456)) goto parse_can_destroy_other_message;
+        break;
+      }
+
+      // optional bool can_destroy_other_message = 182;
+      case 182: {
+        if (tag == 1456) {
+         parse_can_destroy_other_message:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_destroy_other_message_)));
+          set_has_can_destroy_other_message();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1464)) goto parse_can_edit_own_message;
+        break;
+      }
+
+      // optional bool can_edit_own_message = 183;
+      case 183: {
+        if (tag == 1464) {
+         parse_can_edit_own_message:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_edit_own_message_)));
+          set_has_can_edit_own_message();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1472)) goto parse_can_pin_message;
+        break;
+      }
+
+      // optional bool can_pin_message = 184;
+      case 184: {
+        if (tag == 1472) {
+         parse_can_pin_message:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_pin_message_)));
+          set_has_can_pin_message();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1480)) goto parse_can_mention_all;
+        break;
+      }
+
+      // optional bool can_mention_all = 185;
+      case 185: {
+        if (tag == 1480) {
+         parse_can_mention_all:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_mention_all_)));
+          set_has_can_mention_all();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1488)) goto parse_can_mention_here;
+        break;
+      }
+
+      // optional bool can_mention_here = 186;
+      case 186: {
+        if (tag == 1488) {
+         parse_can_mention_here:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_mention_here_)));
+          set_has_can_mention_here();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(1496)) goto parse_can_mention_member;
+        break;
+      }
+
+      // optional bool can_mention_member = 187;
+      case 187: {
+        if (tag == 1496) {
+         parse_can_mention_member:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_mention_member_)));
+          set_has_can_mention_member();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubPrivilegeSet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubPrivilegeSet)
+  return false;
+#undef DO_
+}
+
+void ClubPrivilegeSet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubPrivilegeSet)
+  // optional bool can_destroy = 1;
+  if (has_can_destroy()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->can_destroy(), output);
+  }
+
+  // optional bool can_set_attribute = 10;
+  if (has_can_set_attribute()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->can_set_attribute(), output);
+  }
+
+  // optional bool can_set_name = 11;
+  if (has_can_set_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->can_set_name(), output);
+  }
+
+  // optional bool can_set_description = 12;
+  if (has_can_set_description()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->can_set_description(), output);
+  }
+
+  // optional bool can_set_avatar = 13;
+  if (has_can_set_avatar()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->can_set_avatar(), output);
+  }
+
+  // optional bool can_set_broadcast = 14;
+  if (has_can_set_broadcast()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->can_set_broadcast(), output);
+  }
+
+  // optional bool can_set_privacy_level = 15;
+  if (has_can_set_privacy_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->can_set_privacy_level(), output);
+  }
+
+  // optional bool can_kick_member = 30;
+  if (has_can_kick_member()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(30, this->can_kick_member(), output);
+  }
+
+  // optional bool can_set_own_member_attribute = 31;
+  if (has_can_set_own_member_attribute()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(31, this->can_set_own_member_attribute(), output);
+  }
+
+  // optional bool can_set_other_member_attribute = 32;
+  if (has_can_set_other_member_attribute()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(32, this->can_set_other_member_attribute(), output);
+  }
+
+  // optional bool can_set_own_voice_state = 33;
+  if (has_can_set_own_voice_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(33, this->can_set_own_voice_state(), output);
+  }
+
+  // optional bool can_set_own_presence_level = 34;
+  if (has_can_set_own_presence_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(34, this->can_set_own_presence_level(), output);
+  }
+
+  // optional bool can_set_own_whisper_level = 35;
+  if (has_can_set_own_whisper_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(35, this->can_set_own_whisper_level(), output);
+  }
+
+  // optional bool can_set_own_member_note = 36;
+  if (has_can_set_own_member_note()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(36, this->can_set_own_member_note(), output);
+  }
+
+  // optional bool can_set_other_member_note = 37;
+  if (has_can_set_other_member_note()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(37, this->can_set_other_member_note(), output);
+  }
+
+  // optional bool can_use_voice = 50;
+  if (has_can_use_voice()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(50, this->can_use_voice(), output);
+  }
+
+  // optional bool can_voice_mute_member_for_all = 51;
+  if (has_can_voice_mute_member_for_all()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(51, this->can_voice_mute_member_for_all(), output);
+  }
+
+  // optional bool can_get_invitation = 70;
+  if (has_can_get_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(70, this->can_get_invitation(), output);
+  }
+
+  // optional bool can_send_invitation = 71;
+  if (has_can_send_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(71, this->can_send_invitation(), output);
+  }
+
+  // optional bool can_send_guest_invitation = 72;
+  if (has_can_send_guest_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(72, this->can_send_guest_invitation(), output);
+  }
+
+  // optional bool can_revoke_own_invitation = 73;
+  if (has_can_revoke_own_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(73, this->can_revoke_own_invitation(), output);
+  }
+
+  // optional bool can_revoke_other_invitation = 74;
+  if (has_can_revoke_other_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(74, this->can_revoke_other_invitation(), output);
+  }
+
+  // optional bool can_get_suggestion = 90;
+  if (has_can_get_suggestion()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(90, this->can_get_suggestion(), output);
+  }
+
+  // optional bool can_suggest_member = 91;
+  if (has_can_suggest_member()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(91, this->can_suggest_member(), output);
+  }
+
+  // optional bool can_approve_member = 92;
+  if (has_can_approve_member()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(92, this->can_approve_member(), output);
+  }
+
+  // optional bool can_get_ticket = 110;
+  if (has_can_get_ticket()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(110, this->can_get_ticket(), output);
+  }
+
+  // optional bool can_create_ticket = 111;
+  if (has_can_create_ticket()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(111, this->can_create_ticket(), output);
+  }
+
+  // optional bool can_destroy_ticket = 112;
+  if (has_can_destroy_ticket()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(112, this->can_destroy_ticket(), output);
+  }
+
+  // optional bool can_get_ban = 130;
+  if (has_can_get_ban()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(130, this->can_get_ban(), output);
+  }
+
+  // optional bool can_add_ban = 131;
+  if (has_can_add_ban()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(131, this->can_add_ban(), output);
+  }
+
+  // optional bool can_remove_ban = 132;
+  if (has_can_remove_ban()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(132, this->can_remove_ban(), output);
+  }
+
+  // optional bool can_create_stream = 140;
+  if (has_can_create_stream()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(140, this->can_create_stream(), output);
+  }
+
+  // optional bool can_destroy_stream = 141;
+  if (has_can_destroy_stream()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(141, this->can_destroy_stream(), output);
+  }
+
+  // optional bool can_set_stream_position = 142;
+  if (has_can_set_stream_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(142, this->can_set_stream_position(), output);
+  }
+
+  // optional bool can_set_stream_attribute = 143;
+  if (has_can_set_stream_attribute()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(143, this->can_set_stream_attribute(), output);
+  }
+
+  // optional bool can_set_stream_name = 144;
+  if (has_can_set_stream_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(144, this->can_set_stream_name(), output);
+  }
+
+  // optional bool can_set_stream_subject = 145;
+  if (has_can_set_stream_subject()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(145, this->can_set_stream_subject(), output);
+  }
+
+  // optional bool can_set_stream_access = 146;
+  if (has_can_set_stream_access()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(146, this->can_set_stream_access(), output);
+  }
+
+  // optional bool can_set_stream_voice_level = 147;
+  if (has_can_set_stream_voice_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(147, this->can_set_stream_voice_level(), output);
+  }
+
+  // optional bool can_create_message = 180;
+  if (has_can_create_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(180, this->can_create_message(), output);
+  }
+
+  // optional bool can_destroy_own_message = 181;
+  if (has_can_destroy_own_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(181, this->can_destroy_own_message(), output);
+  }
+
+  // optional bool can_destroy_other_message = 182;
+  if (has_can_destroy_other_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(182, this->can_destroy_other_message(), output);
+  }
+
+  // optional bool can_edit_own_message = 183;
+  if (has_can_edit_own_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(183, this->can_edit_own_message(), output);
+  }
+
+  // optional bool can_pin_message = 184;
+  if (has_can_pin_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(184, this->can_pin_message(), output);
+  }
+
+  // optional bool can_mention_all = 185;
+  if (has_can_mention_all()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(185, this->can_mention_all(), output);
+  }
+
+  // optional bool can_mention_here = 186;
+  if (has_can_mention_here()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(186, this->can_mention_here(), output);
+  }
+
+  // optional bool can_mention_member = 187;
+  if (has_can_mention_member()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(187, this->can_mention_member(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubPrivilegeSet)
+}
+
+::google::protobuf::uint8* ClubPrivilegeSet::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubPrivilegeSet)
+  // optional bool can_destroy = 1;
+  if (has_can_destroy()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->can_destroy(), target);
+  }
+
+  // optional bool can_set_attribute = 10;
+  if (has_can_set_attribute()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->can_set_attribute(), target);
+  }
+
+  // optional bool can_set_name = 11;
+  if (has_can_set_name()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->can_set_name(), target);
+  }
+
+  // optional bool can_set_description = 12;
+  if (has_can_set_description()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->can_set_description(), target);
+  }
+
+  // optional bool can_set_avatar = 13;
+  if (has_can_set_avatar()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(13, this->can_set_avatar(), target);
+  }
+
+  // optional bool can_set_broadcast = 14;
+  if (has_can_set_broadcast()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(14, this->can_set_broadcast(), target);
+  }
+
+  // optional bool can_set_privacy_level = 15;
+  if (has_can_set_privacy_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(15, this->can_set_privacy_level(), target);
+  }
+
+  // optional bool can_kick_member = 30;
+  if (has_can_kick_member()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(30, this->can_kick_member(), target);
+  }
+
+  // optional bool can_set_own_member_attribute = 31;
+  if (has_can_set_own_member_attribute()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(31, this->can_set_own_member_attribute(), target);
+  }
+
+  // optional bool can_set_other_member_attribute = 32;
+  if (has_can_set_other_member_attribute()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(32, this->can_set_other_member_attribute(), target);
+  }
+
+  // optional bool can_set_own_voice_state = 33;
+  if (has_can_set_own_voice_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(33, this->can_set_own_voice_state(), target);
+  }
+
+  // optional bool can_set_own_presence_level = 34;
+  if (has_can_set_own_presence_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(34, this->can_set_own_presence_level(), target);
+  }
+
+  // optional bool can_set_own_whisper_level = 35;
+  if (has_can_set_own_whisper_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(35, this->can_set_own_whisper_level(), target);
+  }
+
+  // optional bool can_set_own_member_note = 36;
+  if (has_can_set_own_member_note()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(36, this->can_set_own_member_note(), target);
+  }
+
+  // optional bool can_set_other_member_note = 37;
+  if (has_can_set_other_member_note()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(37, this->can_set_other_member_note(), target);
+  }
+
+  // optional bool can_use_voice = 50;
+  if (has_can_use_voice()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(50, this->can_use_voice(), target);
+  }
+
+  // optional bool can_voice_mute_member_for_all = 51;
+  if (has_can_voice_mute_member_for_all()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(51, this->can_voice_mute_member_for_all(), target);
+  }
+
+  // optional bool can_get_invitation = 70;
+  if (has_can_get_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(70, this->can_get_invitation(), target);
+  }
+
+  // optional bool can_send_invitation = 71;
+  if (has_can_send_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(71, this->can_send_invitation(), target);
+  }
+
+  // optional bool can_send_guest_invitation = 72;
+  if (has_can_send_guest_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(72, this->can_send_guest_invitation(), target);
+  }
+
+  // optional bool can_revoke_own_invitation = 73;
+  if (has_can_revoke_own_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(73, this->can_revoke_own_invitation(), target);
+  }
+
+  // optional bool can_revoke_other_invitation = 74;
+  if (has_can_revoke_other_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(74, this->can_revoke_other_invitation(), target);
+  }
+
+  // optional bool can_get_suggestion = 90;
+  if (has_can_get_suggestion()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(90, this->can_get_suggestion(), target);
+  }
+
+  // optional bool can_suggest_member = 91;
+  if (has_can_suggest_member()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(91, this->can_suggest_member(), target);
+  }
+
+  // optional bool can_approve_member = 92;
+  if (has_can_approve_member()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(92, this->can_approve_member(), target);
+  }
+
+  // optional bool can_get_ticket = 110;
+  if (has_can_get_ticket()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(110, this->can_get_ticket(), target);
+  }
+
+  // optional bool can_create_ticket = 111;
+  if (has_can_create_ticket()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(111, this->can_create_ticket(), target);
+  }
+
+  // optional bool can_destroy_ticket = 112;
+  if (has_can_destroy_ticket()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(112, this->can_destroy_ticket(), target);
+  }
+
+  // optional bool can_get_ban = 130;
+  if (has_can_get_ban()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(130, this->can_get_ban(), target);
+  }
+
+  // optional bool can_add_ban = 131;
+  if (has_can_add_ban()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(131, this->can_add_ban(), target);
+  }
+
+  // optional bool can_remove_ban = 132;
+  if (has_can_remove_ban()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(132, this->can_remove_ban(), target);
+  }
+
+  // optional bool can_create_stream = 140;
+  if (has_can_create_stream()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(140, this->can_create_stream(), target);
+  }
+
+  // optional bool can_destroy_stream = 141;
+  if (has_can_destroy_stream()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(141, this->can_destroy_stream(), target);
+  }
+
+  // optional bool can_set_stream_position = 142;
+  if (has_can_set_stream_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(142, this->can_set_stream_position(), target);
+  }
+
+  // optional bool can_set_stream_attribute = 143;
+  if (has_can_set_stream_attribute()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(143, this->can_set_stream_attribute(), target);
+  }
+
+  // optional bool can_set_stream_name = 144;
+  if (has_can_set_stream_name()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(144, this->can_set_stream_name(), target);
+  }
+
+  // optional bool can_set_stream_subject = 145;
+  if (has_can_set_stream_subject()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(145, this->can_set_stream_subject(), target);
+  }
+
+  // optional bool can_set_stream_access = 146;
+  if (has_can_set_stream_access()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(146, this->can_set_stream_access(), target);
+  }
+
+  // optional bool can_set_stream_voice_level = 147;
+  if (has_can_set_stream_voice_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(147, this->can_set_stream_voice_level(), target);
+  }
+
+  // optional bool can_create_message = 180;
+  if (has_can_create_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(180, this->can_create_message(), target);
+  }
+
+  // optional bool can_destroy_own_message = 181;
+  if (has_can_destroy_own_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(181, this->can_destroy_own_message(), target);
+  }
+
+  // optional bool can_destroy_other_message = 182;
+  if (has_can_destroy_other_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(182, this->can_destroy_other_message(), target);
+  }
+
+  // optional bool can_edit_own_message = 183;
+  if (has_can_edit_own_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(183, this->can_edit_own_message(), target);
+  }
+
+  // optional bool can_pin_message = 184;
+  if (has_can_pin_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(184, this->can_pin_message(), target);
+  }
+
+  // optional bool can_mention_all = 185;
+  if (has_can_mention_all()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(185, this->can_mention_all(), target);
+  }
+
+  // optional bool can_mention_here = 186;
+  if (has_can_mention_here()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(186, this->can_mention_here(), target);
+  }
+
+  // optional bool can_mention_member = 187;
+  if (has_can_mention_member()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(187, this->can_mention_member(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubPrivilegeSet)
+  return target;
+}
+
+int ClubPrivilegeSet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool can_destroy = 1;
+    if (has_can_destroy()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_set_attribute = 10;
+    if (has_can_set_attribute()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_set_name = 11;
+    if (has_can_set_name()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_set_description = 12;
+    if (has_can_set_description()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_set_avatar = 13;
+    if (has_can_set_avatar()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_set_broadcast = 14;
+    if (has_can_set_broadcast()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_set_privacy_level = 15;
+    if (has_can_set_privacy_level()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_kick_member = 30;
+    if (has_can_kick_member()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional bool can_set_own_member_attribute = 31;
+    if (has_can_set_own_member_attribute()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_other_member_attribute = 32;
+    if (has_can_set_other_member_attribute()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_own_voice_state = 33;
+    if (has_can_set_own_voice_state()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_own_presence_level = 34;
+    if (has_can_set_own_presence_level()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_own_whisper_level = 35;
+    if (has_can_set_own_whisper_level()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_own_member_note = 36;
+    if (has_can_set_own_member_note()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_other_member_note = 37;
+    if (has_can_set_other_member_note()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_use_voice = 50;
+    if (has_can_use_voice()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    // optional bool can_voice_mute_member_for_all = 51;
+    if (has_can_voice_mute_member_for_all()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_get_invitation = 70;
+    if (has_can_get_invitation()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_send_invitation = 71;
+    if (has_can_send_invitation()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_send_guest_invitation = 72;
+    if (has_can_send_guest_invitation()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_revoke_own_invitation = 73;
+    if (has_can_revoke_own_invitation()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_revoke_other_invitation = 74;
+    if (has_can_revoke_other_invitation()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_get_suggestion = 90;
+    if (has_can_get_suggestion()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_suggest_member = 91;
+    if (has_can_suggest_member()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (_has_bits_[24 / 32] & (0xffu << (24 % 32))) {
+    // optional bool can_approve_member = 92;
+    if (has_can_approve_member()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_get_ticket = 110;
+    if (has_can_get_ticket()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_create_ticket = 111;
+    if (has_can_create_ticket()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_destroy_ticket = 112;
+    if (has_can_destroy_ticket()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_get_ban = 130;
+    if (has_can_get_ban()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_add_ban = 131;
+    if (has_can_add_ban()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_remove_ban = 132;
+    if (has_can_remove_ban()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_create_stream = 140;
+    if (has_can_create_stream()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (_has_bits_[32 / 32] & (0xffu << (32 % 32))) {
+    // optional bool can_destroy_stream = 141;
+    if (has_can_destroy_stream()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_stream_position = 142;
+    if (has_can_set_stream_position()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_stream_attribute = 143;
+    if (has_can_set_stream_attribute()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_stream_name = 144;
+    if (has_can_set_stream_name()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_stream_subject = 145;
+    if (has_can_set_stream_subject()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_stream_access = 146;
+    if (has_can_set_stream_access()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_set_stream_voice_level = 147;
+    if (has_can_set_stream_voice_level()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_create_message = 180;
+    if (has_can_create_message()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (_has_bits_[40 / 32] & (0xffu << (40 % 32))) {
+    // optional bool can_destroy_own_message = 181;
+    if (has_can_destroy_own_message()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_destroy_other_message = 182;
+    if (has_can_destroy_other_message()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_edit_own_message = 183;
+    if (has_can_edit_own_message()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_pin_message = 184;
+    if (has_can_pin_message()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_mention_all = 185;
+    if (has_can_mention_all()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_mention_here = 186;
+    if (has_can_mention_here()) {
+      total_size += 2 + 1;
+    }
+
+    // optional bool can_mention_member = 187;
+    if (has_can_mention_member()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubPrivilegeSet::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubPrivilegeSet* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubPrivilegeSet*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubPrivilegeSet::MergeFrom(const ClubPrivilegeSet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_can_destroy()) {
+      set_can_destroy(from.can_destroy());
+    }
+    if (from.has_can_set_attribute()) {
+      set_can_set_attribute(from.can_set_attribute());
+    }
+    if (from.has_can_set_name()) {
+      set_can_set_name(from.can_set_name());
+    }
+    if (from.has_can_set_description()) {
+      set_can_set_description(from.can_set_description());
+    }
+    if (from.has_can_set_avatar()) {
+      set_can_set_avatar(from.can_set_avatar());
+    }
+    if (from.has_can_set_broadcast()) {
+      set_can_set_broadcast(from.can_set_broadcast());
+    }
+    if (from.has_can_set_privacy_level()) {
+      set_can_set_privacy_level(from.can_set_privacy_level());
+    }
+    if (from.has_can_kick_member()) {
+      set_can_kick_member(from.can_kick_member());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_can_set_own_member_attribute()) {
+      set_can_set_own_member_attribute(from.can_set_own_member_attribute());
+    }
+    if (from.has_can_set_other_member_attribute()) {
+      set_can_set_other_member_attribute(from.can_set_other_member_attribute());
+    }
+    if (from.has_can_set_own_voice_state()) {
+      set_can_set_own_voice_state(from.can_set_own_voice_state());
+    }
+    if (from.has_can_set_own_presence_level()) {
+      set_can_set_own_presence_level(from.can_set_own_presence_level());
+    }
+    if (from.has_can_set_own_whisper_level()) {
+      set_can_set_own_whisper_level(from.can_set_own_whisper_level());
+    }
+    if (from.has_can_set_own_member_note()) {
+      set_can_set_own_member_note(from.can_set_own_member_note());
+    }
+    if (from.has_can_set_other_member_note()) {
+      set_can_set_other_member_note(from.can_set_other_member_note());
+    }
+    if (from.has_can_use_voice()) {
+      set_can_use_voice(from.can_use_voice());
+    }
+  }
+  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    if (from.has_can_voice_mute_member_for_all()) {
+      set_can_voice_mute_member_for_all(from.can_voice_mute_member_for_all());
+    }
+    if (from.has_can_get_invitation()) {
+      set_can_get_invitation(from.can_get_invitation());
+    }
+    if (from.has_can_send_invitation()) {
+      set_can_send_invitation(from.can_send_invitation());
+    }
+    if (from.has_can_send_guest_invitation()) {
+      set_can_send_guest_invitation(from.can_send_guest_invitation());
+    }
+    if (from.has_can_revoke_own_invitation()) {
+      set_can_revoke_own_invitation(from.can_revoke_own_invitation());
+    }
+    if (from.has_can_revoke_other_invitation()) {
+      set_can_revoke_other_invitation(from.can_revoke_other_invitation());
+    }
+    if (from.has_can_get_suggestion()) {
+      set_can_get_suggestion(from.can_get_suggestion());
+    }
+    if (from.has_can_suggest_member()) {
+      set_can_suggest_member(from.can_suggest_member());
+    }
+  }
+  if (from._has_bits_[24 / 32] & (0xffu << (24 % 32))) {
+    if (from.has_can_approve_member()) {
+      set_can_approve_member(from.can_approve_member());
+    }
+    if (from.has_can_get_ticket()) {
+      set_can_get_ticket(from.can_get_ticket());
+    }
+    if (from.has_can_create_ticket()) {
+      set_can_create_ticket(from.can_create_ticket());
+    }
+    if (from.has_can_destroy_ticket()) {
+      set_can_destroy_ticket(from.can_destroy_ticket());
+    }
+    if (from.has_can_get_ban()) {
+      set_can_get_ban(from.can_get_ban());
+    }
+    if (from.has_can_add_ban()) {
+      set_can_add_ban(from.can_add_ban());
+    }
+    if (from.has_can_remove_ban()) {
+      set_can_remove_ban(from.can_remove_ban());
+    }
+    if (from.has_can_create_stream()) {
+      set_can_create_stream(from.can_create_stream());
+    }
+  }
+  if (from._has_bits_[32 / 32] & (0xffu << (32 % 32))) {
+    if (from.has_can_destroy_stream()) {
+      set_can_destroy_stream(from.can_destroy_stream());
+    }
+    if (from.has_can_set_stream_position()) {
+      set_can_set_stream_position(from.can_set_stream_position());
+    }
+    if (from.has_can_set_stream_attribute()) {
+      set_can_set_stream_attribute(from.can_set_stream_attribute());
+    }
+    if (from.has_can_set_stream_name()) {
+      set_can_set_stream_name(from.can_set_stream_name());
+    }
+    if (from.has_can_set_stream_subject()) {
+      set_can_set_stream_subject(from.can_set_stream_subject());
+    }
+    if (from.has_can_set_stream_access()) {
+      set_can_set_stream_access(from.can_set_stream_access());
+    }
+    if (from.has_can_set_stream_voice_level()) {
+      set_can_set_stream_voice_level(from.can_set_stream_voice_level());
+    }
+    if (from.has_can_create_message()) {
+      set_can_create_message(from.can_create_message());
+    }
+  }
+  if (from._has_bits_[40 / 32] & (0xffu << (40 % 32))) {
+    if (from.has_can_destroy_own_message()) {
+      set_can_destroy_own_message(from.can_destroy_own_message());
+    }
+    if (from.has_can_destroy_other_message()) {
+      set_can_destroy_other_message(from.can_destroy_other_message());
+    }
+    if (from.has_can_edit_own_message()) {
+      set_can_edit_own_message(from.can_edit_own_message());
+    }
+    if (from.has_can_pin_message()) {
+      set_can_pin_message(from.can_pin_message());
+    }
+    if (from.has_can_mention_all()) {
+      set_can_mention_all(from.can_mention_all());
+    }
+    if (from.has_can_mention_here()) {
+      set_can_mention_here(from.can_mention_here());
+    }
+    if (from.has_can_mention_member()) {
+      set_can_mention_member(from.can_mention_member());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubPrivilegeSet::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubPrivilegeSet::CopyFrom(const ClubPrivilegeSet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubPrivilegeSet::IsInitialized() const {
+
+  return true;
+}
+
+void ClubPrivilegeSet::Swap(ClubPrivilegeSet* other) {
+  if (other != this) {
+    std::swap(can_destroy_, other->can_destroy_);
+    std::swap(can_set_attribute_, other->can_set_attribute_);
+    std::swap(can_set_name_, other->can_set_name_);
+    std::swap(can_set_description_, other->can_set_description_);
+    std::swap(can_set_avatar_, other->can_set_avatar_);
+    std::swap(can_set_broadcast_, other->can_set_broadcast_);
+    std::swap(can_set_privacy_level_, other->can_set_privacy_level_);
+    std::swap(can_kick_member_, other->can_kick_member_);
+    std::swap(can_set_own_member_attribute_, other->can_set_own_member_attribute_);
+    std::swap(can_set_other_member_attribute_, other->can_set_other_member_attribute_);
+    std::swap(can_set_own_voice_state_, other->can_set_own_voice_state_);
+    std::swap(can_set_own_presence_level_, other->can_set_own_presence_level_);
+    std::swap(can_set_own_whisper_level_, other->can_set_own_whisper_level_);
+    std::swap(can_set_own_member_note_, other->can_set_own_member_note_);
+    std::swap(can_set_other_member_note_, other->can_set_other_member_note_);
+    std::swap(can_use_voice_, other->can_use_voice_);
+    std::swap(can_voice_mute_member_for_all_, other->can_voice_mute_member_for_all_);
+    std::swap(can_get_invitation_, other->can_get_invitation_);
+    std::swap(can_send_invitation_, other->can_send_invitation_);
+    std::swap(can_send_guest_invitation_, other->can_send_guest_invitation_);
+    std::swap(can_revoke_own_invitation_, other->can_revoke_own_invitation_);
+    std::swap(can_revoke_other_invitation_, other->can_revoke_other_invitation_);
+    std::swap(can_get_suggestion_, other->can_get_suggestion_);
+    std::swap(can_suggest_member_, other->can_suggest_member_);
+    std::swap(can_approve_member_, other->can_approve_member_);
+    std::swap(can_get_ticket_, other->can_get_ticket_);
+    std::swap(can_create_ticket_, other->can_create_ticket_);
+    std::swap(can_destroy_ticket_, other->can_destroy_ticket_);
+    std::swap(can_get_ban_, other->can_get_ban_);
+    std::swap(can_add_ban_, other->can_add_ban_);
+    std::swap(can_remove_ban_, other->can_remove_ban_);
+    std::swap(can_create_stream_, other->can_create_stream_);
+    std::swap(can_destroy_stream_, other->can_destroy_stream_);
+    std::swap(can_set_stream_position_, other->can_set_stream_position_);
+    std::swap(can_set_stream_attribute_, other->can_set_stream_attribute_);
+    std::swap(can_set_stream_name_, other->can_set_stream_name_);
+    std::swap(can_set_stream_subject_, other->can_set_stream_subject_);
+    std::swap(can_set_stream_access_, other->can_set_stream_access_);
+    std::swap(can_set_stream_voice_level_, other->can_set_stream_voice_level_);
+    std::swap(can_create_message_, other->can_create_message_);
+    std::swap(can_destroy_own_message_, other->can_destroy_own_message_);
+    std::swap(can_destroy_other_message_, other->can_destroy_other_message_);
+    std::swap(can_edit_own_message_, other->can_edit_own_message_);
+    std::swap(can_pin_message_, other->can_pin_message_);
+    std::swap(can_mention_all_, other->can_mention_all_);
+    std::swap(can_mention_here_, other->can_mention_here_);
+    std::swap(can_mention_member_, other->can_mention_member_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_has_bits_[1], other->_has_bits_[1]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubPrivilegeSet::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubPrivilegeSet_descriptor_;
+  metadata.reflection = ClubPrivilegeSet_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubRole::kIdFieldNumber;
+const int ClubRole::kStateFieldNumber;
+const int ClubRole::kPrivilegeFieldNumber;
+const int ClubRole::kAlwaysGrantStreamAccessFieldNumber;
+const int ClubRole::kAllowInClubSlotFieldNumber;
+#endif  // !_MSC_VER
+
+ClubRole::ClubRole()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubRole)
+}
+
+void ClubRole::InitAsDefaultInstance() {
+  state_ = const_cast< ::bgs::protocol::RoleState*>(&::bgs::protocol::RoleState::default_instance());
+  privilege_ = const_cast< ::bgs::protocol::club::v1::ClubPrivilegeSet*>(&::bgs::protocol::club::v1::ClubPrivilegeSet::default_instance());
+}
+
+ClubRole::ClubRole(const ClubRole& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubRole)
+}
+
+void ClubRole::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = 0u;
+  state_ = NULL;
+  privilege_ = NULL;
+  always_grant_stream_access_ = false;
+  allow_in_club_slot_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubRole::~ClubRole() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubRole)
+  SharedDtor();
+}
+
+void ClubRole::SharedDtor() {
+  if (this != default_instance_) {
+    delete state_;
+    delete privilege_;
+  }
+}
+
+void ClubRole::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubRole::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubRole_descriptor_;
+}
+
+const ClubRole& ClubRole::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frole_2eproto();
+  return *default_instance_;
+}
+
+ClubRole* ClubRole::default_instance_ = NULL;
+
+ClubRole* ClubRole::New() const {
+  return new ClubRole;
+}
+
+void ClubRole::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ClubRole*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(id_, allow_in_club_slot_);
+    if (has_state()) {
+      if (state_ != NULL) state_->::bgs::protocol::RoleState::Clear();
+    }
+    if (has_privilege()) {
+      if (privilege_ != NULL) privilege_->::bgs::protocol::club::v1::ClubPrivilegeSet::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubRole::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubRole)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state;
+        break;
+      }
+
+      // optional .bgs.protocol.RoleState state = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_privilege;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.ClubPrivilegeSet privilege = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_privilege:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_privilege()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_always_grant_stream_access;
+        break;
+      }
+
+      // optional bool always_grant_stream_access = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_always_grant_stream_access:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &always_grant_stream_access_)));
+          set_has_always_grant_stream_access();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_allow_in_club_slot;
+        break;
+      }
+
+      // optional bool allow_in_club_slot = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_allow_in_club_slot:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &allow_in_club_slot_)));
+          set_has_allow_in_club_slot();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubRole)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubRole)
+  return false;
+#undef DO_
+}
+
+void ClubRole::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubRole)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  // optional .bgs.protocol.RoleState state = 2;
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->state(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubPrivilegeSet privilege = 3;
+  if (has_privilege()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->privilege(), output);
+  }
+
+  // optional bool always_grant_stream_access = 4;
+  if (has_always_grant_stream_access()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->always_grant_stream_access(), output);
+  }
+
+  // optional bool allow_in_club_slot = 5;
+  if (has_allow_in_club_slot()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->allow_in_club_slot(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubRole)
+}
+
+::google::protobuf::uint8* ClubRole::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubRole)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  // optional .bgs.protocol.RoleState state = 2;
+  if (has_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->state(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.ClubPrivilegeSet privilege = 3;
+  if (has_privilege()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->privilege(), target);
+  }
+
+  // optional bool always_grant_stream_access = 4;
+  if (has_always_grant_stream_access()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->always_grant_stream_access(), target);
+  }
+
+  // optional bool allow_in_club_slot = 5;
+  if (has_allow_in_club_slot()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->allow_in_club_slot(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubRole)
+  return target;
+}
+
+int ClubRole::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+    // optional .bgs.protocol.RoleState state = 2;
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->state());
+    }
+
+    // optional .bgs.protocol.club.v1.ClubPrivilegeSet privilege = 3;
+    if (has_privilege()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->privilege());
+    }
+
+    // optional bool always_grant_stream_access = 4;
+    if (has_always_grant_stream_access()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool allow_in_club_slot = 5;
+    if (has_allow_in_club_slot()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubRole::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubRole* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubRole*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubRole::MergeFrom(const ClubRole& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_state()) {
+      mutable_state()->::bgs::protocol::RoleState::MergeFrom(from.state());
+    }
+    if (from.has_privilege()) {
+      mutable_privilege()->::bgs::protocol::club::v1::ClubPrivilegeSet::MergeFrom(from.privilege());
+    }
+    if (from.has_always_grant_stream_access()) {
+      set_always_grant_stream_access(from.always_grant_stream_access());
+    }
+    if (from.has_allow_in_club_slot()) {
+      set_allow_in_club_slot(from.allow_in_club_slot());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubRole::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubRole::CopyFrom(const ClubRole& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubRole::IsInitialized() const {
+
+  return true;
+}
+
+void ClubRole::Swap(ClubRole* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(state_, other->state_);
+    std::swap(privilege_, other->privilege_);
+    std::swap(always_grant_stream_access_, other->always_grant_stream_access_);
+    std::swap(allow_in_club_slot_, other->allow_in_club_slot_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubRole::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubRole_descriptor_;
+  metadata.reflection = ClubRole_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubRoleSet::kRoleFieldNumber;
+const int ClubRoleSet::kDefaultRoleFieldNumber;
+const int ClubRoleSet::kAssignmentRespectsRelegationChainFieldNumber;
+const int ClubRoleSet::kSubtypeFieldNumber;
+#endif  // !_MSC_VER
+
+ClubRoleSet::ClubRoleSet()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubRoleSet)
+}
+
+void ClubRoleSet::InitAsDefaultInstance() {
+}
+
+ClubRoleSet::ClubRoleSet(const ClubRoleSet& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubRoleSet)
+}
+
+void ClubRoleSet::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  _default_role_cached_byte_size_ = 0;
+  assignment_respects_relegation_chain_ = false;
+  subtype_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubRoleSet::~ClubRoleSet() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubRoleSet)
+  SharedDtor();
+}
+
+void ClubRoleSet::SharedDtor() {
+  if (subtype_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subtype_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ClubRoleSet::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubRoleSet::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubRoleSet_descriptor_;
+}
+
+const ClubRoleSet& ClubRoleSet::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5frole_2eproto();
+  return *default_instance_;
+}
+
+ClubRoleSet* ClubRoleSet::default_instance_ = NULL;
+
+ClubRoleSet* ClubRoleSet::New() const {
+  return new ClubRoleSet;
+}
+
+void ClubRoleSet::Clear() {
+  if (_has_bits_[0 / 32] & 12) {
+    assignment_respects_relegation_chain_ = false;
+    if (has_subtype()) {
+      if (subtype_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        subtype_->clear();
+      }
+    }
+  }
+  role_.Clear();
+  default_role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubRoleSet::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubRoleSet)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.ClubRole role = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_role:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_role()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_role;
+        if (input->ExpectTag(42)) goto parse_default_role;
+        break;
+      }
+
+      // repeated uint32 default_role = 5 [packed = true];
+      case 5: {
+        if (tag == 42) {
+         parse_default_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_default_role())));
+        } else if (tag == 40) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 42, input, this->mutable_default_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_assignment_respects_relegation_chain;
+        break;
+      }
+
+      // optional bool assignment_respects_relegation_chain = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_assignment_respects_relegation_chain:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &assignment_respects_relegation_chain_)));
+          set_has_assignment_respects_relegation_chain();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_subtype;
+        break;
+      }
+
+      // optional string subtype = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_subtype:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_subtype()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->subtype().data(), this->subtype().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "subtype");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubRoleSet)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubRoleSet)
+  return false;
+#undef DO_
+}
+
+void ClubRoleSet::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubRoleSet)
+  // repeated .bgs.protocol.club.v1.ClubRole role = 1;
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->role(i), output);
+  }
+
+  // repeated uint32 default_role = 5 [packed = true];
+  if (this->default_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_default_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->default_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->default_role(i), output);
+  }
+
+  // optional bool assignment_respects_relegation_chain = 6;
+  if (has_assignment_respects_relegation_chain()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->assignment_respects_relegation_chain(), output);
+  }
+
+  // optional string subtype = 7;
+  if (has_subtype()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subtype().data(), this->subtype().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subtype");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      7, this->subtype(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubRoleSet)
+}
+
+::google::protobuf::uint8* ClubRoleSet::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubRoleSet)
+  // repeated .bgs.protocol.club.v1.ClubRole role = 1;
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->role(i), target);
+  }
+
+  // repeated uint32 default_role = 5 [packed = true];
+  if (this->default_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      5,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _default_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->default_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->default_role(i), target);
+  }
+
+  // optional bool assignment_respects_relegation_chain = 6;
+  if (has_assignment_respects_relegation_chain()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->assignment_respects_relegation_chain(), target);
+  }
+
+  // optional string subtype = 7;
+  if (has_subtype()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subtype().data(), this->subtype().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subtype");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        7, this->subtype(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubRoleSet)
+  return target;
+}
+
+int ClubRoleSet::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[2 / 32] & (0xffu << (2 % 32))) {
+    // optional bool assignment_respects_relegation_chain = 6;
+    if (has_assignment_respects_relegation_chain()) {
+      total_size += 1 + 1;
+    }
+
+    // optional string subtype = 7;
+    if (has_subtype()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->subtype());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.ClubRole role = 1;
+  total_size += 1 * this->role_size();
+  for (int i = 0; i < this->role_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->role(i));
+  }
+
+  // repeated uint32 default_role = 5 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->default_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->default_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _default_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubRoleSet::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubRoleSet* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubRoleSet*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubRoleSet::MergeFrom(const ClubRoleSet& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  default_role_.MergeFrom(from.default_role_);
+  if (from._has_bits_[2 / 32] & (0xffu << (2 % 32))) {
+    if (from.has_assignment_respects_relegation_chain()) {
+      set_assignment_respects_relegation_chain(from.assignment_respects_relegation_chain());
+    }
+    if (from.has_subtype()) {
+      set_subtype(from.subtype());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubRoleSet::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubRoleSet::CopyFrom(const ClubRoleSet& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubRoleSet::IsInitialized() const {
+
+  return true;
+}
+
+void ClubRoleSet::Swap(ClubRoleSet* other) {
+  if (other != this) {
+    role_.Swap(&other->role_);
+    default_role_.Swap(&other->default_role_);
+    std::swap(assignment_respects_relegation_chain_, other->assignment_respects_relegation_chain_);
+    std::swap(subtype_, other->subtype_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubRoleSet::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubRoleSet_descriptor_;
+  metadata.reflection = ClubRoleSet_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_role.pb.h b/src/server/proto/Client/club_role.pb.h
new file mode 100644
index 00000000000..e40c1660108
--- /dev/null
+++ b/src/server/proto/Client/club_role.pb.h
@@ -0,0 +1,2307 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_role.proto
+
+#ifndef PROTOBUF_club_5frole_2eproto__INCLUDED
+#define PROTOBUF_club_5frole_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "role_types.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5frole_2eproto();
+void protobuf_AssignDesc_club_5frole_2eproto();
+void protobuf_ShutdownFile_club_5frole_2eproto();
+
+class ClubPrivilegeSet;
+class ClubRole;
+class ClubRoleSet;
+
+// ===================================================================
+
+class TC_PROTO_API ClubPrivilegeSet : public ::google::protobuf::Message {
+ public:
+  ClubPrivilegeSet();
+  virtual ~ClubPrivilegeSet();
+
+  ClubPrivilegeSet(const ClubPrivilegeSet& from);
+
+  inline ClubPrivilegeSet& operator=(const ClubPrivilegeSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubPrivilegeSet& default_instance();
+
+  void Swap(ClubPrivilegeSet* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubPrivilegeSet* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubPrivilegeSet& from);
+  void MergeFrom(const ClubPrivilegeSet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bool can_destroy = 1;
+  inline bool has_can_destroy() const;
+  inline void clear_can_destroy();
+  static const int kCanDestroyFieldNumber = 1;
+  inline bool can_destroy() const;
+  inline void set_can_destroy(bool value);
+
+  // optional bool can_set_attribute = 10;
+  inline bool has_can_set_attribute() const;
+  inline void clear_can_set_attribute();
+  static const int kCanSetAttributeFieldNumber = 10;
+  inline bool can_set_attribute() const;
+  inline void set_can_set_attribute(bool value);
+
+  // optional bool can_set_name = 11;
+  inline bool has_can_set_name() const;
+  inline void clear_can_set_name();
+  static const int kCanSetNameFieldNumber = 11;
+  inline bool can_set_name() const;
+  inline void set_can_set_name(bool value);
+
+  // optional bool can_set_description = 12;
+  inline bool has_can_set_description() const;
+  inline void clear_can_set_description();
+  static const int kCanSetDescriptionFieldNumber = 12;
+  inline bool can_set_description() const;
+  inline void set_can_set_description(bool value);
+
+  // optional bool can_set_avatar = 13;
+  inline bool has_can_set_avatar() const;
+  inline void clear_can_set_avatar();
+  static const int kCanSetAvatarFieldNumber = 13;
+  inline bool can_set_avatar() const;
+  inline void set_can_set_avatar(bool value);
+
+  // optional bool can_set_broadcast = 14;
+  inline bool has_can_set_broadcast() const;
+  inline void clear_can_set_broadcast();
+  static const int kCanSetBroadcastFieldNumber = 14;
+  inline bool can_set_broadcast() const;
+  inline void set_can_set_broadcast(bool value);
+
+  // optional bool can_set_privacy_level = 15;
+  inline bool has_can_set_privacy_level() const;
+  inline void clear_can_set_privacy_level();
+  static const int kCanSetPrivacyLevelFieldNumber = 15;
+  inline bool can_set_privacy_level() const;
+  inline void set_can_set_privacy_level(bool value);
+
+  // optional bool can_kick_member = 30;
+  inline bool has_can_kick_member() const;
+  inline void clear_can_kick_member();
+  static const int kCanKickMemberFieldNumber = 30;
+  inline bool can_kick_member() const;
+  inline void set_can_kick_member(bool value);
+
+  // optional bool can_set_own_member_attribute = 31;
+  inline bool has_can_set_own_member_attribute() const;
+  inline void clear_can_set_own_member_attribute();
+  static const int kCanSetOwnMemberAttributeFieldNumber = 31;
+  inline bool can_set_own_member_attribute() const;
+  inline void set_can_set_own_member_attribute(bool value);
+
+  // optional bool can_set_other_member_attribute = 32;
+  inline bool has_can_set_other_member_attribute() const;
+  inline void clear_can_set_other_member_attribute();
+  static const int kCanSetOtherMemberAttributeFieldNumber = 32;
+  inline bool can_set_other_member_attribute() const;
+  inline void set_can_set_other_member_attribute(bool value);
+
+  // optional bool can_set_own_voice_state = 33;
+  inline bool has_can_set_own_voice_state() const;
+  inline void clear_can_set_own_voice_state();
+  static const int kCanSetOwnVoiceStateFieldNumber = 33;
+  inline bool can_set_own_voice_state() const;
+  inline void set_can_set_own_voice_state(bool value);
+
+  // optional bool can_set_own_presence_level = 34;
+  inline bool has_can_set_own_presence_level() const;
+  inline void clear_can_set_own_presence_level();
+  static const int kCanSetOwnPresenceLevelFieldNumber = 34;
+  inline bool can_set_own_presence_level() const;
+  inline void set_can_set_own_presence_level(bool value);
+
+  // optional bool can_set_own_whisper_level = 35;
+  inline bool has_can_set_own_whisper_level() const;
+  inline void clear_can_set_own_whisper_level();
+  static const int kCanSetOwnWhisperLevelFieldNumber = 35;
+  inline bool can_set_own_whisper_level() const;
+  inline void set_can_set_own_whisper_level(bool value);
+
+  // optional bool can_set_own_member_note = 36;
+  inline bool has_can_set_own_member_note() const;
+  inline void clear_can_set_own_member_note();
+  static const int kCanSetOwnMemberNoteFieldNumber = 36;
+  inline bool can_set_own_member_note() const;
+  inline void set_can_set_own_member_note(bool value);
+
+  // optional bool can_set_other_member_note = 37;
+  inline bool has_can_set_other_member_note() const;
+  inline void clear_can_set_other_member_note();
+  static const int kCanSetOtherMemberNoteFieldNumber = 37;
+  inline bool can_set_other_member_note() const;
+  inline void set_can_set_other_member_note(bool value);
+
+  // optional bool can_use_voice = 50;
+  inline bool has_can_use_voice() const;
+  inline void clear_can_use_voice();
+  static const int kCanUseVoiceFieldNumber = 50;
+  inline bool can_use_voice() const;
+  inline void set_can_use_voice(bool value);
+
+  // optional bool can_voice_mute_member_for_all = 51;
+  inline bool has_can_voice_mute_member_for_all() const;
+  inline void clear_can_voice_mute_member_for_all();
+  static const int kCanVoiceMuteMemberForAllFieldNumber = 51;
+  inline bool can_voice_mute_member_for_all() const;
+  inline void set_can_voice_mute_member_for_all(bool value);
+
+  // optional bool can_get_invitation = 70;
+  inline bool has_can_get_invitation() const;
+  inline void clear_can_get_invitation();
+  static const int kCanGetInvitationFieldNumber = 70;
+  inline bool can_get_invitation() const;
+  inline void set_can_get_invitation(bool value);
+
+  // optional bool can_send_invitation = 71;
+  inline bool has_can_send_invitation() const;
+  inline void clear_can_send_invitation();
+  static const int kCanSendInvitationFieldNumber = 71;
+  inline bool can_send_invitation() const;
+  inline void set_can_send_invitation(bool value);
+
+  // optional bool can_send_guest_invitation = 72;
+  inline bool has_can_send_guest_invitation() const;
+  inline void clear_can_send_guest_invitation();
+  static const int kCanSendGuestInvitationFieldNumber = 72;
+  inline bool can_send_guest_invitation() const;
+  inline void set_can_send_guest_invitation(bool value);
+
+  // optional bool can_revoke_own_invitation = 73;
+  inline bool has_can_revoke_own_invitation() const;
+  inline void clear_can_revoke_own_invitation();
+  static const int kCanRevokeOwnInvitationFieldNumber = 73;
+  inline bool can_revoke_own_invitation() const;
+  inline void set_can_revoke_own_invitation(bool value);
+
+  // optional bool can_revoke_other_invitation = 74;
+  inline bool has_can_revoke_other_invitation() const;
+  inline void clear_can_revoke_other_invitation();
+  static const int kCanRevokeOtherInvitationFieldNumber = 74;
+  inline bool can_revoke_other_invitation() const;
+  inline void set_can_revoke_other_invitation(bool value);
+
+  // optional bool can_get_suggestion = 90;
+  inline bool has_can_get_suggestion() const;
+  inline void clear_can_get_suggestion();
+  static const int kCanGetSuggestionFieldNumber = 90;
+  inline bool can_get_suggestion() const;
+  inline void set_can_get_suggestion(bool value);
+
+  // optional bool can_suggest_member = 91;
+  inline bool has_can_suggest_member() const;
+  inline void clear_can_suggest_member();
+  static const int kCanSuggestMemberFieldNumber = 91;
+  inline bool can_suggest_member() const;
+  inline void set_can_suggest_member(bool value);
+
+  // optional bool can_approve_member = 92;
+  inline bool has_can_approve_member() const;
+  inline void clear_can_approve_member();
+  static const int kCanApproveMemberFieldNumber = 92;
+  inline bool can_approve_member() const;
+  inline void set_can_approve_member(bool value);
+
+  // optional bool can_get_ticket = 110;
+  inline bool has_can_get_ticket() const;
+  inline void clear_can_get_ticket();
+  static const int kCanGetTicketFieldNumber = 110;
+  inline bool can_get_ticket() const;
+  inline void set_can_get_ticket(bool value);
+
+  // optional bool can_create_ticket = 111;
+  inline bool has_can_create_ticket() const;
+  inline void clear_can_create_ticket();
+  static const int kCanCreateTicketFieldNumber = 111;
+  inline bool can_create_ticket() const;
+  inline void set_can_create_ticket(bool value);
+
+  // optional bool can_destroy_ticket = 112;
+  inline bool has_can_destroy_ticket() const;
+  inline void clear_can_destroy_ticket();
+  static const int kCanDestroyTicketFieldNumber = 112;
+  inline bool can_destroy_ticket() const;
+  inline void set_can_destroy_ticket(bool value);
+
+  // optional bool can_get_ban = 130;
+  inline bool has_can_get_ban() const;
+  inline void clear_can_get_ban();
+  static const int kCanGetBanFieldNumber = 130;
+  inline bool can_get_ban() const;
+  inline void set_can_get_ban(bool value);
+
+  // optional bool can_add_ban = 131;
+  inline bool has_can_add_ban() const;
+  inline void clear_can_add_ban();
+  static const int kCanAddBanFieldNumber = 131;
+  inline bool can_add_ban() const;
+  inline void set_can_add_ban(bool value);
+
+  // optional bool can_remove_ban = 132;
+  inline bool has_can_remove_ban() const;
+  inline void clear_can_remove_ban();
+  static const int kCanRemoveBanFieldNumber = 132;
+  inline bool can_remove_ban() const;
+  inline void set_can_remove_ban(bool value);
+
+  // optional bool can_create_stream = 140;
+  inline bool has_can_create_stream() const;
+  inline void clear_can_create_stream();
+  static const int kCanCreateStreamFieldNumber = 140;
+  inline bool can_create_stream() const;
+  inline void set_can_create_stream(bool value);
+
+  // optional bool can_destroy_stream = 141;
+  inline bool has_can_destroy_stream() const;
+  inline void clear_can_destroy_stream();
+  static const int kCanDestroyStreamFieldNumber = 141;
+  inline bool can_destroy_stream() const;
+  inline void set_can_destroy_stream(bool value);
+
+  // optional bool can_set_stream_position = 142;
+  inline bool has_can_set_stream_position() const;
+  inline void clear_can_set_stream_position();
+  static const int kCanSetStreamPositionFieldNumber = 142;
+  inline bool can_set_stream_position() const;
+  inline void set_can_set_stream_position(bool value);
+
+  // optional bool can_set_stream_attribute = 143;
+  inline bool has_can_set_stream_attribute() const;
+  inline void clear_can_set_stream_attribute();
+  static const int kCanSetStreamAttributeFieldNumber = 143;
+  inline bool can_set_stream_attribute() const;
+  inline void set_can_set_stream_attribute(bool value);
+
+  // optional bool can_set_stream_name = 144;
+  inline bool has_can_set_stream_name() const;
+  inline void clear_can_set_stream_name();
+  static const int kCanSetStreamNameFieldNumber = 144;
+  inline bool can_set_stream_name() const;
+  inline void set_can_set_stream_name(bool value);
+
+  // optional bool can_set_stream_subject = 145;
+  inline bool has_can_set_stream_subject() const;
+  inline void clear_can_set_stream_subject();
+  static const int kCanSetStreamSubjectFieldNumber = 145;
+  inline bool can_set_stream_subject() const;
+  inline void set_can_set_stream_subject(bool value);
+
+  // optional bool can_set_stream_access = 146;
+  inline bool has_can_set_stream_access() const;
+  inline void clear_can_set_stream_access();
+  static const int kCanSetStreamAccessFieldNumber = 146;
+  inline bool can_set_stream_access() const;
+  inline void set_can_set_stream_access(bool value);
+
+  // optional bool can_set_stream_voice_level = 147;
+  inline bool has_can_set_stream_voice_level() const;
+  inline void clear_can_set_stream_voice_level();
+  static const int kCanSetStreamVoiceLevelFieldNumber = 147;
+  inline bool can_set_stream_voice_level() const;
+  inline void set_can_set_stream_voice_level(bool value);
+
+  // optional bool can_create_message = 180;
+  inline bool has_can_create_message() const;
+  inline void clear_can_create_message();
+  static const int kCanCreateMessageFieldNumber = 180;
+  inline bool can_create_message() const;
+  inline void set_can_create_message(bool value);
+
+  // optional bool can_destroy_own_message = 181;
+  inline bool has_can_destroy_own_message() const;
+  inline void clear_can_destroy_own_message();
+  static const int kCanDestroyOwnMessageFieldNumber = 181;
+  inline bool can_destroy_own_message() const;
+  inline void set_can_destroy_own_message(bool value);
+
+  // optional bool can_destroy_other_message = 182;
+  inline bool has_can_destroy_other_message() const;
+  inline void clear_can_destroy_other_message();
+  static const int kCanDestroyOtherMessageFieldNumber = 182;
+  inline bool can_destroy_other_message() const;
+  inline void set_can_destroy_other_message(bool value);
+
+  // optional bool can_edit_own_message = 183;
+  inline bool has_can_edit_own_message() const;
+  inline void clear_can_edit_own_message();
+  static const int kCanEditOwnMessageFieldNumber = 183;
+  inline bool can_edit_own_message() const;
+  inline void set_can_edit_own_message(bool value);
+
+  // optional bool can_pin_message = 184;
+  inline bool has_can_pin_message() const;
+  inline void clear_can_pin_message();
+  static const int kCanPinMessageFieldNumber = 184;
+  inline bool can_pin_message() const;
+  inline void set_can_pin_message(bool value);
+
+  // optional bool can_mention_all = 185;
+  inline bool has_can_mention_all() const;
+  inline void clear_can_mention_all();
+  static const int kCanMentionAllFieldNumber = 185;
+  inline bool can_mention_all() const;
+  inline void set_can_mention_all(bool value);
+
+  // optional bool can_mention_here = 186;
+  inline bool has_can_mention_here() const;
+  inline void clear_can_mention_here();
+  static const int kCanMentionHereFieldNumber = 186;
+  inline bool can_mention_here() const;
+  inline void set_can_mention_here(bool value);
+
+  // optional bool can_mention_member = 187;
+  inline bool has_can_mention_member() const;
+  inline void clear_can_mention_member();
+  static const int kCanMentionMemberFieldNumber = 187;
+  inline bool can_mention_member() const;
+  inline void set_can_mention_member(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubPrivilegeSet)
+ private:
+  inline void set_has_can_destroy();
+  inline void clear_has_can_destroy();
+  inline void set_has_can_set_attribute();
+  inline void clear_has_can_set_attribute();
+  inline void set_has_can_set_name();
+  inline void clear_has_can_set_name();
+  inline void set_has_can_set_description();
+  inline void clear_has_can_set_description();
+  inline void set_has_can_set_avatar();
+  inline void clear_has_can_set_avatar();
+  inline void set_has_can_set_broadcast();
+  inline void clear_has_can_set_broadcast();
+  inline void set_has_can_set_privacy_level();
+  inline void clear_has_can_set_privacy_level();
+  inline void set_has_can_kick_member();
+  inline void clear_has_can_kick_member();
+  inline void set_has_can_set_own_member_attribute();
+  inline void clear_has_can_set_own_member_attribute();
+  inline void set_has_can_set_other_member_attribute();
+  inline void clear_has_can_set_other_member_attribute();
+  inline void set_has_can_set_own_voice_state();
+  inline void clear_has_can_set_own_voice_state();
+  inline void set_has_can_set_own_presence_level();
+  inline void clear_has_can_set_own_presence_level();
+  inline void set_has_can_set_own_whisper_level();
+  inline void clear_has_can_set_own_whisper_level();
+  inline void set_has_can_set_own_member_note();
+  inline void clear_has_can_set_own_member_note();
+  inline void set_has_can_set_other_member_note();
+  inline void clear_has_can_set_other_member_note();
+  inline void set_has_can_use_voice();
+  inline void clear_has_can_use_voice();
+  inline void set_has_can_voice_mute_member_for_all();
+  inline void clear_has_can_voice_mute_member_for_all();
+  inline void set_has_can_get_invitation();
+  inline void clear_has_can_get_invitation();
+  inline void set_has_can_send_invitation();
+  inline void clear_has_can_send_invitation();
+  inline void set_has_can_send_guest_invitation();
+  inline void clear_has_can_send_guest_invitation();
+  inline void set_has_can_revoke_own_invitation();
+  inline void clear_has_can_revoke_own_invitation();
+  inline void set_has_can_revoke_other_invitation();
+  inline void clear_has_can_revoke_other_invitation();
+  inline void set_has_can_get_suggestion();
+  inline void clear_has_can_get_suggestion();
+  inline void set_has_can_suggest_member();
+  inline void clear_has_can_suggest_member();
+  inline void set_has_can_approve_member();
+  inline void clear_has_can_approve_member();
+  inline void set_has_can_get_ticket();
+  inline void clear_has_can_get_ticket();
+  inline void set_has_can_create_ticket();
+  inline void clear_has_can_create_ticket();
+  inline void set_has_can_destroy_ticket();
+  inline void clear_has_can_destroy_ticket();
+  inline void set_has_can_get_ban();
+  inline void clear_has_can_get_ban();
+  inline void set_has_can_add_ban();
+  inline void clear_has_can_add_ban();
+  inline void set_has_can_remove_ban();
+  inline void clear_has_can_remove_ban();
+  inline void set_has_can_create_stream();
+  inline void clear_has_can_create_stream();
+  inline void set_has_can_destroy_stream();
+  inline void clear_has_can_destroy_stream();
+  inline void set_has_can_set_stream_position();
+  inline void clear_has_can_set_stream_position();
+  inline void set_has_can_set_stream_attribute();
+  inline void clear_has_can_set_stream_attribute();
+  inline void set_has_can_set_stream_name();
+  inline void clear_has_can_set_stream_name();
+  inline void set_has_can_set_stream_subject();
+  inline void clear_has_can_set_stream_subject();
+  inline void set_has_can_set_stream_access();
+  inline void clear_has_can_set_stream_access();
+  inline void set_has_can_set_stream_voice_level();
+  inline void clear_has_can_set_stream_voice_level();
+  inline void set_has_can_create_message();
+  inline void clear_has_can_create_message();
+  inline void set_has_can_destroy_own_message();
+  inline void clear_has_can_destroy_own_message();
+  inline void set_has_can_destroy_other_message();
+  inline void clear_has_can_destroy_other_message();
+  inline void set_has_can_edit_own_message();
+  inline void clear_has_can_edit_own_message();
+  inline void set_has_can_pin_message();
+  inline void clear_has_can_pin_message();
+  inline void set_has_can_mention_all();
+  inline void clear_has_can_mention_all();
+  inline void set_has_can_mention_here();
+  inline void clear_has_can_mention_here();
+  inline void set_has_can_mention_member();
+  inline void clear_has_can_mention_member();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[2];
+  bool can_destroy_;
+  bool can_set_attribute_;
+  bool can_set_name_;
+  bool can_set_description_;
+  bool can_set_avatar_;
+  bool can_set_broadcast_;
+  bool can_set_privacy_level_;
+  bool can_kick_member_;
+  bool can_set_own_member_attribute_;
+  bool can_set_other_member_attribute_;
+  bool can_set_own_voice_state_;
+  bool can_set_own_presence_level_;
+  bool can_set_own_whisper_level_;
+  bool can_set_own_member_note_;
+  bool can_set_other_member_note_;
+  bool can_use_voice_;
+  bool can_voice_mute_member_for_all_;
+  bool can_get_invitation_;
+  bool can_send_invitation_;
+  bool can_send_guest_invitation_;
+  bool can_revoke_own_invitation_;
+  bool can_revoke_other_invitation_;
+  bool can_get_suggestion_;
+  bool can_suggest_member_;
+  bool can_approve_member_;
+  bool can_get_ticket_;
+  bool can_create_ticket_;
+  bool can_destroy_ticket_;
+  bool can_get_ban_;
+  bool can_add_ban_;
+  bool can_remove_ban_;
+  bool can_create_stream_;
+  bool can_destroy_stream_;
+  bool can_set_stream_position_;
+  bool can_set_stream_attribute_;
+  bool can_set_stream_name_;
+  bool can_set_stream_subject_;
+  bool can_set_stream_access_;
+  bool can_set_stream_voice_level_;
+  bool can_create_message_;
+  bool can_destroy_own_message_;
+  bool can_destroy_other_message_;
+  bool can_edit_own_message_;
+  bool can_pin_message_;
+  bool can_mention_all_;
+  bool can_mention_here_;
+  bool can_mention_member_;
+  mutable int _cached_size_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frole_2eproto();
+  friend void protobuf_AssignDesc_club_5frole_2eproto();
+  friend void protobuf_ShutdownFile_club_5frole_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubPrivilegeSet* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubRole : public ::google::protobuf::Message {
+ public:
+  ClubRole();
+  virtual ~ClubRole();
+
+  ClubRole(const ClubRole& from);
+
+  inline ClubRole& operator=(const ClubRole& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubRole& default_instance();
+
+  void Swap(ClubRole* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubRole* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubRole& from);
+  void MergeFrom(const ClubRole& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint32 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.RoleState state = 2;
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 2;
+  inline const ::bgs::protocol::RoleState& state() const;
+  inline ::bgs::protocol::RoleState* mutable_state();
+  inline ::bgs::protocol::RoleState* release_state();
+  inline void set_allocated_state(::bgs::protocol::RoleState* state);
+
+  // optional .bgs.protocol.club.v1.ClubPrivilegeSet privilege = 3;
+  inline bool has_privilege() const;
+  inline void clear_privilege();
+  static const int kPrivilegeFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::ClubPrivilegeSet& privilege() const;
+  inline ::bgs::protocol::club::v1::ClubPrivilegeSet* mutable_privilege();
+  inline ::bgs::protocol::club::v1::ClubPrivilegeSet* release_privilege();
+  inline void set_allocated_privilege(::bgs::protocol::club::v1::ClubPrivilegeSet* privilege);
+
+  // optional bool always_grant_stream_access = 4;
+  inline bool has_always_grant_stream_access() const;
+  inline void clear_always_grant_stream_access();
+  static const int kAlwaysGrantStreamAccessFieldNumber = 4;
+  inline bool always_grant_stream_access() const;
+  inline void set_always_grant_stream_access(bool value);
+
+  // optional bool allow_in_club_slot = 5;
+  inline bool has_allow_in_club_slot() const;
+  inline void clear_allow_in_club_slot();
+  static const int kAllowInClubSlotFieldNumber = 5;
+  inline bool allow_in_club_slot() const;
+  inline void set_allow_in_club_slot(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubRole)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_state();
+  inline void clear_has_state();
+  inline void set_has_privilege();
+  inline void clear_has_privilege();
+  inline void set_has_always_grant_stream_access();
+  inline void clear_has_always_grant_stream_access();
+  inline void set_has_allow_in_club_slot();
+  inline void clear_has_allow_in_club_slot();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::RoleState* state_;
+  ::bgs::protocol::club::v1::ClubPrivilegeSet* privilege_;
+  ::google::protobuf::uint32 id_;
+  bool always_grant_stream_access_;
+  bool allow_in_club_slot_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frole_2eproto();
+  friend void protobuf_AssignDesc_club_5frole_2eproto();
+  friend void protobuf_ShutdownFile_club_5frole_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubRole* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubRoleSet : public ::google::protobuf::Message {
+ public:
+  ClubRoleSet();
+  virtual ~ClubRoleSet();
+
+  ClubRoleSet(const ClubRoleSet& from);
+
+  inline ClubRoleSet& operator=(const ClubRoleSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubRoleSet& default_instance();
+
+  void Swap(ClubRoleSet* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubRoleSet* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubRoleSet& from);
+  void MergeFrom(const ClubRoleSet& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.ClubRole role = 1;
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::ClubRole& role(int index) const;
+  inline ::bgs::protocol::club::v1::ClubRole* mutable_role(int index);
+  inline ::bgs::protocol::club::v1::ClubRole* add_role();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubRole >&
+      role() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubRole >*
+      mutable_role();
+
+  // repeated uint32 default_role = 5 [packed = true];
+  inline int default_role_size() const;
+  inline void clear_default_role();
+  static const int kDefaultRoleFieldNumber = 5;
+  inline ::google::protobuf::uint32 default_role(int index) const;
+  inline void set_default_role(int index, ::google::protobuf::uint32 value);
+  inline void add_default_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      default_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_default_role();
+
+  // optional bool assignment_respects_relegation_chain = 6;
+  inline bool has_assignment_respects_relegation_chain() const;
+  inline void clear_assignment_respects_relegation_chain();
+  static const int kAssignmentRespectsRelegationChainFieldNumber = 6;
+  inline bool assignment_respects_relegation_chain() const;
+  inline void set_assignment_respects_relegation_chain(bool value);
+
+  // optional string subtype = 7;
+  inline bool has_subtype() const;
+  inline void clear_subtype();
+  static const int kSubtypeFieldNumber = 7;
+  inline const ::std::string& subtype() const;
+  inline void set_subtype(const ::std::string& value);
+  inline void set_subtype(const char* value);
+  inline void set_subtype(const char* value, size_t size);
+  inline ::std::string* mutable_subtype();
+  inline ::std::string* release_subtype();
+  inline void set_allocated_subtype(::std::string* subtype);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubRoleSet)
+ private:
+  inline void set_has_assignment_respects_relegation_chain();
+  inline void clear_has_assignment_respects_relegation_chain();
+  inline void set_has_subtype();
+  inline void clear_has_subtype();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubRole > role_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > default_role_;
+  mutable int _default_role_cached_byte_size_;
+  ::std::string* subtype_;
+  bool assignment_respects_relegation_chain_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5frole_2eproto();
+  friend void protobuf_AssignDesc_club_5frole_2eproto();
+  friend void protobuf_ShutdownFile_club_5frole_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubRoleSet* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ClubPrivilegeSet
+
+// optional bool can_destroy = 1;
+inline bool ClubPrivilegeSet::has_can_destroy() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_destroy() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubPrivilegeSet::clear_has_can_destroy() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubPrivilegeSet::clear_can_destroy() {
+  can_destroy_ = false;
+  clear_has_can_destroy();
+}
+inline bool ClubPrivilegeSet::can_destroy() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy)
+  return can_destroy_;
+}
+inline void ClubPrivilegeSet::set_can_destroy(bool value) {
+  set_has_can_destroy();
+  can_destroy_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy)
+}
+
+// optional bool can_set_attribute = 10;
+inline bool ClubPrivilegeSet::has_can_set_attribute() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_attribute() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_attribute() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubPrivilegeSet::clear_can_set_attribute() {
+  can_set_attribute_ = false;
+  clear_has_can_set_attribute();
+}
+inline bool ClubPrivilegeSet::can_set_attribute() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_attribute)
+  return can_set_attribute_;
+}
+inline void ClubPrivilegeSet::set_can_set_attribute(bool value) {
+  set_has_can_set_attribute();
+  can_set_attribute_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_attribute)
+}
+
+// optional bool can_set_name = 11;
+inline bool ClubPrivilegeSet::has_can_set_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubPrivilegeSet::clear_can_set_name() {
+  can_set_name_ = false;
+  clear_has_can_set_name();
+}
+inline bool ClubPrivilegeSet::can_set_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_name)
+  return can_set_name_;
+}
+inline void ClubPrivilegeSet::set_can_set_name(bool value) {
+  set_has_can_set_name();
+  can_set_name_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_name)
+}
+
+// optional bool can_set_description = 12;
+inline bool ClubPrivilegeSet::has_can_set_description() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_description() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_description() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubPrivilegeSet::clear_can_set_description() {
+  can_set_description_ = false;
+  clear_has_can_set_description();
+}
+inline bool ClubPrivilegeSet::can_set_description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_description)
+  return can_set_description_;
+}
+inline void ClubPrivilegeSet::set_can_set_description(bool value) {
+  set_has_can_set_description();
+  can_set_description_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_description)
+}
+
+// optional bool can_set_avatar = 13;
+inline bool ClubPrivilegeSet::has_can_set_avatar() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_avatar() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_avatar() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubPrivilegeSet::clear_can_set_avatar() {
+  can_set_avatar_ = false;
+  clear_has_can_set_avatar();
+}
+inline bool ClubPrivilegeSet::can_set_avatar() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_avatar)
+  return can_set_avatar_;
+}
+inline void ClubPrivilegeSet::set_can_set_avatar(bool value) {
+  set_has_can_set_avatar();
+  can_set_avatar_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_avatar)
+}
+
+// optional bool can_set_broadcast = 14;
+inline bool ClubPrivilegeSet::has_can_set_broadcast() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_broadcast() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_broadcast() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClubPrivilegeSet::clear_can_set_broadcast() {
+  can_set_broadcast_ = false;
+  clear_has_can_set_broadcast();
+}
+inline bool ClubPrivilegeSet::can_set_broadcast() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_broadcast)
+  return can_set_broadcast_;
+}
+inline void ClubPrivilegeSet::set_can_set_broadcast(bool value) {
+  set_has_can_set_broadcast();
+  can_set_broadcast_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_broadcast)
+}
+
+// optional bool can_set_privacy_level = 15;
+inline bool ClubPrivilegeSet::has_can_set_privacy_level() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_privacy_level() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_privacy_level() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ClubPrivilegeSet::clear_can_set_privacy_level() {
+  can_set_privacy_level_ = false;
+  clear_has_can_set_privacy_level();
+}
+inline bool ClubPrivilegeSet::can_set_privacy_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_privacy_level)
+  return can_set_privacy_level_;
+}
+inline void ClubPrivilegeSet::set_can_set_privacy_level(bool value) {
+  set_has_can_set_privacy_level();
+  can_set_privacy_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_privacy_level)
+}
+
+// optional bool can_kick_member = 30;
+inline bool ClubPrivilegeSet::has_can_kick_member() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_kick_member() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ClubPrivilegeSet::clear_has_can_kick_member() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ClubPrivilegeSet::clear_can_kick_member() {
+  can_kick_member_ = false;
+  clear_has_can_kick_member();
+}
+inline bool ClubPrivilegeSet::can_kick_member() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_kick_member)
+  return can_kick_member_;
+}
+inline void ClubPrivilegeSet::set_can_kick_member(bool value) {
+  set_has_can_kick_member();
+  can_kick_member_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_kick_member)
+}
+
+// optional bool can_set_own_member_attribute = 31;
+inline bool ClubPrivilegeSet::has_can_set_own_member_attribute() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_own_member_attribute() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_own_member_attribute() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ClubPrivilegeSet::clear_can_set_own_member_attribute() {
+  can_set_own_member_attribute_ = false;
+  clear_has_can_set_own_member_attribute();
+}
+inline bool ClubPrivilegeSet::can_set_own_member_attribute() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_member_attribute)
+  return can_set_own_member_attribute_;
+}
+inline void ClubPrivilegeSet::set_can_set_own_member_attribute(bool value) {
+  set_has_can_set_own_member_attribute();
+  can_set_own_member_attribute_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_member_attribute)
+}
+
+// optional bool can_set_other_member_attribute = 32;
+inline bool ClubPrivilegeSet::has_can_set_other_member_attribute() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_other_member_attribute() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_other_member_attribute() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ClubPrivilegeSet::clear_can_set_other_member_attribute() {
+  can_set_other_member_attribute_ = false;
+  clear_has_can_set_other_member_attribute();
+}
+inline bool ClubPrivilegeSet::can_set_other_member_attribute() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_other_member_attribute)
+  return can_set_other_member_attribute_;
+}
+inline void ClubPrivilegeSet::set_can_set_other_member_attribute(bool value) {
+  set_has_can_set_other_member_attribute();
+  can_set_other_member_attribute_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_other_member_attribute)
+}
+
+// optional bool can_set_own_voice_state = 33;
+inline bool ClubPrivilegeSet::has_can_set_own_voice_state() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_own_voice_state() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_own_voice_state() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void ClubPrivilegeSet::clear_can_set_own_voice_state() {
+  can_set_own_voice_state_ = false;
+  clear_has_can_set_own_voice_state();
+}
+inline bool ClubPrivilegeSet::can_set_own_voice_state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_voice_state)
+  return can_set_own_voice_state_;
+}
+inline void ClubPrivilegeSet::set_can_set_own_voice_state(bool value) {
+  set_has_can_set_own_voice_state();
+  can_set_own_voice_state_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_voice_state)
+}
+
+// optional bool can_set_own_presence_level = 34;
+inline bool ClubPrivilegeSet::has_can_set_own_presence_level() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_own_presence_level() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_own_presence_level() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void ClubPrivilegeSet::clear_can_set_own_presence_level() {
+  can_set_own_presence_level_ = false;
+  clear_has_can_set_own_presence_level();
+}
+inline bool ClubPrivilegeSet::can_set_own_presence_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_presence_level)
+  return can_set_own_presence_level_;
+}
+inline void ClubPrivilegeSet::set_can_set_own_presence_level(bool value) {
+  set_has_can_set_own_presence_level();
+  can_set_own_presence_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_presence_level)
+}
+
+// optional bool can_set_own_whisper_level = 35;
+inline bool ClubPrivilegeSet::has_can_set_own_whisper_level() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_own_whisper_level() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_own_whisper_level() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void ClubPrivilegeSet::clear_can_set_own_whisper_level() {
+  can_set_own_whisper_level_ = false;
+  clear_has_can_set_own_whisper_level();
+}
+inline bool ClubPrivilegeSet::can_set_own_whisper_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_whisper_level)
+  return can_set_own_whisper_level_;
+}
+inline void ClubPrivilegeSet::set_can_set_own_whisper_level(bool value) {
+  set_has_can_set_own_whisper_level();
+  can_set_own_whisper_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_whisper_level)
+}
+
+// optional bool can_set_own_member_note = 36;
+inline bool ClubPrivilegeSet::has_can_set_own_member_note() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_own_member_note() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_own_member_note() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void ClubPrivilegeSet::clear_can_set_own_member_note() {
+  can_set_own_member_note_ = false;
+  clear_has_can_set_own_member_note();
+}
+inline bool ClubPrivilegeSet::can_set_own_member_note() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_member_note)
+  return can_set_own_member_note_;
+}
+inline void ClubPrivilegeSet::set_can_set_own_member_note(bool value) {
+  set_has_can_set_own_member_note();
+  can_set_own_member_note_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_own_member_note)
+}
+
+// optional bool can_set_other_member_note = 37;
+inline bool ClubPrivilegeSet::has_can_set_other_member_note() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_other_member_note() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_other_member_note() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void ClubPrivilegeSet::clear_can_set_other_member_note() {
+  can_set_other_member_note_ = false;
+  clear_has_can_set_other_member_note();
+}
+inline bool ClubPrivilegeSet::can_set_other_member_note() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_other_member_note)
+  return can_set_other_member_note_;
+}
+inline void ClubPrivilegeSet::set_can_set_other_member_note(bool value) {
+  set_has_can_set_other_member_note();
+  can_set_other_member_note_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_other_member_note)
+}
+
+// optional bool can_use_voice = 50;
+inline bool ClubPrivilegeSet::has_can_use_voice() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_use_voice() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_use_voice() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void ClubPrivilegeSet::clear_can_use_voice() {
+  can_use_voice_ = false;
+  clear_has_can_use_voice();
+}
+inline bool ClubPrivilegeSet::can_use_voice() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_use_voice)
+  return can_use_voice_;
+}
+inline void ClubPrivilegeSet::set_can_use_voice(bool value) {
+  set_has_can_use_voice();
+  can_use_voice_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_use_voice)
+}
+
+// optional bool can_voice_mute_member_for_all = 51;
+inline bool ClubPrivilegeSet::has_can_voice_mute_member_for_all() const {
+  return (_has_bits_[0] & 0x00010000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_voice_mute_member_for_all() {
+  _has_bits_[0] |= 0x00010000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_voice_mute_member_for_all() {
+  _has_bits_[0] &= ~0x00010000u;
+}
+inline void ClubPrivilegeSet::clear_can_voice_mute_member_for_all() {
+  can_voice_mute_member_for_all_ = false;
+  clear_has_can_voice_mute_member_for_all();
+}
+inline bool ClubPrivilegeSet::can_voice_mute_member_for_all() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_voice_mute_member_for_all)
+  return can_voice_mute_member_for_all_;
+}
+inline void ClubPrivilegeSet::set_can_voice_mute_member_for_all(bool value) {
+  set_has_can_voice_mute_member_for_all();
+  can_voice_mute_member_for_all_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_voice_mute_member_for_all)
+}
+
+// optional bool can_get_invitation = 70;
+inline bool ClubPrivilegeSet::has_can_get_invitation() const {
+  return (_has_bits_[0] & 0x00020000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_get_invitation() {
+  _has_bits_[0] |= 0x00020000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_get_invitation() {
+  _has_bits_[0] &= ~0x00020000u;
+}
+inline void ClubPrivilegeSet::clear_can_get_invitation() {
+  can_get_invitation_ = false;
+  clear_has_can_get_invitation();
+}
+inline bool ClubPrivilegeSet::can_get_invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_get_invitation)
+  return can_get_invitation_;
+}
+inline void ClubPrivilegeSet::set_can_get_invitation(bool value) {
+  set_has_can_get_invitation();
+  can_get_invitation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_get_invitation)
+}
+
+// optional bool can_send_invitation = 71;
+inline bool ClubPrivilegeSet::has_can_send_invitation() const {
+  return (_has_bits_[0] & 0x00040000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_send_invitation() {
+  _has_bits_[0] |= 0x00040000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_send_invitation() {
+  _has_bits_[0] &= ~0x00040000u;
+}
+inline void ClubPrivilegeSet::clear_can_send_invitation() {
+  can_send_invitation_ = false;
+  clear_has_can_send_invitation();
+}
+inline bool ClubPrivilegeSet::can_send_invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_send_invitation)
+  return can_send_invitation_;
+}
+inline void ClubPrivilegeSet::set_can_send_invitation(bool value) {
+  set_has_can_send_invitation();
+  can_send_invitation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_send_invitation)
+}
+
+// optional bool can_send_guest_invitation = 72;
+inline bool ClubPrivilegeSet::has_can_send_guest_invitation() const {
+  return (_has_bits_[0] & 0x00080000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_send_guest_invitation() {
+  _has_bits_[0] |= 0x00080000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_send_guest_invitation() {
+  _has_bits_[0] &= ~0x00080000u;
+}
+inline void ClubPrivilegeSet::clear_can_send_guest_invitation() {
+  can_send_guest_invitation_ = false;
+  clear_has_can_send_guest_invitation();
+}
+inline bool ClubPrivilegeSet::can_send_guest_invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_send_guest_invitation)
+  return can_send_guest_invitation_;
+}
+inline void ClubPrivilegeSet::set_can_send_guest_invitation(bool value) {
+  set_has_can_send_guest_invitation();
+  can_send_guest_invitation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_send_guest_invitation)
+}
+
+// optional bool can_revoke_own_invitation = 73;
+inline bool ClubPrivilegeSet::has_can_revoke_own_invitation() const {
+  return (_has_bits_[0] & 0x00100000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_revoke_own_invitation() {
+  _has_bits_[0] |= 0x00100000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_revoke_own_invitation() {
+  _has_bits_[0] &= ~0x00100000u;
+}
+inline void ClubPrivilegeSet::clear_can_revoke_own_invitation() {
+  can_revoke_own_invitation_ = false;
+  clear_has_can_revoke_own_invitation();
+}
+inline bool ClubPrivilegeSet::can_revoke_own_invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_revoke_own_invitation)
+  return can_revoke_own_invitation_;
+}
+inline void ClubPrivilegeSet::set_can_revoke_own_invitation(bool value) {
+  set_has_can_revoke_own_invitation();
+  can_revoke_own_invitation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_revoke_own_invitation)
+}
+
+// optional bool can_revoke_other_invitation = 74;
+inline bool ClubPrivilegeSet::has_can_revoke_other_invitation() const {
+  return (_has_bits_[0] & 0x00200000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_revoke_other_invitation() {
+  _has_bits_[0] |= 0x00200000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_revoke_other_invitation() {
+  _has_bits_[0] &= ~0x00200000u;
+}
+inline void ClubPrivilegeSet::clear_can_revoke_other_invitation() {
+  can_revoke_other_invitation_ = false;
+  clear_has_can_revoke_other_invitation();
+}
+inline bool ClubPrivilegeSet::can_revoke_other_invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_revoke_other_invitation)
+  return can_revoke_other_invitation_;
+}
+inline void ClubPrivilegeSet::set_can_revoke_other_invitation(bool value) {
+  set_has_can_revoke_other_invitation();
+  can_revoke_other_invitation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_revoke_other_invitation)
+}
+
+// optional bool can_get_suggestion = 90;
+inline bool ClubPrivilegeSet::has_can_get_suggestion() const {
+  return (_has_bits_[0] & 0x00400000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_get_suggestion() {
+  _has_bits_[0] |= 0x00400000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_get_suggestion() {
+  _has_bits_[0] &= ~0x00400000u;
+}
+inline void ClubPrivilegeSet::clear_can_get_suggestion() {
+  can_get_suggestion_ = false;
+  clear_has_can_get_suggestion();
+}
+inline bool ClubPrivilegeSet::can_get_suggestion() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_get_suggestion)
+  return can_get_suggestion_;
+}
+inline void ClubPrivilegeSet::set_can_get_suggestion(bool value) {
+  set_has_can_get_suggestion();
+  can_get_suggestion_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_get_suggestion)
+}
+
+// optional bool can_suggest_member = 91;
+inline bool ClubPrivilegeSet::has_can_suggest_member() const {
+  return (_has_bits_[0] & 0x00800000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_suggest_member() {
+  _has_bits_[0] |= 0x00800000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_suggest_member() {
+  _has_bits_[0] &= ~0x00800000u;
+}
+inline void ClubPrivilegeSet::clear_can_suggest_member() {
+  can_suggest_member_ = false;
+  clear_has_can_suggest_member();
+}
+inline bool ClubPrivilegeSet::can_suggest_member() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_suggest_member)
+  return can_suggest_member_;
+}
+inline void ClubPrivilegeSet::set_can_suggest_member(bool value) {
+  set_has_can_suggest_member();
+  can_suggest_member_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_suggest_member)
+}
+
+// optional bool can_approve_member = 92;
+inline bool ClubPrivilegeSet::has_can_approve_member() const {
+  return (_has_bits_[0] & 0x01000000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_approve_member() {
+  _has_bits_[0] |= 0x01000000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_approve_member() {
+  _has_bits_[0] &= ~0x01000000u;
+}
+inline void ClubPrivilegeSet::clear_can_approve_member() {
+  can_approve_member_ = false;
+  clear_has_can_approve_member();
+}
+inline bool ClubPrivilegeSet::can_approve_member() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_approve_member)
+  return can_approve_member_;
+}
+inline void ClubPrivilegeSet::set_can_approve_member(bool value) {
+  set_has_can_approve_member();
+  can_approve_member_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_approve_member)
+}
+
+// optional bool can_get_ticket = 110;
+inline bool ClubPrivilegeSet::has_can_get_ticket() const {
+  return (_has_bits_[0] & 0x02000000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_get_ticket() {
+  _has_bits_[0] |= 0x02000000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_get_ticket() {
+  _has_bits_[0] &= ~0x02000000u;
+}
+inline void ClubPrivilegeSet::clear_can_get_ticket() {
+  can_get_ticket_ = false;
+  clear_has_can_get_ticket();
+}
+inline bool ClubPrivilegeSet::can_get_ticket() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_get_ticket)
+  return can_get_ticket_;
+}
+inline void ClubPrivilegeSet::set_can_get_ticket(bool value) {
+  set_has_can_get_ticket();
+  can_get_ticket_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_get_ticket)
+}
+
+// optional bool can_create_ticket = 111;
+inline bool ClubPrivilegeSet::has_can_create_ticket() const {
+  return (_has_bits_[0] & 0x04000000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_create_ticket() {
+  _has_bits_[0] |= 0x04000000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_create_ticket() {
+  _has_bits_[0] &= ~0x04000000u;
+}
+inline void ClubPrivilegeSet::clear_can_create_ticket() {
+  can_create_ticket_ = false;
+  clear_has_can_create_ticket();
+}
+inline bool ClubPrivilegeSet::can_create_ticket() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_create_ticket)
+  return can_create_ticket_;
+}
+inline void ClubPrivilegeSet::set_can_create_ticket(bool value) {
+  set_has_can_create_ticket();
+  can_create_ticket_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_create_ticket)
+}
+
+// optional bool can_destroy_ticket = 112;
+inline bool ClubPrivilegeSet::has_can_destroy_ticket() const {
+  return (_has_bits_[0] & 0x08000000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_destroy_ticket() {
+  _has_bits_[0] |= 0x08000000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_destroy_ticket() {
+  _has_bits_[0] &= ~0x08000000u;
+}
+inline void ClubPrivilegeSet::clear_can_destroy_ticket() {
+  can_destroy_ticket_ = false;
+  clear_has_can_destroy_ticket();
+}
+inline bool ClubPrivilegeSet::can_destroy_ticket() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy_ticket)
+  return can_destroy_ticket_;
+}
+inline void ClubPrivilegeSet::set_can_destroy_ticket(bool value) {
+  set_has_can_destroy_ticket();
+  can_destroy_ticket_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy_ticket)
+}
+
+// optional bool can_get_ban = 130;
+inline bool ClubPrivilegeSet::has_can_get_ban() const {
+  return (_has_bits_[0] & 0x10000000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_get_ban() {
+  _has_bits_[0] |= 0x10000000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_get_ban() {
+  _has_bits_[0] &= ~0x10000000u;
+}
+inline void ClubPrivilegeSet::clear_can_get_ban() {
+  can_get_ban_ = false;
+  clear_has_can_get_ban();
+}
+inline bool ClubPrivilegeSet::can_get_ban() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_get_ban)
+  return can_get_ban_;
+}
+inline void ClubPrivilegeSet::set_can_get_ban(bool value) {
+  set_has_can_get_ban();
+  can_get_ban_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_get_ban)
+}
+
+// optional bool can_add_ban = 131;
+inline bool ClubPrivilegeSet::has_can_add_ban() const {
+  return (_has_bits_[0] & 0x20000000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_add_ban() {
+  _has_bits_[0] |= 0x20000000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_add_ban() {
+  _has_bits_[0] &= ~0x20000000u;
+}
+inline void ClubPrivilegeSet::clear_can_add_ban() {
+  can_add_ban_ = false;
+  clear_has_can_add_ban();
+}
+inline bool ClubPrivilegeSet::can_add_ban() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_add_ban)
+  return can_add_ban_;
+}
+inline void ClubPrivilegeSet::set_can_add_ban(bool value) {
+  set_has_can_add_ban();
+  can_add_ban_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_add_ban)
+}
+
+// optional bool can_remove_ban = 132;
+inline bool ClubPrivilegeSet::has_can_remove_ban() const {
+  return (_has_bits_[0] & 0x40000000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_remove_ban() {
+  _has_bits_[0] |= 0x40000000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_remove_ban() {
+  _has_bits_[0] &= ~0x40000000u;
+}
+inline void ClubPrivilegeSet::clear_can_remove_ban() {
+  can_remove_ban_ = false;
+  clear_has_can_remove_ban();
+}
+inline bool ClubPrivilegeSet::can_remove_ban() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_remove_ban)
+  return can_remove_ban_;
+}
+inline void ClubPrivilegeSet::set_can_remove_ban(bool value) {
+  set_has_can_remove_ban();
+  can_remove_ban_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_remove_ban)
+}
+
+// optional bool can_create_stream = 140;
+inline bool ClubPrivilegeSet::has_can_create_stream() const {
+  return (_has_bits_[0] & 0x80000000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_create_stream() {
+  _has_bits_[0] |= 0x80000000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_create_stream() {
+  _has_bits_[0] &= ~0x80000000u;
+}
+inline void ClubPrivilegeSet::clear_can_create_stream() {
+  can_create_stream_ = false;
+  clear_has_can_create_stream();
+}
+inline bool ClubPrivilegeSet::can_create_stream() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_create_stream)
+  return can_create_stream_;
+}
+inline void ClubPrivilegeSet::set_can_create_stream(bool value) {
+  set_has_can_create_stream();
+  can_create_stream_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_create_stream)
+}
+
+// optional bool can_destroy_stream = 141;
+inline bool ClubPrivilegeSet::has_can_destroy_stream() const {
+  return (_has_bits_[1] & 0x00000001u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_destroy_stream() {
+  _has_bits_[1] |= 0x00000001u;
+}
+inline void ClubPrivilegeSet::clear_has_can_destroy_stream() {
+  _has_bits_[1] &= ~0x00000001u;
+}
+inline void ClubPrivilegeSet::clear_can_destroy_stream() {
+  can_destroy_stream_ = false;
+  clear_has_can_destroy_stream();
+}
+inline bool ClubPrivilegeSet::can_destroy_stream() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy_stream)
+  return can_destroy_stream_;
+}
+inline void ClubPrivilegeSet::set_can_destroy_stream(bool value) {
+  set_has_can_destroy_stream();
+  can_destroy_stream_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy_stream)
+}
+
+// optional bool can_set_stream_position = 142;
+inline bool ClubPrivilegeSet::has_can_set_stream_position() const {
+  return (_has_bits_[1] & 0x00000002u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_stream_position() {
+  _has_bits_[1] |= 0x00000002u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_stream_position() {
+  _has_bits_[1] &= ~0x00000002u;
+}
+inline void ClubPrivilegeSet::clear_can_set_stream_position() {
+  can_set_stream_position_ = false;
+  clear_has_can_set_stream_position();
+}
+inline bool ClubPrivilegeSet::can_set_stream_position() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_position)
+  return can_set_stream_position_;
+}
+inline void ClubPrivilegeSet::set_can_set_stream_position(bool value) {
+  set_has_can_set_stream_position();
+  can_set_stream_position_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_position)
+}
+
+// optional bool can_set_stream_attribute = 143;
+inline bool ClubPrivilegeSet::has_can_set_stream_attribute() const {
+  return (_has_bits_[1] & 0x00000004u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_stream_attribute() {
+  _has_bits_[1] |= 0x00000004u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_stream_attribute() {
+  _has_bits_[1] &= ~0x00000004u;
+}
+inline void ClubPrivilegeSet::clear_can_set_stream_attribute() {
+  can_set_stream_attribute_ = false;
+  clear_has_can_set_stream_attribute();
+}
+inline bool ClubPrivilegeSet::can_set_stream_attribute() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_attribute)
+  return can_set_stream_attribute_;
+}
+inline void ClubPrivilegeSet::set_can_set_stream_attribute(bool value) {
+  set_has_can_set_stream_attribute();
+  can_set_stream_attribute_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_attribute)
+}
+
+// optional bool can_set_stream_name = 144;
+inline bool ClubPrivilegeSet::has_can_set_stream_name() const {
+  return (_has_bits_[1] & 0x00000008u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_stream_name() {
+  _has_bits_[1] |= 0x00000008u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_stream_name() {
+  _has_bits_[1] &= ~0x00000008u;
+}
+inline void ClubPrivilegeSet::clear_can_set_stream_name() {
+  can_set_stream_name_ = false;
+  clear_has_can_set_stream_name();
+}
+inline bool ClubPrivilegeSet::can_set_stream_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_name)
+  return can_set_stream_name_;
+}
+inline void ClubPrivilegeSet::set_can_set_stream_name(bool value) {
+  set_has_can_set_stream_name();
+  can_set_stream_name_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_name)
+}
+
+// optional bool can_set_stream_subject = 145;
+inline bool ClubPrivilegeSet::has_can_set_stream_subject() const {
+  return (_has_bits_[1] & 0x00000010u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_stream_subject() {
+  _has_bits_[1] |= 0x00000010u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_stream_subject() {
+  _has_bits_[1] &= ~0x00000010u;
+}
+inline void ClubPrivilegeSet::clear_can_set_stream_subject() {
+  can_set_stream_subject_ = false;
+  clear_has_can_set_stream_subject();
+}
+inline bool ClubPrivilegeSet::can_set_stream_subject() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_subject)
+  return can_set_stream_subject_;
+}
+inline void ClubPrivilegeSet::set_can_set_stream_subject(bool value) {
+  set_has_can_set_stream_subject();
+  can_set_stream_subject_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_subject)
+}
+
+// optional bool can_set_stream_access = 146;
+inline bool ClubPrivilegeSet::has_can_set_stream_access() const {
+  return (_has_bits_[1] & 0x00000020u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_stream_access() {
+  _has_bits_[1] |= 0x00000020u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_stream_access() {
+  _has_bits_[1] &= ~0x00000020u;
+}
+inline void ClubPrivilegeSet::clear_can_set_stream_access() {
+  can_set_stream_access_ = false;
+  clear_has_can_set_stream_access();
+}
+inline bool ClubPrivilegeSet::can_set_stream_access() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_access)
+  return can_set_stream_access_;
+}
+inline void ClubPrivilegeSet::set_can_set_stream_access(bool value) {
+  set_has_can_set_stream_access();
+  can_set_stream_access_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_access)
+}
+
+// optional bool can_set_stream_voice_level = 147;
+inline bool ClubPrivilegeSet::has_can_set_stream_voice_level() const {
+  return (_has_bits_[1] & 0x00000040u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_set_stream_voice_level() {
+  _has_bits_[1] |= 0x00000040u;
+}
+inline void ClubPrivilegeSet::clear_has_can_set_stream_voice_level() {
+  _has_bits_[1] &= ~0x00000040u;
+}
+inline void ClubPrivilegeSet::clear_can_set_stream_voice_level() {
+  can_set_stream_voice_level_ = false;
+  clear_has_can_set_stream_voice_level();
+}
+inline bool ClubPrivilegeSet::can_set_stream_voice_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_voice_level)
+  return can_set_stream_voice_level_;
+}
+inline void ClubPrivilegeSet::set_can_set_stream_voice_level(bool value) {
+  set_has_can_set_stream_voice_level();
+  can_set_stream_voice_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_set_stream_voice_level)
+}
+
+// optional bool can_create_message = 180;
+inline bool ClubPrivilegeSet::has_can_create_message() const {
+  return (_has_bits_[1] & 0x00000080u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_create_message() {
+  _has_bits_[1] |= 0x00000080u;
+}
+inline void ClubPrivilegeSet::clear_has_can_create_message() {
+  _has_bits_[1] &= ~0x00000080u;
+}
+inline void ClubPrivilegeSet::clear_can_create_message() {
+  can_create_message_ = false;
+  clear_has_can_create_message();
+}
+inline bool ClubPrivilegeSet::can_create_message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_create_message)
+  return can_create_message_;
+}
+inline void ClubPrivilegeSet::set_can_create_message(bool value) {
+  set_has_can_create_message();
+  can_create_message_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_create_message)
+}
+
+// optional bool can_destroy_own_message = 181;
+inline bool ClubPrivilegeSet::has_can_destroy_own_message() const {
+  return (_has_bits_[1] & 0x00000100u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_destroy_own_message() {
+  _has_bits_[1] |= 0x00000100u;
+}
+inline void ClubPrivilegeSet::clear_has_can_destroy_own_message() {
+  _has_bits_[1] &= ~0x00000100u;
+}
+inline void ClubPrivilegeSet::clear_can_destroy_own_message() {
+  can_destroy_own_message_ = false;
+  clear_has_can_destroy_own_message();
+}
+inline bool ClubPrivilegeSet::can_destroy_own_message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy_own_message)
+  return can_destroy_own_message_;
+}
+inline void ClubPrivilegeSet::set_can_destroy_own_message(bool value) {
+  set_has_can_destroy_own_message();
+  can_destroy_own_message_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy_own_message)
+}
+
+// optional bool can_destroy_other_message = 182;
+inline bool ClubPrivilegeSet::has_can_destroy_other_message() const {
+  return (_has_bits_[1] & 0x00000200u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_destroy_other_message() {
+  _has_bits_[1] |= 0x00000200u;
+}
+inline void ClubPrivilegeSet::clear_has_can_destroy_other_message() {
+  _has_bits_[1] &= ~0x00000200u;
+}
+inline void ClubPrivilegeSet::clear_can_destroy_other_message() {
+  can_destroy_other_message_ = false;
+  clear_has_can_destroy_other_message();
+}
+inline bool ClubPrivilegeSet::can_destroy_other_message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy_other_message)
+  return can_destroy_other_message_;
+}
+inline void ClubPrivilegeSet::set_can_destroy_other_message(bool value) {
+  set_has_can_destroy_other_message();
+  can_destroy_other_message_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_destroy_other_message)
+}
+
+// optional bool can_edit_own_message = 183;
+inline bool ClubPrivilegeSet::has_can_edit_own_message() const {
+  return (_has_bits_[1] & 0x00000400u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_edit_own_message() {
+  _has_bits_[1] |= 0x00000400u;
+}
+inline void ClubPrivilegeSet::clear_has_can_edit_own_message() {
+  _has_bits_[1] &= ~0x00000400u;
+}
+inline void ClubPrivilegeSet::clear_can_edit_own_message() {
+  can_edit_own_message_ = false;
+  clear_has_can_edit_own_message();
+}
+inline bool ClubPrivilegeSet::can_edit_own_message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_edit_own_message)
+  return can_edit_own_message_;
+}
+inline void ClubPrivilegeSet::set_can_edit_own_message(bool value) {
+  set_has_can_edit_own_message();
+  can_edit_own_message_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_edit_own_message)
+}
+
+// optional bool can_pin_message = 184;
+inline bool ClubPrivilegeSet::has_can_pin_message() const {
+  return (_has_bits_[1] & 0x00000800u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_pin_message() {
+  _has_bits_[1] |= 0x00000800u;
+}
+inline void ClubPrivilegeSet::clear_has_can_pin_message() {
+  _has_bits_[1] &= ~0x00000800u;
+}
+inline void ClubPrivilegeSet::clear_can_pin_message() {
+  can_pin_message_ = false;
+  clear_has_can_pin_message();
+}
+inline bool ClubPrivilegeSet::can_pin_message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_pin_message)
+  return can_pin_message_;
+}
+inline void ClubPrivilegeSet::set_can_pin_message(bool value) {
+  set_has_can_pin_message();
+  can_pin_message_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_pin_message)
+}
+
+// optional bool can_mention_all = 185;
+inline bool ClubPrivilegeSet::has_can_mention_all() const {
+  return (_has_bits_[1] & 0x00001000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_mention_all() {
+  _has_bits_[1] |= 0x00001000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_mention_all() {
+  _has_bits_[1] &= ~0x00001000u;
+}
+inline void ClubPrivilegeSet::clear_can_mention_all() {
+  can_mention_all_ = false;
+  clear_has_can_mention_all();
+}
+inline bool ClubPrivilegeSet::can_mention_all() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_mention_all)
+  return can_mention_all_;
+}
+inline void ClubPrivilegeSet::set_can_mention_all(bool value) {
+  set_has_can_mention_all();
+  can_mention_all_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_mention_all)
+}
+
+// optional bool can_mention_here = 186;
+inline bool ClubPrivilegeSet::has_can_mention_here() const {
+  return (_has_bits_[1] & 0x00002000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_mention_here() {
+  _has_bits_[1] |= 0x00002000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_mention_here() {
+  _has_bits_[1] &= ~0x00002000u;
+}
+inline void ClubPrivilegeSet::clear_can_mention_here() {
+  can_mention_here_ = false;
+  clear_has_can_mention_here();
+}
+inline bool ClubPrivilegeSet::can_mention_here() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_mention_here)
+  return can_mention_here_;
+}
+inline void ClubPrivilegeSet::set_can_mention_here(bool value) {
+  set_has_can_mention_here();
+  can_mention_here_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_mention_here)
+}
+
+// optional bool can_mention_member = 187;
+inline bool ClubPrivilegeSet::has_can_mention_member() const {
+  return (_has_bits_[1] & 0x00004000u) != 0;
+}
+inline void ClubPrivilegeSet::set_has_can_mention_member() {
+  _has_bits_[1] |= 0x00004000u;
+}
+inline void ClubPrivilegeSet::clear_has_can_mention_member() {
+  _has_bits_[1] &= ~0x00004000u;
+}
+inline void ClubPrivilegeSet::clear_can_mention_member() {
+  can_mention_member_ = false;
+  clear_has_can_mention_member();
+}
+inline bool ClubPrivilegeSet::can_mention_member() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubPrivilegeSet.can_mention_member)
+  return can_mention_member_;
+}
+inline void ClubPrivilegeSet::set_can_mention_member(bool value) {
+  set_has_can_mention_member();
+  can_mention_member_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubPrivilegeSet.can_mention_member)
+}
+
+// -------------------------------------------------------------------
+
+// ClubRole
+
+// optional uint32 id = 1;
+inline bool ClubRole::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClubRole::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClubRole::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClubRole::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 ClubRole::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubRole.id)
+  return id_;
+}
+inline void ClubRole::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubRole.id)
+}
+
+// optional .bgs.protocol.RoleState state = 2;
+inline bool ClubRole::has_state() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClubRole::set_has_state() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClubRole::clear_has_state() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClubRole::clear_state() {
+  if (state_ != NULL) state_->::bgs::protocol::RoleState::Clear();
+  clear_has_state();
+}
+inline const ::bgs::protocol::RoleState& ClubRole::state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubRole.state)
+  return state_ != NULL ? *state_ : *default_instance_->state_;
+}
+inline ::bgs::protocol::RoleState* ClubRole::mutable_state() {
+  set_has_state();
+  if (state_ == NULL) state_ = new ::bgs::protocol::RoleState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubRole.state)
+  return state_;
+}
+inline ::bgs::protocol::RoleState* ClubRole::release_state() {
+  clear_has_state();
+  ::bgs::protocol::RoleState* temp = state_;
+  state_ = NULL;
+  return temp;
+}
+inline void ClubRole::set_allocated_state(::bgs::protocol::RoleState* state) {
+  delete state_;
+  state_ = state;
+  if (state) {
+    set_has_state();
+  } else {
+    clear_has_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubRole.state)
+}
+
+// optional .bgs.protocol.club.v1.ClubPrivilegeSet privilege = 3;
+inline bool ClubRole::has_privilege() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubRole::set_has_privilege() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubRole::clear_has_privilege() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubRole::clear_privilege() {
+  if (privilege_ != NULL) privilege_->::bgs::protocol::club::v1::ClubPrivilegeSet::Clear();
+  clear_has_privilege();
+}
+inline const ::bgs::protocol::club::v1::ClubPrivilegeSet& ClubRole::privilege() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubRole.privilege)
+  return privilege_ != NULL ? *privilege_ : *default_instance_->privilege_;
+}
+inline ::bgs::protocol::club::v1::ClubPrivilegeSet* ClubRole::mutable_privilege() {
+  set_has_privilege();
+  if (privilege_ == NULL) privilege_ = new ::bgs::protocol::club::v1::ClubPrivilegeSet;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubRole.privilege)
+  return privilege_;
+}
+inline ::bgs::protocol::club::v1::ClubPrivilegeSet* ClubRole::release_privilege() {
+  clear_has_privilege();
+  ::bgs::protocol::club::v1::ClubPrivilegeSet* temp = privilege_;
+  privilege_ = NULL;
+  return temp;
+}
+inline void ClubRole::set_allocated_privilege(::bgs::protocol::club::v1::ClubPrivilegeSet* privilege) {
+  delete privilege_;
+  privilege_ = privilege;
+  if (privilege) {
+    set_has_privilege();
+  } else {
+    clear_has_privilege();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubRole.privilege)
+}
+
+// optional bool always_grant_stream_access = 4;
+inline bool ClubRole::has_always_grant_stream_access() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubRole::set_has_always_grant_stream_access() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubRole::clear_has_always_grant_stream_access() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubRole::clear_always_grant_stream_access() {
+  always_grant_stream_access_ = false;
+  clear_has_always_grant_stream_access();
+}
+inline bool ClubRole::always_grant_stream_access() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubRole.always_grant_stream_access)
+  return always_grant_stream_access_;
+}
+inline void ClubRole::set_always_grant_stream_access(bool value) {
+  set_has_always_grant_stream_access();
+  always_grant_stream_access_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubRole.always_grant_stream_access)
+}
+
+// optional bool allow_in_club_slot = 5;
+inline bool ClubRole::has_allow_in_club_slot() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClubRole::set_has_allow_in_club_slot() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClubRole::clear_has_allow_in_club_slot() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClubRole::clear_allow_in_club_slot() {
+  allow_in_club_slot_ = false;
+  clear_has_allow_in_club_slot();
+}
+inline bool ClubRole::allow_in_club_slot() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubRole.allow_in_club_slot)
+  return allow_in_club_slot_;
+}
+inline void ClubRole::set_allow_in_club_slot(bool value) {
+  set_has_allow_in_club_slot();
+  allow_in_club_slot_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubRole.allow_in_club_slot)
+}
+
+// -------------------------------------------------------------------
+
+// ClubRoleSet
+
+// repeated .bgs.protocol.club.v1.ClubRole role = 1;
+inline int ClubRoleSet::role_size() const {
+  return role_.size();
+}
+inline void ClubRoleSet::clear_role() {
+  role_.Clear();
+}
+inline const ::bgs::protocol::club::v1::ClubRole& ClubRoleSet::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubRoleSet.role)
+  return role_.Get(index);
+}
+inline ::bgs::protocol::club::v1::ClubRole* ClubRoleSet::mutable_role(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubRoleSet.role)
+  return role_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::ClubRole* ClubRoleSet::add_role() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubRoleSet.role)
+  return role_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubRole >&
+ClubRoleSet::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubRoleSet.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ClubRole >*
+ClubRoleSet::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubRoleSet.role)
+  return &role_;
+}
+
+// repeated uint32 default_role = 5 [packed = true];
+inline int ClubRoleSet::default_role_size() const {
+  return default_role_.size();
+}
+inline void ClubRoleSet::clear_default_role() {
+  default_role_.Clear();
+}
+inline ::google::protobuf::uint32 ClubRoleSet::default_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubRoleSet.default_role)
+  return default_role_.Get(index);
+}
+inline void ClubRoleSet::set_default_role(int index, ::google::protobuf::uint32 value) {
+  default_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubRoleSet.default_role)
+}
+inline void ClubRoleSet::add_default_role(::google::protobuf::uint32 value) {
+  default_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubRoleSet.default_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+ClubRoleSet::default_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubRoleSet.default_role)
+  return default_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+ClubRoleSet::mutable_default_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubRoleSet.default_role)
+  return &default_role_;
+}
+
+// optional bool assignment_respects_relegation_chain = 6;
+inline bool ClubRoleSet::has_assignment_respects_relegation_chain() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClubRoleSet::set_has_assignment_respects_relegation_chain() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClubRoleSet::clear_has_assignment_respects_relegation_chain() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClubRoleSet::clear_assignment_respects_relegation_chain() {
+  assignment_respects_relegation_chain_ = false;
+  clear_has_assignment_respects_relegation_chain();
+}
+inline bool ClubRoleSet::assignment_respects_relegation_chain() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubRoleSet.assignment_respects_relegation_chain)
+  return assignment_respects_relegation_chain_;
+}
+inline void ClubRoleSet::set_assignment_respects_relegation_chain(bool value) {
+  set_has_assignment_respects_relegation_chain();
+  assignment_respects_relegation_chain_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubRoleSet.assignment_respects_relegation_chain)
+}
+
+// optional string subtype = 7;
+inline bool ClubRoleSet::has_subtype() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClubRoleSet::set_has_subtype() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClubRoleSet::clear_has_subtype() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClubRoleSet::clear_subtype() {
+  if (subtype_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subtype_->clear();
+  }
+  clear_has_subtype();
+}
+inline const ::std::string& ClubRoleSet::subtype() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubRoleSet.subtype)
+  return *subtype_;
+}
+inline void ClubRoleSet::set_subtype(const ::std::string& value) {
+  set_has_subtype();
+  if (subtype_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subtype_ = new ::std::string;
+  }
+  subtype_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ClubRoleSet.subtype)
+}
+inline void ClubRoleSet::set_subtype(const char* value) {
+  set_has_subtype();
+  if (subtype_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subtype_ = new ::std::string;
+  }
+  subtype_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ClubRoleSet.subtype)
+}
+inline void ClubRoleSet::set_subtype(const char* value, size_t size) {
+  set_has_subtype();
+  if (subtype_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subtype_ = new ::std::string;
+  }
+  subtype_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ClubRoleSet.subtype)
+}
+inline ::std::string* ClubRoleSet::mutable_subtype() {
+  set_has_subtype();
+  if (subtype_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subtype_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubRoleSet.subtype)
+  return subtype_;
+}
+inline ::std::string* ClubRoleSet::release_subtype() {
+  clear_has_subtype();
+  if (subtype_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = subtype_;
+    subtype_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClubRoleSet::set_allocated_subtype(::std::string* subtype) {
+  if (subtype_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subtype_;
+  }
+  if (subtype) {
+    set_has_subtype();
+    subtype_ = subtype;
+  } else {
+    clear_has_subtype();
+    subtype_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ClubRoleSet.subtype)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5frole_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_stream.pb.cc b/src/server/proto/Client/club_stream.pb.cc
new file mode 100644
index 00000000000..6a270d05ad3
--- /dev/null
+++ b/src/server/proto/Client/club_stream.pb.cc
@@ -0,0 +1,6766 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_stream.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_stream.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* StreamPosition_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamPosition_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamAccess_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamAccess_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateStreamOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateStreamOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Stream_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Stream_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MentionContent_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MentionContent_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateMessageOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateMessageOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClubStreamMessageContainer_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClubStreamMessageContainer_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ContentChain_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ContentChain_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamMessage_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamMessage_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamMention_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamMention_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamView_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamView_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamAdvanceViewTime_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamAdvanceViewTime_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamEventTime_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamEventTime_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamMentionView_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamMentionView_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamStateOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamStateOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamStateAssignment_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamStateAssignment_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StreamTypingIndicator_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StreamTypingIndicator_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5fstream_2eproto() {
+  protobuf_AddDesc_club_5fstream_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_stream.proto");
+  GOOGLE_CHECK(file != NULL);
+  StreamPosition_descriptor_ = file->message_type(0);
+  static const int StreamPosition_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamPosition, stream_id_),
+  };
+  StreamPosition_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamPosition_descriptor_,
+      StreamPosition::default_instance_,
+      StreamPosition_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamPosition, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamPosition, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamPosition));
+  StreamAccess_descriptor_ = file->message_type(1);
+  static const int StreamAccess_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAccess, role_),
+  };
+  StreamAccess_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamAccess_descriptor_,
+      StreamAccess::default_instance_,
+      StreamAccess_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAccess, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAccess, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamAccess));
+  CreateStreamOptions_descriptor_ = file->message_type(2);
+  static const int CreateStreamOptions_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamOptions, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamOptions, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamOptions, subject_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamOptions, access_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamOptions, voice_level_),
+  };
+  CreateStreamOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateStreamOptions_descriptor_,
+      CreateStreamOptions::default_instance_,
+      CreateStreamOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateStreamOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateStreamOptions));
+  Stream_descriptor_ = file->message_type(3);
+  static const int Stream_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, subject_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, access_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, voice_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, creation_time_),
+  };
+  Stream_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Stream_descriptor_,
+      Stream::default_instance_,
+      Stream_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Stream, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Stream));
+  MentionContent_descriptor_ = file->message_type(4);
+  static const int MentionContent_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MentionContent, all_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MentionContent, here_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MentionContent, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MentionContent, role_),
+  };
+  MentionContent_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MentionContent_descriptor_,
+      MentionContent::default_instance_,
+      MentionContent_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MentionContent, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MentionContent, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MentionContent));
+  CreateMessageOptions_descriptor_ = file->message_type(5);
+  static const int CreateMessageOptions_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageOptions, content_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageOptions, mention_),
+  };
+  CreateMessageOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateMessageOptions_descriptor_,
+      CreateMessageOptions::default_instance_,
+      CreateMessageOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateMessageOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateMessageOptions));
+  ClubStreamMessageContainer_descriptor_ = file->message_type(6);
+  static const int ClubStreamMessageContainer_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStreamMessageContainer, message_),
+  };
+  ClubStreamMessageContainer_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClubStreamMessageContainer_descriptor_,
+      ClubStreamMessageContainer::default_instance_,
+      ClubStreamMessageContainer_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStreamMessageContainer, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClubStreamMessageContainer, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClubStreamMessageContainer));
+  ContentChain_descriptor_ = file->message_type(7);
+  static const int ContentChain_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentChain, content_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentChain, embed_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentChain, mention_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentChain, edit_time_),
+  };
+  ContentChain_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ContentChain_descriptor_,
+      ContentChain::default_instance_,
+      ContentChain_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentChain, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentChain, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ContentChain));
+  StreamMessage_descriptor_ = file->message_type(8);
+  static const int StreamMessage_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessage, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessage, author_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessage, content_chain_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessage, destroyer_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessage, destroyed_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessage, destroy_time_),
+  };
+  StreamMessage_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamMessage_descriptor_,
+      StreamMessage::default_instance_,
+      StreamMessage_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessage, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMessage, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamMessage));
+  StreamMention_descriptor_ = file->message_type(9);
+  static const int StreamMention_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMention, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMention, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMention, message_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMention, author_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMention, destroyed_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMention, mention_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMention, member_id_),
+  };
+  StreamMention_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamMention_descriptor_,
+      StreamMention::default_instance_,
+      StreamMention_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMention, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMention, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamMention));
+  StreamView_descriptor_ = file->message_type(10);
+  static const int StreamView_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamView, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamView, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamView, marker_),
+  };
+  StreamView_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamView_descriptor_,
+      StreamView::default_instance_,
+      StreamView_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamView, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamView, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamView));
+  StreamAdvanceViewTime_descriptor_ = file->message_type(11);
+  static const int StreamAdvanceViewTime_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTime, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTime, view_time_),
+  };
+  StreamAdvanceViewTime_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamAdvanceViewTime_descriptor_,
+      StreamAdvanceViewTime::default_instance_,
+      StreamAdvanceViewTime_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTime, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamAdvanceViewTime, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamAdvanceViewTime));
+  StreamEventTime_descriptor_ = file->message_type(12);
+  static const int StreamEventTime_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamEventTime, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamEventTime, event_time_),
+  };
+  StreamEventTime_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamEventTime_descriptor_,
+      StreamEventTime::default_instance_,
+      StreamEventTime_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamEventTime, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamEventTime, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamEventTime));
+  StreamMentionView_descriptor_ = file->message_type(13);
+  static const int StreamMentionView_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionView, club_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionView, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionView, marker_),
+  };
+  StreamMentionView_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamMentionView_descriptor_,
+      StreamMentionView::default_instance_,
+      StreamMentionView_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionView, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamMentionView, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamMentionView));
+  StreamStateOptions_descriptor_ = file->message_type(14);
+  static const int StreamStateOptions_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateOptions, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateOptions, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateOptions, subject_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateOptions, access_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateOptions, voice_level_),
+  };
+  StreamStateOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamStateOptions_descriptor_,
+      StreamStateOptions::default_instance_,
+      StreamStateOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamStateOptions));
+  StreamStateAssignment_descriptor_ = file->message_type(15);
+  static const int StreamStateAssignment_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateAssignment, stream_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateAssignment, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateAssignment, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateAssignment, subject_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateAssignment, access_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateAssignment, stream_subscription_removed_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateAssignment, voice_level_),
+  };
+  StreamStateAssignment_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamStateAssignment_descriptor_,
+      StreamStateAssignment::default_instance_,
+      StreamStateAssignment_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateAssignment, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamStateAssignment, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamStateAssignment));
+  StreamTypingIndicator_descriptor_ = file->message_type(16);
+  static const int StreamTypingIndicator_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicator, author_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicator, indicator_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicator, epoch_),
+  };
+  StreamTypingIndicator_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StreamTypingIndicator_descriptor_,
+      StreamTypingIndicator::default_instance_,
+      StreamTypingIndicator_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicator, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StreamTypingIndicator, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StreamTypingIndicator));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5fstream_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamPosition_descriptor_, &StreamPosition::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamAccess_descriptor_, &StreamAccess::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateStreamOptions_descriptor_, &CreateStreamOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Stream_descriptor_, &Stream::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MentionContent_descriptor_, &MentionContent::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateMessageOptions_descriptor_, &CreateMessageOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClubStreamMessageContainer_descriptor_, &ClubStreamMessageContainer::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ContentChain_descriptor_, &ContentChain::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamMessage_descriptor_, &StreamMessage::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamMention_descriptor_, &StreamMention::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamView_descriptor_, &StreamView::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamAdvanceViewTime_descriptor_, &StreamAdvanceViewTime::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamEventTime_descriptor_, &StreamEventTime::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamMentionView_descriptor_, &StreamMentionView::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamStateOptions_descriptor_, &StreamStateOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamStateAssignment_descriptor_, &StreamStateAssignment::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StreamTypingIndicator_descriptor_, &StreamTypingIndicator::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5fstream_2eproto() {
+  delete StreamPosition::default_instance_;
+  delete StreamPosition_reflection_;
+  delete StreamAccess::default_instance_;
+  delete StreamAccess_reflection_;
+  delete CreateStreamOptions::default_instance_;
+  delete CreateStreamOptions_reflection_;
+  delete Stream::default_instance_;
+  delete Stream_reflection_;
+  delete MentionContent::default_instance_;
+  delete MentionContent_reflection_;
+  delete CreateMessageOptions::default_instance_;
+  delete CreateMessageOptions_reflection_;
+  delete ClubStreamMessageContainer::default_instance_;
+  delete ClubStreamMessageContainer_reflection_;
+  delete ContentChain::default_instance_;
+  delete ContentChain_reflection_;
+  delete StreamMessage::default_instance_;
+  delete StreamMessage_reflection_;
+  delete StreamMention::default_instance_;
+  delete StreamMention_reflection_;
+  delete StreamView::default_instance_;
+  delete StreamView_reflection_;
+  delete StreamAdvanceViewTime::default_instance_;
+  delete StreamAdvanceViewTime_reflection_;
+  delete StreamEventTime::default_instance_;
+  delete StreamEventTime_reflection_;
+  delete StreamMentionView::default_instance_;
+  delete StreamMentionView_reflection_;
+  delete StreamStateOptions::default_instance_;
+  delete StreamStateOptions_reflection_;
+  delete StreamStateAssignment::default_instance_;
+  delete StreamStateAssignment_reflection_;
+  delete StreamTypingIndicator::default_instance_;
+  delete StreamTypingIndicator_reflection_;
+}
+
+void protobuf_AddDesc_club_5fstream_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fenum_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fmember_2eproto();
+  ::bgs::protocol::v2::protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_embed_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_message_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_ets_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\021club_stream.proto\022\024bgs.protocol.club.v"
+    "1\032\017club_enum.proto\032\021club_member.proto\032#a"
+    "pi/client/v2/attribute_types.proto\032\021embe"
+    "d_types.proto\032\026event_view_types.proto\032\023m"
+    "essage_types.proto\032\017ets_types.proto\"\'\n\016S"
+    "treamPosition\022\025\n\tstream_id\030\001 \003(\004B\002\020\001\" \n\014"
+    "StreamAccess\022\020\n\004role\030\001 \003(\rB\002\020\001\"\324\001\n\023Creat"
+    "eStreamOptions\022-\n\tattribute\030\001 \003(\0132\032.bgs."
+    "protocol.v2.Attribute\022\014\n\004name\030\002 \001(\t\022\017\n\007s"
+    "ubject\030\003 \001(\t\0222\n\006access\030\004 \001(\0132\".bgs.proto"
+    "col.club.v1.StreamAccess\022;\n\013voice_level\030"
+    "\005 \001(\0162&.bgs.protocol.club.v1.StreamVoice"
+    "Level\"\373\001\n\006Stream\022\017\n\007club_id\030\001 \001(\004\022\n\n\002id\030"
+    "\002 \001(\004\022-\n\tattribute\030\003 \003(\0132\032.bgs.protocol."
+    "v2.Attribute\022\014\n\004name\030\004 \001(\t\022\017\n\007subject\030\005 "
+    "\001(\t\0222\n\006access\030\006 \001(\0132\".bgs.protocol.club."
+    "v1.StreamAccess\022;\n\013voice_level\030\007 \001(\0162&.b"
+    "gs.protocol.club.v1.StreamVoiceLevel\022\025\n\r"
+    "creation_time\030\010 \001(\004\"p\n\016MentionContent\022\013\n"
+    "\003all\030\001 \001(\010\022\014\n\004here\030\002 \001(\010\0221\n\tmember_id\030\003 "
+    "\003(\0132\036.bgs.protocol.club.v1.MemberId\022\020\n\004r"
+    "ole\030\004 \003(\rB\002\020\001\"^\n\024CreateMessageOptions\022\017\n"
+    "\007content\030\002 \001(\t\0225\n\007mention\030\003 \001(\0132$.bgs.pr"
+    "otocol.club.v1.MentionContent\"R\n\032ClubStr"
+    "eamMessageContainer\0224\n\007message\030\001 \003(\0132#.b"
+    "gs.protocol.club.v1.StreamMessage\"\221\001\n\014Co"
+    "ntentChain\022\017\n\007content\030\005 \001(\t\022&\n\005embed\030\006 \003"
+    "(\0132\027.bgs.protocol.EmbedInfo\0225\n\007mention\030\007"
+    " \001(\0132$.bgs.protocol.club.v1.MentionConte"
+    "nt\022\021\n\tedit_time\030\010 \001(\004\"\215\002\n\rStreamMessage\022"
+    "#\n\002id\030\003 \001(\0132\027.bgs.protocol.MessageId\0227\n\006"
+    "author\030\004 \001(\0132\'.bgs.protocol.club.v1.Memb"
+    "erDescription\0229\n\rcontent_chain\030\006 \003(\0132\".b"
+    "gs.protocol.club.v1.ContentChain\022:\n\tdest"
+    "royer\030\017 \001(\0132\'.bgs.protocol.club.v1.Membe"
+    "rDescription\022\021\n\tdestroyed\030\020 \001(\010\022\024\n\014destr"
+    "oy_time\030\021 \001(\004\"\217\002\n\rStreamMention\022\017\n\007club_"
+    "id\030\001 \001(\004\022\021\n\tstream_id\030\002 \001(\004\022+\n\nmessage_i"
+    "d\030\003 \001(\0132\027.bgs.protocol.MessageId\0227\n\006auth"
+    "or\030\004 \001(\0132\'.bgs.protocol.club.v1.MemberDe"
+    "scription\022\021\n\tdestroyed\030\005 \001(\010\022.\n\nmention_"
+    "id\030\006 \001(\0132\032.bgs.protocol.TimeSeriesId\0221\n\t"
+    "member_id\030\007 \001(\0132\036.bgs.protocol.club.v1.M"
+    "emberId\"Z\n\nStreamView\022\017\n\007club_id\030\001 \001(\004\022\021"
+    "\n\tstream_id\030\002 \001(\004\022(\n\006marker\030\003 \001(\0132\030.bgs."
+    "protocol.ViewMarker\"=\n\025StreamAdvanceView"
+    "Time\022\021\n\tstream_id\030\001 \001(\004\022\021\n\tview_time\030\002 \001"
+    "(\004\"8\n\017StreamEventTime\022\021\n\tstream_id\030\001 \001(\004"
+    "\022\022\n\nevent_time\030\002 \001(\004\"a\n\021StreamMentionVie"
+    "w\022\017\n\007club_id\030\001 \001(\004\022\021\n\tstream_id\030\002 \001(\004\022(\n"
+    "\006marker\030\003 \001(\0132\030.bgs.protocol.ViewMarker\""
+    "\323\001\n\022StreamStateOptions\022-\n\tattribute\030\001 \003("
+    "\0132\032.bgs.protocol.v2.Attribute\022\014\n\004name\030\002 "
+    "\001(\t\022\017\n\007subject\030\003 \001(\t\0222\n\006access\030\004 \001(\0132\".b"
+    "gs.protocol.club.v1.StreamAccess\022;\n\013voic"
+    "e_level\030\005 \001(\0162&.bgs.protocol.club.v1.Str"
+    "eamVoiceLevel\"\216\002\n\025StreamStateAssignment\022"
+    "\021\n\tstream_id\030\001 \001(\004\022-\n\tattribute\030\002 \003(\0132\032."
+    "bgs.protocol.v2.Attribute\022\014\n\004name\030\003 \001(\t\022"
+    "\017\n\007subject\030\004 \001(\t\0222\n\006access\030\005 \001(\0132\".bgs.p"
+    "rotocol.club.v1.StreamAccess\022#\n\033stream_s"
+    "ubscription_removed\030\006 \001(\010\022;\n\013voice_level"
+    "\030\007 \001(\0162&.bgs.protocol.club.v1.StreamVoic"
+    "eLevel\"\213\001\n\025StreamTypingIndicator\0221\n\tauth"
+    "or_id\030\001 \001(\0132\036.bgs.protocol.club.v1.Membe"
+    "rId\0220\n\tindicator\030\002 \001(\0162\035.bgs.protocol.Ty"
+    "pingIndicator\022\r\n\005epoch\030\003 \001(\004B\002H\001", 2672);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_stream.proto", &protobuf_RegisterTypes);
+  StreamPosition::default_instance_ = new StreamPosition();
+  StreamAccess::default_instance_ = new StreamAccess();
+  CreateStreamOptions::default_instance_ = new CreateStreamOptions();
+  Stream::default_instance_ = new Stream();
+  MentionContent::default_instance_ = new MentionContent();
+  CreateMessageOptions::default_instance_ = new CreateMessageOptions();
+  ClubStreamMessageContainer::default_instance_ = new ClubStreamMessageContainer();
+  ContentChain::default_instance_ = new ContentChain();
+  StreamMessage::default_instance_ = new StreamMessage();
+  StreamMention::default_instance_ = new StreamMention();
+  StreamView::default_instance_ = new StreamView();
+  StreamAdvanceViewTime::default_instance_ = new StreamAdvanceViewTime();
+  StreamEventTime::default_instance_ = new StreamEventTime();
+  StreamMentionView::default_instance_ = new StreamMentionView();
+  StreamStateOptions::default_instance_ = new StreamStateOptions();
+  StreamStateAssignment::default_instance_ = new StreamStateAssignment();
+  StreamTypingIndicator::default_instance_ = new StreamTypingIndicator();
+  StreamPosition::default_instance_->InitAsDefaultInstance();
+  StreamAccess::default_instance_->InitAsDefaultInstance();
+  CreateStreamOptions::default_instance_->InitAsDefaultInstance();
+  Stream::default_instance_->InitAsDefaultInstance();
+  MentionContent::default_instance_->InitAsDefaultInstance();
+  CreateMessageOptions::default_instance_->InitAsDefaultInstance();
+  ClubStreamMessageContainer::default_instance_->InitAsDefaultInstance();
+  ContentChain::default_instance_->InitAsDefaultInstance();
+  StreamMessage::default_instance_->InitAsDefaultInstance();
+  StreamMention::default_instance_->InitAsDefaultInstance();
+  StreamView::default_instance_->InitAsDefaultInstance();
+  StreamAdvanceViewTime::default_instance_->InitAsDefaultInstance();
+  StreamEventTime::default_instance_->InitAsDefaultInstance();
+  StreamMentionView::default_instance_->InitAsDefaultInstance();
+  StreamStateOptions::default_instance_->InitAsDefaultInstance();
+  StreamStateAssignment::default_instance_->InitAsDefaultInstance();
+  StreamTypingIndicator::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5fstream_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5fstream_2eproto {
+  StaticDescriptorInitializer_club_5fstream_2eproto() {
+    protobuf_AddDesc_club_5fstream_2eproto();
+  }
+} static_descriptor_initializer_club_5fstream_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamPosition::kStreamIdFieldNumber;
+#endif  // !_MSC_VER
+
+StreamPosition::StreamPosition()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamPosition)
+}
+
+void StreamPosition::InitAsDefaultInstance() {
+}
+
+StreamPosition::StreamPosition(const StreamPosition& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamPosition)
+}
+
+void StreamPosition::SharedCtor() {
+  _cached_size_ = 0;
+  _stream_id_cached_byte_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamPosition::~StreamPosition() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamPosition)
+  SharedDtor();
+}
+
+void StreamPosition::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void StreamPosition::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamPosition::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamPosition_descriptor_;
+}
+
+const StreamPosition& StreamPosition::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamPosition* StreamPosition::default_instance_ = NULL;
+
+StreamPosition* StreamPosition::New() const {
+  return new StreamPosition;
+}
+
+void StreamPosition::Clear() {
+  stream_id_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamPosition::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamPosition)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated uint64 stream_id = 1 [packed = true];
+      case 1: {
+        if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, this->mutable_stream_id())));
+        } else if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 1, 10, input, this->mutable_stream_id())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamPosition)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamPosition)
+  return false;
+#undef DO_
+}
+
+void StreamPosition::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamPosition)
+  // repeated uint64 stream_id = 1 [packed = true];
+  if (this->stream_id_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_stream_id_cached_byte_size_);
+  }
+  for (int i = 0; i < this->stream_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64NoTag(
+      this->stream_id(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamPosition)
+}
+
+::google::protobuf::uint8* StreamPosition::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamPosition)
+  // repeated uint64 stream_id = 1 [packed = true];
+  if (this->stream_id_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      1,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _stream_id_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->stream_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt64NoTagToArray(this->stream_id(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamPosition)
+  return target;
+}
+
+int StreamPosition::ByteSize() const {
+  int total_size = 0;
+
+  // repeated uint64 stream_id = 1 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->stream_id_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt64Size(this->stream_id(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _stream_id_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamPosition::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamPosition* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamPosition*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamPosition::MergeFrom(const StreamPosition& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  stream_id_.MergeFrom(from.stream_id_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamPosition::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamPosition::CopyFrom(const StreamPosition& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamPosition::IsInitialized() const {
+
+  return true;
+}
+
+void StreamPosition::Swap(StreamPosition* other) {
+  if (other != this) {
+    stream_id_.Swap(&other->stream_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamPosition::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamPosition_descriptor_;
+  metadata.reflection = StreamPosition_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamAccess::kRoleFieldNumber;
+#endif  // !_MSC_VER
+
+StreamAccess::StreamAccess()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamAccess)
+}
+
+void StreamAccess::InitAsDefaultInstance() {
+}
+
+StreamAccess::StreamAccess(const StreamAccess& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamAccess)
+}
+
+void StreamAccess::SharedCtor() {
+  _cached_size_ = 0;
+  _role_cached_byte_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamAccess::~StreamAccess() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamAccess)
+  SharedDtor();
+}
+
+void StreamAccess::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void StreamAccess::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamAccess::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamAccess_descriptor_;
+}
+
+const StreamAccess& StreamAccess::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamAccess* StreamAccess::default_instance_ = NULL;
+
+StreamAccess* StreamAccess::New() const {
+  return new StreamAccess;
+}
+
+void StreamAccess::Clear() {
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamAccess::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamAccess)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated uint32 role = 1 [packed = true];
+      case 1: {
+        if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 10, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamAccess)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamAccess)
+  return false;
+#undef DO_
+}
+
+void StreamAccess::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamAccess)
+  // repeated uint32 role = 1 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamAccess)
+}
+
+::google::protobuf::uint8* StreamAccess::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamAccess)
+  // repeated uint32 role = 1 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      1,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamAccess)
+  return target;
+}
+
+int StreamAccess::ByteSize() const {
+  int total_size = 0;
+
+  // repeated uint32 role = 1 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamAccess::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamAccess* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamAccess*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamAccess::MergeFrom(const StreamAccess& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamAccess::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamAccess::CopyFrom(const StreamAccess& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamAccess::IsInitialized() const {
+
+  return true;
+}
+
+void StreamAccess::Swap(StreamAccess* other) {
+  if (other != this) {
+    role_.Swap(&other->role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamAccess::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamAccess_descriptor_;
+  metadata.reflection = StreamAccess_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateStreamOptions::kAttributeFieldNumber;
+const int CreateStreamOptions::kNameFieldNumber;
+const int CreateStreamOptions::kSubjectFieldNumber;
+const int CreateStreamOptions::kAccessFieldNumber;
+const int CreateStreamOptions::kVoiceLevelFieldNumber;
+#endif  // !_MSC_VER
+
+CreateStreamOptions::CreateStreamOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateStreamOptions)
+}
+
+void CreateStreamOptions::InitAsDefaultInstance() {
+  access_ = const_cast< ::bgs::protocol::club::v1::StreamAccess*>(&::bgs::protocol::club::v1::StreamAccess::default_instance());
+}
+
+CreateStreamOptions::CreateStreamOptions(const CreateStreamOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateStreamOptions)
+}
+
+void CreateStreamOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  access_ = NULL;
+  voice_level_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateStreamOptions::~CreateStreamOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateStreamOptions)
+  SharedDtor();
+}
+
+void CreateStreamOptions::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subject_;
+  }
+  if (this != default_instance_) {
+    delete access_;
+  }
+}
+
+void CreateStreamOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateStreamOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateStreamOptions_descriptor_;
+}
+
+const CreateStreamOptions& CreateStreamOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+CreateStreamOptions* CreateStreamOptions::default_instance_ = NULL;
+
+CreateStreamOptions* CreateStreamOptions::New() const {
+  return new CreateStreamOptions;
+}
+
+void CreateStreamOptions::Clear() {
+  if (_has_bits_[0 / 32] & 30) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_subject()) {
+      if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        subject_->clear();
+      }
+    }
+    if (has_access()) {
+      if (access_ != NULL) access_->::bgs::protocol::club::v1::StreamAccess::Clear();
+    }
+    voice_level_ = 0;
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateStreamOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateStreamOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.v2.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectTag(18)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_subject;
+        break;
+      }
+
+      // optional string subject = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_subject:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_subject()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->subject().data(), this->subject().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "subject");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_access;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_access:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_access()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_voice_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_voice_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::StreamVoiceLevel_IsValid(value)) {
+            set_voice_level(static_cast< ::bgs::protocol::club::v1::StreamVoiceLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(5, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateStreamOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateStreamOptions)
+  return false;
+#undef DO_
+}
+
+void CreateStreamOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateStreamOptions)
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->name(), output);
+  }
+
+  // optional string subject = 3;
+  if (has_subject()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subject().data(), this->subject().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subject");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->subject(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+  if (has_access()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->access(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+  if (has_voice_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->voice_level(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateStreamOptions)
+}
+
+::google::protobuf::uint8* CreateStreamOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateStreamOptions)
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+
+  // optional string subject = 3;
+  if (has_subject()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subject().data(), this->subject().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subject");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->subject(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+  if (has_access()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->access(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+  if (has_voice_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      5, this->voice_level(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateStreamOptions)
+  return target;
+}
+
+int CreateStreamOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional string name = 2;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string subject = 3;
+    if (has_subject()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->subject());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+    if (has_access()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->access());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+    if (has_voice_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->voice_level());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateStreamOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateStreamOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateStreamOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateStreamOptions::MergeFrom(const CreateStreamOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_subject()) {
+      set_subject(from.subject());
+    }
+    if (from.has_access()) {
+      mutable_access()->::bgs::protocol::club::v1::StreamAccess::MergeFrom(from.access());
+    }
+    if (from.has_voice_level()) {
+      set_voice_level(from.voice_level());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateStreamOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateStreamOptions::CopyFrom(const CreateStreamOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateStreamOptions::IsInitialized() const {
+
+  return true;
+}
+
+void CreateStreamOptions::Swap(CreateStreamOptions* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    std::swap(name_, other->name_);
+    std::swap(subject_, other->subject_);
+    std::swap(access_, other->access_);
+    std::swap(voice_level_, other->voice_level_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateStreamOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateStreamOptions_descriptor_;
+  metadata.reflection = CreateStreamOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Stream::kClubIdFieldNumber;
+const int Stream::kIdFieldNumber;
+const int Stream::kAttributeFieldNumber;
+const int Stream::kNameFieldNumber;
+const int Stream::kSubjectFieldNumber;
+const int Stream::kAccessFieldNumber;
+const int Stream::kVoiceLevelFieldNumber;
+const int Stream::kCreationTimeFieldNumber;
+#endif  // !_MSC_VER
+
+Stream::Stream()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.Stream)
+}
+
+void Stream::InitAsDefaultInstance() {
+  access_ = const_cast< ::bgs::protocol::club::v1::StreamAccess*>(&::bgs::protocol::club::v1::StreamAccess::default_instance());
+}
+
+Stream::Stream(const Stream& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.Stream)
+}
+
+void Stream::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  id_ = GOOGLE_ULONGLONG(0);
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  access_ = NULL;
+  voice_level_ = 0;
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Stream::~Stream() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.Stream)
+  SharedDtor();
+}
+
+void Stream::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subject_;
+  }
+  if (this != default_instance_) {
+    delete access_;
+  }
+}
+
+void Stream::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Stream::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Stream_descriptor_;
+}
+
+const Stream& Stream::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+Stream* Stream::default_instance_ = NULL;
+
+Stream* Stream::New() const {
+  return new Stream;
+}
+
+void Stream::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Stream*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 251) {
+    ZR_(club_id_, id_);
+    ZR_(creation_time_, voice_level_);
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_subject()) {
+      if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        subject_->clear();
+      }
+    }
+    if (has_access()) {
+      if (access_ != NULL) access_->::bgs::protocol::club::v1::StreamAccess::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Stream::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.Stream)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 club_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_id;
+        break;
+      }
+
+      // optional uint64 id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        if (input->ExpectTag(34)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_subject;
+        break;
+      }
+
+      // optional string subject = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_subject:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_subject()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->subject().data(), this->subject().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "subject");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_access;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamAccess access = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_access:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_access()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_voice_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_voice_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::StreamVoiceLevel_IsValid(value)) {
+            set_voice_level(static_cast< ::bgs::protocol::club::v1::StreamVoiceLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(7, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.Stream)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.Stream)
+  return false;
+#undef DO_
+}
+
+void Stream::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.Stream)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->club_id(), output);
+  }
+
+  // optional uint64 id = 2;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->id(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->attribute(i), output);
+  }
+
+  // optional string name = 4;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->name(), output);
+  }
+
+  // optional string subject = 5;
+  if (has_subject()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subject().data(), this->subject().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subject");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->subject(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 6;
+  if (has_access()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->access(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+  if (has_voice_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      7, this->voice_level(), output);
+  }
+
+  // optional uint64 creation_time = 8;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->creation_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.Stream)
+}
+
+::google::protobuf::uint8* Stream::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.Stream)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->club_id(), target);
+  }
+
+  // optional uint64 id = 2;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->id(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->attribute(i), target);
+  }
+
+  // optional string name = 4;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->name(), target);
+  }
+
+  // optional string subject = 5;
+  if (has_subject()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subject().data(), this->subject().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subject");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->subject(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 6;
+  if (has_access()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->access(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+  if (has_voice_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      7, this->voice_level(), target);
+  }
+
+  // optional uint64 creation_time = 8;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->creation_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.Stream)
+  return target;
+}
+
+int Stream::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 club_id = 1;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 id = 2;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->id());
+    }
+
+    // optional string name = 4;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string subject = 5;
+    if (has_subject()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->subject());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamAccess access = 6;
+    if (has_access()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->access());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+    if (has_voice_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->voice_level());
+    }
+
+    // optional uint64 creation_time = 8;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Stream::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Stream* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Stream*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Stream::MergeFrom(const Stream& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_subject()) {
+      set_subject(from.subject());
+    }
+    if (from.has_access()) {
+      mutable_access()->::bgs::protocol::club::v1::StreamAccess::MergeFrom(from.access());
+    }
+    if (from.has_voice_level()) {
+      set_voice_level(from.voice_level());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Stream::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Stream::CopyFrom(const Stream& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Stream::IsInitialized() const {
+
+  return true;
+}
+
+void Stream::Swap(Stream* other) {
+  if (other != this) {
+    std::swap(club_id_, other->club_id_);
+    std::swap(id_, other->id_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(name_, other->name_);
+    std::swap(subject_, other->subject_);
+    std::swap(access_, other->access_);
+    std::swap(voice_level_, other->voice_level_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Stream::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Stream_descriptor_;
+  metadata.reflection = Stream_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MentionContent::kAllFieldNumber;
+const int MentionContent::kHereFieldNumber;
+const int MentionContent::kMemberIdFieldNumber;
+const int MentionContent::kRoleFieldNumber;
+#endif  // !_MSC_VER
+
+MentionContent::MentionContent()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.MentionContent)
+}
+
+void MentionContent::InitAsDefaultInstance() {
+}
+
+MentionContent::MentionContent(const MentionContent& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.MentionContent)
+}
+
+void MentionContent::SharedCtor() {
+  _cached_size_ = 0;
+  all_ = false;
+  here_ = false;
+  _role_cached_byte_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MentionContent::~MentionContent() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.MentionContent)
+  SharedDtor();
+}
+
+void MentionContent::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void MentionContent::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MentionContent::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MentionContent_descriptor_;
+}
+
+const MentionContent& MentionContent::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+MentionContent* MentionContent::default_instance_ = NULL;
+
+MentionContent* MentionContent::New() const {
+  return new MentionContent;
+}
+
+void MentionContent::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<MentionContent*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(all_, here_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  member_id_.Clear();
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MentionContent::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.MentionContent)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool all = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &all_)));
+          set_has_all();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_here;
+        break;
+      }
+
+      // optional bool here = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_here:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &here_)));
+          set_has_here();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_member_id;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.MemberId member_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_member_id;
+        if (input->ExpectTag(34)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 4 [packed = true];
+      case 4: {
+        if (tag == 34) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 34, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.MentionContent)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.MentionContent)
+  return false;
+#undef DO_
+}
+
+void MentionContent::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.MentionContent)
+  // optional bool all = 1;
+  if (has_all()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->all(), output);
+  }
+
+  // optional bool here = 2;
+  if (has_here()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->here(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberId member_id = 3;
+  for (int i = 0; i < this->member_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->member_id(i), output);
+  }
+
+  // repeated uint32 role = 4 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.MentionContent)
+}
+
+::google::protobuf::uint8* MentionContent::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.MentionContent)
+  // optional bool all = 1;
+  if (has_all()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->all(), target);
+  }
+
+  // optional bool here = 2;
+  if (has_here()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->here(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.MemberId member_id = 3;
+  for (int i = 0; i < this->member_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->member_id(i), target);
+  }
+
+  // repeated uint32 role = 4 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      4,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.MentionContent)
+  return target;
+}
+
+int MentionContent::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool all = 1;
+    if (has_all()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool here = 2;
+    if (has_here()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.MemberId member_id = 3;
+  total_size += 1 * this->member_id_size();
+  for (int i = 0; i < this->member_id_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->member_id(i));
+  }
+
+  // repeated uint32 role = 4 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MentionContent::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MentionContent* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MentionContent*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MentionContent::MergeFrom(const MentionContent& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  member_id_.MergeFrom(from.member_id_);
+  role_.MergeFrom(from.role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_all()) {
+      set_all(from.all());
+    }
+    if (from.has_here()) {
+      set_here(from.here());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MentionContent::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MentionContent::CopyFrom(const MentionContent& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MentionContent::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->member_id())) return false;
+  return true;
+}
+
+void MentionContent::Swap(MentionContent* other) {
+  if (other != this) {
+    std::swap(all_, other->all_);
+    std::swap(here_, other->here_);
+    member_id_.Swap(&other->member_id_);
+    role_.Swap(&other->role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MentionContent::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MentionContent_descriptor_;
+  metadata.reflection = MentionContent_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateMessageOptions::kContentFieldNumber;
+const int CreateMessageOptions::kMentionFieldNumber;
+#endif  // !_MSC_VER
+
+CreateMessageOptions::CreateMessageOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.CreateMessageOptions)
+}
+
+void CreateMessageOptions::InitAsDefaultInstance() {
+  mention_ = const_cast< ::bgs::protocol::club::v1::MentionContent*>(&::bgs::protocol::club::v1::MentionContent::default_instance());
+}
+
+CreateMessageOptions::CreateMessageOptions(const CreateMessageOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.CreateMessageOptions)
+}
+
+void CreateMessageOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  mention_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateMessageOptions::~CreateMessageOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.CreateMessageOptions)
+  SharedDtor();
+}
+
+void CreateMessageOptions::SharedDtor() {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete content_;
+  }
+  if (this != default_instance_) {
+    delete mention_;
+  }
+}
+
+void CreateMessageOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateMessageOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateMessageOptions_descriptor_;
+}
+
+const CreateMessageOptions& CreateMessageOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+CreateMessageOptions* CreateMessageOptions::default_instance_ = NULL;
+
+CreateMessageOptions* CreateMessageOptions::New() const {
+  return new CreateMessageOptions;
+}
+
+void CreateMessageOptions::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_content()) {
+      if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        content_->clear();
+      }
+    }
+    if (has_mention()) {
+      if (mention_ != NULL) mention_->::bgs::protocol::club::v1::MentionContent::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateMessageOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.CreateMessageOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string content = 2;
+      case 2: {
+        if (tag == 18) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_content()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->content().data(), this->content().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "content");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_mention;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MentionContent mention = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_mention:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_mention()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.CreateMessageOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.CreateMessageOptions)
+  return false;
+#undef DO_
+}
+
+void CreateMessageOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.CreateMessageOptions)
+  // optional string content = 2;
+  if (has_content()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->content().data(), this->content().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "content");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->content(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MentionContent mention = 3;
+  if (has_mention()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->mention(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.CreateMessageOptions)
+}
+
+::google::protobuf::uint8* CreateMessageOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.CreateMessageOptions)
+  // optional string content = 2;
+  if (has_content()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->content().data(), this->content().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "content");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->content(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MentionContent mention = 3;
+  if (has_mention()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->mention(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.CreateMessageOptions)
+  return target;
+}
+
+int CreateMessageOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string content = 2;
+    if (has_content()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->content());
+    }
+
+    // optional .bgs.protocol.club.v1.MentionContent mention = 3;
+    if (has_mention()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->mention());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateMessageOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateMessageOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateMessageOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateMessageOptions::MergeFrom(const CreateMessageOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_content()) {
+      set_content(from.content());
+    }
+    if (from.has_mention()) {
+      mutable_mention()->::bgs::protocol::club::v1::MentionContent::MergeFrom(from.mention());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateMessageOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateMessageOptions::CopyFrom(const CreateMessageOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateMessageOptions::IsInitialized() const {
+
+  if (has_mention()) {
+    if (!this->mention().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CreateMessageOptions::Swap(CreateMessageOptions* other) {
+  if (other != this) {
+    std::swap(content_, other->content_);
+    std::swap(mention_, other->mention_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateMessageOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateMessageOptions_descriptor_;
+  metadata.reflection = CreateMessageOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClubStreamMessageContainer::kMessageFieldNumber;
+#endif  // !_MSC_VER
+
+ClubStreamMessageContainer::ClubStreamMessageContainer()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ClubStreamMessageContainer)
+}
+
+void ClubStreamMessageContainer::InitAsDefaultInstance() {
+}
+
+ClubStreamMessageContainer::ClubStreamMessageContainer(const ClubStreamMessageContainer& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ClubStreamMessageContainer)
+}
+
+void ClubStreamMessageContainer::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClubStreamMessageContainer::~ClubStreamMessageContainer() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ClubStreamMessageContainer)
+  SharedDtor();
+}
+
+void ClubStreamMessageContainer::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ClubStreamMessageContainer::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClubStreamMessageContainer::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClubStreamMessageContainer_descriptor_;
+}
+
+const ClubStreamMessageContainer& ClubStreamMessageContainer::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+ClubStreamMessageContainer* ClubStreamMessageContainer::default_instance_ = NULL;
+
+ClubStreamMessageContainer* ClubStreamMessageContainer::New() const {
+  return new ClubStreamMessageContainer;
+}
+
+void ClubStreamMessageContainer::Clear() {
+  message_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClubStreamMessageContainer::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ClubStreamMessageContainer)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_message;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ClubStreamMessageContainer)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ClubStreamMessageContainer)
+  return false;
+#undef DO_
+}
+
+void ClubStreamMessageContainer::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ClubStreamMessageContainer)
+  // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+  for (int i = 0; i < this->message_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->message(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ClubStreamMessageContainer)
+}
+
+::google::protobuf::uint8* ClubStreamMessageContainer::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ClubStreamMessageContainer)
+  // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+  for (int i = 0; i < this->message_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->message(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ClubStreamMessageContainer)
+  return target;
+}
+
+int ClubStreamMessageContainer::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+  total_size += 1 * this->message_size();
+  for (int i = 0; i < this->message_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->message(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClubStreamMessageContainer::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClubStreamMessageContainer* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClubStreamMessageContainer*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClubStreamMessageContainer::MergeFrom(const ClubStreamMessageContainer& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  message_.MergeFrom(from.message_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClubStreamMessageContainer::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClubStreamMessageContainer::CopyFrom(const ClubStreamMessageContainer& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClubStreamMessageContainer::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->message())) return false;
+  return true;
+}
+
+void ClubStreamMessageContainer::Swap(ClubStreamMessageContainer* other) {
+  if (other != this) {
+    message_.Swap(&other->message_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClubStreamMessageContainer::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClubStreamMessageContainer_descriptor_;
+  metadata.reflection = ClubStreamMessageContainer_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ContentChain::kContentFieldNumber;
+const int ContentChain::kEmbedFieldNumber;
+const int ContentChain::kMentionFieldNumber;
+const int ContentChain::kEditTimeFieldNumber;
+#endif  // !_MSC_VER
+
+ContentChain::ContentChain()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.ContentChain)
+}
+
+void ContentChain::InitAsDefaultInstance() {
+  mention_ = const_cast< ::bgs::protocol::club::v1::MentionContent*>(&::bgs::protocol::club::v1::MentionContent::default_instance());
+}
+
+ContentChain::ContentChain(const ContentChain& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.ContentChain)
+}
+
+void ContentChain::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  mention_ = NULL;
+  edit_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ContentChain::~ContentChain() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.ContentChain)
+  SharedDtor();
+}
+
+void ContentChain::SharedDtor() {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete content_;
+  }
+  if (this != default_instance_) {
+    delete mention_;
+  }
+}
+
+void ContentChain::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ContentChain::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ContentChain_descriptor_;
+}
+
+const ContentChain& ContentChain::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+ContentChain* ContentChain::default_instance_ = NULL;
+
+ContentChain* ContentChain::New() const {
+  return new ContentChain;
+}
+
+void ContentChain::Clear() {
+  if (_has_bits_[0 / 32] & 13) {
+    if (has_content()) {
+      if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        content_->clear();
+      }
+    }
+    if (has_mention()) {
+      if (mention_ != NULL) mention_->::bgs::protocol::club::v1::MentionContent::Clear();
+    }
+    edit_time_ = GOOGLE_ULONGLONG(0);
+  }
+  embed_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ContentChain::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.ContentChain)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string content = 5;
+      case 5: {
+        if (tag == 42) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_content()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->content().data(), this->content().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "content");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_embed;
+        break;
+      }
+
+      // repeated .bgs.protocol.EmbedInfo embed = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_embed:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_embed()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_embed;
+        if (input->ExpectTag(58)) goto parse_mention;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MentionContent mention = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_mention:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_mention()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_edit_time;
+        break;
+      }
+
+      // optional uint64 edit_time = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_edit_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &edit_time_)));
+          set_has_edit_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.ContentChain)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.ContentChain)
+  return false;
+#undef DO_
+}
+
+void ContentChain::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.ContentChain)
+  // optional string content = 5;
+  if (has_content()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->content().data(), this->content().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "content");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->content(), output);
+  }
+
+  // repeated .bgs.protocol.EmbedInfo embed = 6;
+  for (int i = 0; i < this->embed_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->embed(i), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MentionContent mention = 7;
+  if (has_mention()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->mention(), output);
+  }
+
+  // optional uint64 edit_time = 8;
+  if (has_edit_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->edit_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.ContentChain)
+}
+
+::google::protobuf::uint8* ContentChain::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.ContentChain)
+  // optional string content = 5;
+  if (has_content()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->content().data(), this->content().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "content");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->content(), target);
+  }
+
+  // repeated .bgs.protocol.EmbedInfo embed = 6;
+  for (int i = 0; i < this->embed_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->embed(i), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MentionContent mention = 7;
+  if (has_mention()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->mention(), target);
+  }
+
+  // optional uint64 edit_time = 8;
+  if (has_edit_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->edit_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.ContentChain)
+  return target;
+}
+
+int ContentChain::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string content = 5;
+    if (has_content()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->content());
+    }
+
+    // optional .bgs.protocol.club.v1.MentionContent mention = 7;
+    if (has_mention()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->mention());
+    }
+
+    // optional uint64 edit_time = 8;
+    if (has_edit_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->edit_time());
+    }
+
+  }
+  // repeated .bgs.protocol.EmbedInfo embed = 6;
+  total_size += 1 * this->embed_size();
+  for (int i = 0; i < this->embed_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->embed(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ContentChain::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ContentChain* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ContentChain*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ContentChain::MergeFrom(const ContentChain& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  embed_.MergeFrom(from.embed_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_content()) {
+      set_content(from.content());
+    }
+    if (from.has_mention()) {
+      mutable_mention()->::bgs::protocol::club::v1::MentionContent::MergeFrom(from.mention());
+    }
+    if (from.has_edit_time()) {
+      set_edit_time(from.edit_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ContentChain::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ContentChain::CopyFrom(const ContentChain& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ContentChain::IsInitialized() const {
+
+  if (has_mention()) {
+    if (!this->mention().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ContentChain::Swap(ContentChain* other) {
+  if (other != this) {
+    std::swap(content_, other->content_);
+    embed_.Swap(&other->embed_);
+    std::swap(mention_, other->mention_);
+    std::swap(edit_time_, other->edit_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ContentChain::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ContentChain_descriptor_;
+  metadata.reflection = ContentChain_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamMessage::kIdFieldNumber;
+const int StreamMessage::kAuthorFieldNumber;
+const int StreamMessage::kContentChainFieldNumber;
+const int StreamMessage::kDestroyerFieldNumber;
+const int StreamMessage::kDestroyedFieldNumber;
+const int StreamMessage::kDestroyTimeFieldNumber;
+#endif  // !_MSC_VER
+
+StreamMessage::StreamMessage()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamMessage)
+}
+
+void StreamMessage::InitAsDefaultInstance() {
+  id_ = const_cast< ::bgs::protocol::MessageId*>(&::bgs::protocol::MessageId::default_instance());
+  author_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+  destroyer_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+}
+
+StreamMessage::StreamMessage(const StreamMessage& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamMessage)
+}
+
+void StreamMessage::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = NULL;
+  author_ = NULL;
+  destroyer_ = NULL;
+  destroyed_ = false;
+  destroy_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamMessage::~StreamMessage() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamMessage)
+  SharedDtor();
+}
+
+void StreamMessage::SharedDtor() {
+  if (this != default_instance_) {
+    delete id_;
+    delete author_;
+    delete destroyer_;
+  }
+}
+
+void StreamMessage::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamMessage::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamMessage_descriptor_;
+}
+
+const StreamMessage& StreamMessage::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamMessage* StreamMessage::default_instance_ = NULL;
+
+StreamMessage* StreamMessage::New() const {
+  return new StreamMessage;
+}
+
+void StreamMessage::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamMessage*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 59) {
+    ZR_(destroy_time_, destroyed_);
+    if (has_id()) {
+      if (id_ != NULL) id_->::bgs::protocol::MessageId::Clear();
+    }
+    if (has_author()) {
+      if (author_ != NULL) author_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+    if (has_destroyer()) {
+      if (destroyer_ != NULL) destroyer_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  content_chain_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamMessage)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.MessageId id = 3;
+      case 3: {
+        if (tag == 26) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_author;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_author:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_author()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_content_chain;
+        break;
+      }
+
+      // repeated .bgs.protocol.club.v1.ContentChain content_chain = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_content_chain:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_content_chain()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_content_chain;
+        if (input->ExpectTag(122)) goto parse_destroyer;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription destroyer = 15;
+      case 15: {
+        if (tag == 122) {
+         parse_destroyer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_destroyer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(128)) goto parse_destroyed;
+        break;
+      }
+
+      // optional bool destroyed = 16;
+      case 16: {
+        if (tag == 128) {
+         parse_destroyed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &destroyed_)));
+          set_has_destroyed();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(136)) goto parse_destroy_time;
+        break;
+      }
+
+      // optional uint64 destroy_time = 17;
+      case 17: {
+        if (tag == 136) {
+         parse_destroy_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &destroy_time_)));
+          set_has_destroy_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamMessage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamMessage)
+  return false;
+#undef DO_
+}
+
+void StreamMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamMessage)
+  // optional .bgs.protocol.MessageId id = 3;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+  if (has_author()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->author(), output);
+  }
+
+  // repeated .bgs.protocol.club.v1.ContentChain content_chain = 6;
+  for (int i = 0; i < this->content_chain_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->content_chain(i), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription destroyer = 15;
+  if (has_destroyer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      15, this->destroyer(), output);
+  }
+
+  // optional bool destroyed = 16;
+  if (has_destroyed()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->destroyed(), output);
+  }
+
+  // optional uint64 destroy_time = 17;
+  if (has_destroy_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(17, this->destroy_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamMessage)
+}
+
+::google::protobuf::uint8* StreamMessage::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamMessage)
+  // optional .bgs.protocol.MessageId id = 3;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+  if (has_author()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->author(), target);
+  }
+
+  // repeated .bgs.protocol.club.v1.ContentChain content_chain = 6;
+  for (int i = 0; i < this->content_chain_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->content_chain(i), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription destroyer = 15;
+  if (has_destroyer()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        15, this->destroyer(), target);
+  }
+
+  // optional bool destroyed = 16;
+  if (has_destroyed()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->destroyed(), target);
+  }
+
+  // optional uint64 destroy_time = 17;
+  if (has_destroy_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(17, this->destroy_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamMessage)
+  return target;
+}
+
+int StreamMessage::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.MessageId id = 3;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+    if (has_author()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->author());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription destroyer = 15;
+    if (has_destroyer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->destroyer());
+    }
+
+    // optional bool destroyed = 16;
+    if (has_destroyed()) {
+      total_size += 2 + 1;
+    }
+
+    // optional uint64 destroy_time = 17;
+    if (has_destroy_time()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->destroy_time());
+    }
+
+  }
+  // repeated .bgs.protocol.club.v1.ContentChain content_chain = 6;
+  total_size += 1 * this->content_chain_size();
+  for (int i = 0; i < this->content_chain_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->content_chain(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamMessage::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamMessage* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamMessage*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamMessage::MergeFrom(const StreamMessage& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  content_chain_.MergeFrom(from.content_chain_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      mutable_id()->::bgs::protocol::MessageId::MergeFrom(from.id());
+    }
+    if (from.has_author()) {
+      mutable_author()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.author());
+    }
+    if (from.has_destroyer()) {
+      mutable_destroyer()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.destroyer());
+    }
+    if (from.has_destroyed()) {
+      set_destroyed(from.destroyed());
+    }
+    if (from.has_destroy_time()) {
+      set_destroy_time(from.destroy_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamMessage::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamMessage::CopyFrom(const StreamMessage& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamMessage::IsInitialized() const {
+
+  if (has_author()) {
+    if (!this->author().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->content_chain())) return false;
+  if (has_destroyer()) {
+    if (!this->destroyer().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamMessage::Swap(StreamMessage* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(author_, other->author_);
+    content_chain_.Swap(&other->content_chain_);
+    std::swap(destroyer_, other->destroyer_);
+    std::swap(destroyed_, other->destroyed_);
+    std::swap(destroy_time_, other->destroy_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamMessage::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamMessage_descriptor_;
+  metadata.reflection = StreamMessage_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamMention::kClubIdFieldNumber;
+const int StreamMention::kStreamIdFieldNumber;
+const int StreamMention::kMessageIdFieldNumber;
+const int StreamMention::kAuthorFieldNumber;
+const int StreamMention::kDestroyedFieldNumber;
+const int StreamMention::kMentionIdFieldNumber;
+const int StreamMention::kMemberIdFieldNumber;
+#endif  // !_MSC_VER
+
+StreamMention::StreamMention()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamMention)
+}
+
+void StreamMention::InitAsDefaultInstance() {
+  message_id_ = const_cast< ::bgs::protocol::MessageId*>(&::bgs::protocol::MessageId::default_instance());
+  author_ = const_cast< ::bgs::protocol::club::v1::MemberDescription*>(&::bgs::protocol::club::v1::MemberDescription::default_instance());
+  mention_id_ = const_cast< ::bgs::protocol::TimeSeriesId*>(&::bgs::protocol::TimeSeriesId::default_instance());
+  member_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+StreamMention::StreamMention(const StreamMention& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamMention)
+}
+
+void StreamMention::SharedCtor() {
+  _cached_size_ = 0;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  message_id_ = NULL;
+  author_ = NULL;
+  destroyed_ = false;
+  mention_id_ = NULL;
+  member_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamMention::~StreamMention() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamMention)
+  SharedDtor();
+}
+
+void StreamMention::SharedDtor() {
+  if (this != default_instance_) {
+    delete message_id_;
+    delete author_;
+    delete mention_id_;
+    delete member_id_;
+  }
+}
+
+void StreamMention::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamMention::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamMention_descriptor_;
+}
+
+const StreamMention& StreamMention::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamMention* StreamMention::default_instance_ = NULL;
+
+StreamMention* StreamMention::New() const {
+  return new StreamMention;
+}
+
+void StreamMention::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamMention*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 127) {
+    ZR_(club_id_, stream_id_);
+    if (has_message_id()) {
+      if (message_id_ != NULL) message_id_->::bgs::protocol::MessageId::Clear();
+    }
+    if (has_author()) {
+      if (author_ != NULL) author_->::bgs::protocol::club::v1::MemberDescription::Clear();
+    }
+    destroyed_ = false;
+    if (has_mention_id()) {
+      if (mention_id_ != NULL) mention_id_->::bgs::protocol::TimeSeriesId::Clear();
+    }
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamMention::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamMention)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 club_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_message_id;
+        break;
+      }
+
+      // optional .bgs.protocol.MessageId message_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_message_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_author;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_author:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_author()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_destroyed;
+        break;
+      }
+
+      // optional bool destroyed = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_destroyed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &destroyed_)));
+          set_has_destroyed();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_mention_id;
+        break;
+      }
+
+      // optional .bgs.protocol.TimeSeriesId mention_id = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_mention_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_mention_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_member_id;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.MemberId member_id = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamMention)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamMention)
+  return false;
+#undef DO_
+}
+
+void StreamMention::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamMention)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.MessageId message_id = 3;
+  if (has_message_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->message_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+  if (has_author()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->author(), output);
+  }
+
+  // optional bool destroyed = 5;
+  if (has_destroyed()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->destroyed(), output);
+  }
+
+  // optional .bgs.protocol.TimeSeriesId mention_id = 6;
+  if (has_mention_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->mention_id(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 7;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->member_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamMention)
+}
+
+::google::protobuf::uint8* StreamMention::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamMention)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.MessageId message_id = 3;
+  if (has_message_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->message_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+  if (has_author()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->author(), target);
+  }
+
+  // optional bool destroyed = 5;
+  if (has_destroyed()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->destroyed(), target);
+  }
+
+  // optional .bgs.protocol.TimeSeriesId mention_id = 6;
+  if (has_mention_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->mention_id(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 7;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->member_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamMention)
+  return target;
+}
+
+int StreamMention::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 club_id = 1;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 2;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.MessageId message_id = 3;
+    if (has_message_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+    if (has_author()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->author());
+    }
+
+    // optional bool destroyed = 5;
+    if (has_destroyed()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.TimeSeriesId mention_id = 6;
+    if (has_mention_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->mention_id());
+    }
+
+    // optional .bgs.protocol.club.v1.MemberId member_id = 7;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamMention::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamMention* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamMention*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamMention::MergeFrom(const StreamMention& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_message_id()) {
+      mutable_message_id()->::bgs::protocol::MessageId::MergeFrom(from.message_id());
+    }
+    if (from.has_author()) {
+      mutable_author()->::bgs::protocol::club::v1::MemberDescription::MergeFrom(from.author());
+    }
+    if (from.has_destroyed()) {
+      set_destroyed(from.destroyed());
+    }
+    if (from.has_mention_id()) {
+      mutable_mention_id()->::bgs::protocol::TimeSeriesId::MergeFrom(from.mention_id());
+    }
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.member_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamMention::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamMention::CopyFrom(const StreamMention& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamMention::IsInitialized() const {
+
+  if (has_author()) {
+    if (!this->author().IsInitialized()) return false;
+  }
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamMention::Swap(StreamMention* other) {
+  if (other != this) {
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(message_id_, other->message_id_);
+    std::swap(author_, other->author_);
+    std::swap(destroyed_, other->destroyed_);
+    std::swap(mention_id_, other->mention_id_);
+    std::swap(member_id_, other->member_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamMention::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamMention_descriptor_;
+  metadata.reflection = StreamMention_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamView::kClubIdFieldNumber;
+const int StreamView::kStreamIdFieldNumber;
+const int StreamView::kMarkerFieldNumber;
+#endif  // !_MSC_VER
+
+StreamView::StreamView()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamView)
+}
+
+void StreamView::InitAsDefaultInstance() {
+  marker_ = const_cast< ::bgs::protocol::ViewMarker*>(&::bgs::protocol::ViewMarker::default_instance());
+}
+
+StreamView::StreamView(const StreamView& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamView)
+}
+
+void StreamView::SharedCtor() {
+  _cached_size_ = 0;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  marker_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamView::~StreamView() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamView)
+  SharedDtor();
+}
+
+void StreamView::SharedDtor() {
+  if (this != default_instance_) {
+    delete marker_;
+  }
+}
+
+void StreamView::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamView::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamView_descriptor_;
+}
+
+const StreamView& StreamView::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamView* StreamView::default_instance_ = NULL;
+
+StreamView* StreamView::New() const {
+  return new StreamView;
+}
+
+void StreamView::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamView*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, stream_id_);
+    if (has_marker()) {
+      if (marker_ != NULL) marker_->::bgs::protocol::ViewMarker::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamView::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamView)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 club_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_marker;
+        break;
+      }
+
+      // optional .bgs.protocol.ViewMarker marker = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_marker:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_marker()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamView)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamView)
+  return false;
+#undef DO_
+}
+
+void StreamView::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamView)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.ViewMarker marker = 3;
+  if (has_marker()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->marker(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamView)
+}
+
+::google::protobuf::uint8* StreamView::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamView)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.ViewMarker marker = 3;
+  if (has_marker()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->marker(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamView)
+  return target;
+}
+
+int StreamView::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 club_id = 1;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 2;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.ViewMarker marker = 3;
+    if (has_marker()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->marker());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamView::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamView* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamView*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamView::MergeFrom(const StreamView& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_marker()) {
+      mutable_marker()->::bgs::protocol::ViewMarker::MergeFrom(from.marker());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamView::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamView::CopyFrom(const StreamView& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamView::IsInitialized() const {
+
+  return true;
+}
+
+void StreamView::Swap(StreamView* other) {
+  if (other != this) {
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(marker_, other->marker_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamView::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamView_descriptor_;
+  metadata.reflection = StreamView_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamAdvanceViewTime::kStreamIdFieldNumber;
+const int StreamAdvanceViewTime::kViewTimeFieldNumber;
+#endif  // !_MSC_VER
+
+StreamAdvanceViewTime::StreamAdvanceViewTime()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamAdvanceViewTime)
+}
+
+void StreamAdvanceViewTime::InitAsDefaultInstance() {
+}
+
+StreamAdvanceViewTime::StreamAdvanceViewTime(const StreamAdvanceViewTime& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamAdvanceViewTime)
+}
+
+void StreamAdvanceViewTime::SharedCtor() {
+  _cached_size_ = 0;
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  view_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamAdvanceViewTime::~StreamAdvanceViewTime() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamAdvanceViewTime)
+  SharedDtor();
+}
+
+void StreamAdvanceViewTime::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void StreamAdvanceViewTime::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamAdvanceViewTime::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamAdvanceViewTime_descriptor_;
+}
+
+const StreamAdvanceViewTime& StreamAdvanceViewTime::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamAdvanceViewTime* StreamAdvanceViewTime::default_instance_ = NULL;
+
+StreamAdvanceViewTime* StreamAdvanceViewTime::New() const {
+  return new StreamAdvanceViewTime;
+}
+
+void StreamAdvanceViewTime::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamAdvanceViewTime*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(stream_id_, view_time_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamAdvanceViewTime::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamAdvanceViewTime)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 stream_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_view_time;
+        break;
+      }
+
+      // optional uint64 view_time = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_view_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &view_time_)));
+          set_has_view_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamAdvanceViewTime)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamAdvanceViewTime)
+  return false;
+#undef DO_
+}
+
+void StreamAdvanceViewTime::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamAdvanceViewTime)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->stream_id(), output);
+  }
+
+  // optional uint64 view_time = 2;
+  if (has_view_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->view_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamAdvanceViewTime)
+}
+
+::google::protobuf::uint8* StreamAdvanceViewTime::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamAdvanceViewTime)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->stream_id(), target);
+  }
+
+  // optional uint64 view_time = 2;
+  if (has_view_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->view_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamAdvanceViewTime)
+  return target;
+}
+
+int StreamAdvanceViewTime::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 stream_id = 1;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional uint64 view_time = 2;
+    if (has_view_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->view_time());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamAdvanceViewTime::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamAdvanceViewTime* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamAdvanceViewTime*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamAdvanceViewTime::MergeFrom(const StreamAdvanceViewTime& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_view_time()) {
+      set_view_time(from.view_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamAdvanceViewTime::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamAdvanceViewTime::CopyFrom(const StreamAdvanceViewTime& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamAdvanceViewTime::IsInitialized() const {
+
+  return true;
+}
+
+void StreamAdvanceViewTime::Swap(StreamAdvanceViewTime* other) {
+  if (other != this) {
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(view_time_, other->view_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamAdvanceViewTime::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamAdvanceViewTime_descriptor_;
+  metadata.reflection = StreamAdvanceViewTime_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamEventTime::kStreamIdFieldNumber;
+const int StreamEventTime::kEventTimeFieldNumber;
+#endif  // !_MSC_VER
+
+StreamEventTime::StreamEventTime()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamEventTime)
+}
+
+void StreamEventTime::InitAsDefaultInstance() {
+}
+
+StreamEventTime::StreamEventTime(const StreamEventTime& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamEventTime)
+}
+
+void StreamEventTime::SharedCtor() {
+  _cached_size_ = 0;
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  event_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamEventTime::~StreamEventTime() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamEventTime)
+  SharedDtor();
+}
+
+void StreamEventTime::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void StreamEventTime::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamEventTime::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamEventTime_descriptor_;
+}
+
+const StreamEventTime& StreamEventTime::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamEventTime* StreamEventTime::default_instance_ = NULL;
+
+StreamEventTime* StreamEventTime::New() const {
+  return new StreamEventTime;
+}
+
+void StreamEventTime::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamEventTime*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(stream_id_, event_time_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamEventTime::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamEventTime)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 stream_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_event_time;
+        break;
+      }
+
+      // optional uint64 event_time = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_event_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &event_time_)));
+          set_has_event_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamEventTime)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamEventTime)
+  return false;
+#undef DO_
+}
+
+void StreamEventTime::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamEventTime)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->stream_id(), output);
+  }
+
+  // optional uint64 event_time = 2;
+  if (has_event_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->event_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamEventTime)
+}
+
+::google::protobuf::uint8* StreamEventTime::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamEventTime)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->stream_id(), target);
+  }
+
+  // optional uint64 event_time = 2;
+  if (has_event_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->event_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamEventTime)
+  return target;
+}
+
+int StreamEventTime::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 stream_id = 1;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional uint64 event_time = 2;
+    if (has_event_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->event_time());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamEventTime::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamEventTime* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamEventTime*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamEventTime::MergeFrom(const StreamEventTime& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_event_time()) {
+      set_event_time(from.event_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamEventTime::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamEventTime::CopyFrom(const StreamEventTime& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamEventTime::IsInitialized() const {
+
+  return true;
+}
+
+void StreamEventTime::Swap(StreamEventTime* other) {
+  if (other != this) {
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(event_time_, other->event_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamEventTime::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamEventTime_descriptor_;
+  metadata.reflection = StreamEventTime_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamMentionView::kClubIdFieldNumber;
+const int StreamMentionView::kStreamIdFieldNumber;
+const int StreamMentionView::kMarkerFieldNumber;
+#endif  // !_MSC_VER
+
+StreamMentionView::StreamMentionView()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamMentionView)
+}
+
+void StreamMentionView::InitAsDefaultInstance() {
+  marker_ = const_cast< ::bgs::protocol::ViewMarker*>(&::bgs::protocol::ViewMarker::default_instance());
+}
+
+StreamMentionView::StreamMentionView(const StreamMentionView& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamMentionView)
+}
+
+void StreamMentionView::SharedCtor() {
+  _cached_size_ = 0;
+  club_id_ = GOOGLE_ULONGLONG(0);
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  marker_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamMentionView::~StreamMentionView() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamMentionView)
+  SharedDtor();
+}
+
+void StreamMentionView::SharedDtor() {
+  if (this != default_instance_) {
+    delete marker_;
+  }
+}
+
+void StreamMentionView::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamMentionView::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamMentionView_descriptor_;
+}
+
+const StreamMentionView& StreamMentionView::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamMentionView* StreamMentionView::default_instance_ = NULL;
+
+StreamMentionView* StreamMentionView::New() const {
+  return new StreamMentionView;
+}
+
+void StreamMentionView::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamMentionView*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(club_id_, stream_id_);
+    if (has_marker()) {
+      if (marker_ != NULL) marker_->::bgs::protocol::ViewMarker::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamMentionView::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamMentionView)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 club_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &club_id_)));
+          set_has_club_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_stream_id;
+        break;
+      }
+
+      // optional uint64 stream_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_stream_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_marker;
+        break;
+      }
+
+      // optional .bgs.protocol.ViewMarker marker = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_marker:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_marker()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamMentionView)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamMentionView)
+  return false;
+#undef DO_
+}
+
+void StreamMentionView::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamMentionView)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->club_id(), output);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->stream_id(), output);
+  }
+
+  // optional .bgs.protocol.ViewMarker marker = 3;
+  if (has_marker()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->marker(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamMentionView)
+}
+
+::google::protobuf::uint8* StreamMentionView::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamMentionView)
+  // optional uint64 club_id = 1;
+  if (has_club_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->club_id(), target);
+  }
+
+  // optional uint64 stream_id = 2;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->stream_id(), target);
+  }
+
+  // optional .bgs.protocol.ViewMarker marker = 3;
+  if (has_marker()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->marker(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamMentionView)
+  return target;
+}
+
+int StreamMentionView::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 club_id = 1;
+    if (has_club_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->club_id());
+    }
+
+    // optional uint64 stream_id = 2;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional .bgs.protocol.ViewMarker marker = 3;
+    if (has_marker()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->marker());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamMentionView::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamMentionView* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamMentionView*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamMentionView::MergeFrom(const StreamMentionView& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_club_id()) {
+      set_club_id(from.club_id());
+    }
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_marker()) {
+      mutable_marker()->::bgs::protocol::ViewMarker::MergeFrom(from.marker());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamMentionView::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamMentionView::CopyFrom(const StreamMentionView& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamMentionView::IsInitialized() const {
+
+  return true;
+}
+
+void StreamMentionView::Swap(StreamMentionView* other) {
+  if (other != this) {
+    std::swap(club_id_, other->club_id_);
+    std::swap(stream_id_, other->stream_id_);
+    std::swap(marker_, other->marker_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamMentionView::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamMentionView_descriptor_;
+  metadata.reflection = StreamMentionView_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamStateOptions::kAttributeFieldNumber;
+const int StreamStateOptions::kNameFieldNumber;
+const int StreamStateOptions::kSubjectFieldNumber;
+const int StreamStateOptions::kAccessFieldNumber;
+const int StreamStateOptions::kVoiceLevelFieldNumber;
+#endif  // !_MSC_VER
+
+StreamStateOptions::StreamStateOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamStateOptions)
+}
+
+void StreamStateOptions::InitAsDefaultInstance() {
+  access_ = const_cast< ::bgs::protocol::club::v1::StreamAccess*>(&::bgs::protocol::club::v1::StreamAccess::default_instance());
+}
+
+StreamStateOptions::StreamStateOptions(const StreamStateOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamStateOptions)
+}
+
+void StreamStateOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  access_ = NULL;
+  voice_level_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamStateOptions::~StreamStateOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamStateOptions)
+  SharedDtor();
+}
+
+void StreamStateOptions::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subject_;
+  }
+  if (this != default_instance_) {
+    delete access_;
+  }
+}
+
+void StreamStateOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamStateOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamStateOptions_descriptor_;
+}
+
+const StreamStateOptions& StreamStateOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamStateOptions* StreamStateOptions::default_instance_ = NULL;
+
+StreamStateOptions* StreamStateOptions::New() const {
+  return new StreamStateOptions;
+}
+
+void StreamStateOptions::Clear() {
+  if (_has_bits_[0 / 32] & 30) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_subject()) {
+      if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        subject_->clear();
+      }
+    }
+    if (has_access()) {
+      if (access_ != NULL) access_->::bgs::protocol::club::v1::StreamAccess::Clear();
+    }
+    voice_level_ = 0;
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamStateOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamStateOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.v2.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectTag(18)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_subject;
+        break;
+      }
+
+      // optional string subject = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_subject:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_subject()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->subject().data(), this->subject().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "subject");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_access;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_access:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_access()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_voice_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_voice_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::StreamVoiceLevel_IsValid(value)) {
+            set_voice_level(static_cast< ::bgs::protocol::club::v1::StreamVoiceLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(5, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamStateOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamStateOptions)
+  return false;
+#undef DO_
+}
+
+void StreamStateOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamStateOptions)
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->name(), output);
+  }
+
+  // optional string subject = 3;
+  if (has_subject()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subject().data(), this->subject().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subject");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->subject(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+  if (has_access()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->access(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+  if (has_voice_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->voice_level(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamStateOptions)
+}
+
+::google::protobuf::uint8* StreamStateOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamStateOptions)
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+
+  // optional string subject = 3;
+  if (has_subject()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subject().data(), this->subject().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subject");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->subject(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+  if (has_access()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->access(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+  if (has_voice_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      5, this->voice_level(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamStateOptions)
+  return target;
+}
+
+int StreamStateOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional string name = 2;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string subject = 3;
+    if (has_subject()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->subject());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+    if (has_access()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->access());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+    if (has_voice_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->voice_level());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamStateOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamStateOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamStateOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamStateOptions::MergeFrom(const StreamStateOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_subject()) {
+      set_subject(from.subject());
+    }
+    if (from.has_access()) {
+      mutable_access()->::bgs::protocol::club::v1::StreamAccess::MergeFrom(from.access());
+    }
+    if (from.has_voice_level()) {
+      set_voice_level(from.voice_level());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamStateOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamStateOptions::CopyFrom(const StreamStateOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamStateOptions::IsInitialized() const {
+
+  return true;
+}
+
+void StreamStateOptions::Swap(StreamStateOptions* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    std::swap(name_, other->name_);
+    std::swap(subject_, other->subject_);
+    std::swap(access_, other->access_);
+    std::swap(voice_level_, other->voice_level_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamStateOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamStateOptions_descriptor_;
+  metadata.reflection = StreamStateOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamStateAssignment::kStreamIdFieldNumber;
+const int StreamStateAssignment::kAttributeFieldNumber;
+const int StreamStateAssignment::kNameFieldNumber;
+const int StreamStateAssignment::kSubjectFieldNumber;
+const int StreamStateAssignment::kAccessFieldNumber;
+const int StreamStateAssignment::kStreamSubscriptionRemovedFieldNumber;
+const int StreamStateAssignment::kVoiceLevelFieldNumber;
+#endif  // !_MSC_VER
+
+StreamStateAssignment::StreamStateAssignment()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamStateAssignment)
+}
+
+void StreamStateAssignment::InitAsDefaultInstance() {
+  access_ = const_cast< ::bgs::protocol::club::v1::StreamAccess*>(&::bgs::protocol::club::v1::StreamAccess::default_instance());
+}
+
+StreamStateAssignment::StreamStateAssignment(const StreamStateAssignment& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamStateAssignment)
+}
+
+void StreamStateAssignment::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  access_ = NULL;
+  stream_subscription_removed_ = false;
+  voice_level_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamStateAssignment::~StreamStateAssignment() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamStateAssignment)
+  SharedDtor();
+}
+
+void StreamStateAssignment::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subject_;
+  }
+  if (this != default_instance_) {
+    delete access_;
+  }
+}
+
+void StreamStateAssignment::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamStateAssignment::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamStateAssignment_descriptor_;
+}
+
+const StreamStateAssignment& StreamStateAssignment::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamStateAssignment* StreamStateAssignment::default_instance_ = NULL;
+
+StreamStateAssignment* StreamStateAssignment::New() const {
+  return new StreamStateAssignment;
+}
+
+void StreamStateAssignment::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamStateAssignment*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 125) {
+    ZR_(stream_subscription_removed_, voice_level_);
+    stream_id_ = GOOGLE_ULONGLONG(0);
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_subject()) {
+      if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        subject_->clear();
+      }
+    }
+    if (has_access()) {
+      if (access_ != NULL) access_->::bgs::protocol::club::v1::StreamAccess::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamStateAssignment::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamStateAssignment)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 stream_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &stream_id_)));
+          set_has_stream_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.v2.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectTag(26)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_subject;
+        break;
+      }
+
+      // optional string subject = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_subject:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_subject()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->subject().data(), this->subject().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "subject");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_access;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamAccess access = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_access:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_access()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_stream_subscription_removed;
+        break;
+      }
+
+      // optional bool stream_subscription_removed = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_stream_subscription_removed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &stream_subscription_removed_)));
+          set_has_stream_subscription_removed();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_voice_level;
+        break;
+      }
+
+      // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_voice_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::club::v1::StreamVoiceLevel_IsValid(value)) {
+            set_voice_level(static_cast< ::bgs::protocol::club::v1::StreamVoiceLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(7, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamStateAssignment)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamStateAssignment)
+  return false;
+#undef DO_
+}
+
+void StreamStateAssignment::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamStateAssignment)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->stream_id(), output);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->name(), output);
+  }
+
+  // optional string subject = 4;
+  if (has_subject()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subject().data(), this->subject().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subject");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->subject(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 5;
+  if (has_access()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->access(), output);
+  }
+
+  // optional bool stream_subscription_removed = 6;
+  if (has_stream_subscription_removed()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->stream_subscription_removed(), output);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+  if (has_voice_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      7, this->voice_level(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamStateAssignment)
+}
+
+::google::protobuf::uint8* StreamStateAssignment::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamStateAssignment)
+  // optional uint64 stream_id = 1;
+  if (has_stream_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->stream_id(), target);
+  }
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->name(), target);
+  }
+
+  // optional string subject = 4;
+  if (has_subject()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->subject().data(), this->subject().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "subject");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->subject(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 5;
+  if (has_access()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->access(), target);
+  }
+
+  // optional bool stream_subscription_removed = 6;
+  if (has_stream_subscription_removed()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->stream_subscription_removed(), target);
+  }
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+  if (has_voice_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      7, this->voice_level(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamStateAssignment)
+  return target;
+}
+
+int StreamStateAssignment::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 stream_id = 1;
+    if (has_stream_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->stream_id());
+    }
+
+    // optional string name = 3;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional string subject = 4;
+    if (has_subject()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->subject());
+    }
+
+    // optional .bgs.protocol.club.v1.StreamAccess access = 5;
+    if (has_access()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->access());
+    }
+
+    // optional bool stream_subscription_removed = 6;
+    if (has_stream_subscription_removed()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+    if (has_voice_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->voice_level());
+    }
+
+  }
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamStateAssignment::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamStateAssignment* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamStateAssignment*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamStateAssignment::MergeFrom(const StreamStateAssignment& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_stream_id()) {
+      set_stream_id(from.stream_id());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_subject()) {
+      set_subject(from.subject());
+    }
+    if (from.has_access()) {
+      mutable_access()->::bgs::protocol::club::v1::StreamAccess::MergeFrom(from.access());
+    }
+    if (from.has_stream_subscription_removed()) {
+      set_stream_subscription_removed(from.stream_subscription_removed());
+    }
+    if (from.has_voice_level()) {
+      set_voice_level(from.voice_level());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamStateAssignment::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamStateAssignment::CopyFrom(const StreamStateAssignment& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamStateAssignment::IsInitialized() const {
+
+  return true;
+}
+
+void StreamStateAssignment::Swap(StreamStateAssignment* other) {
+  if (other != this) {
+    std::swap(stream_id_, other->stream_id_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(name_, other->name_);
+    std::swap(subject_, other->subject_);
+    std::swap(access_, other->access_);
+    std::swap(stream_subscription_removed_, other->stream_subscription_removed_);
+    std::swap(voice_level_, other->voice_level_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamStateAssignment::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamStateAssignment_descriptor_;
+  metadata.reflection = StreamStateAssignment_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StreamTypingIndicator::kAuthorIdFieldNumber;
+const int StreamTypingIndicator::kIndicatorFieldNumber;
+const int StreamTypingIndicator::kEpochFieldNumber;
+#endif  // !_MSC_VER
+
+StreamTypingIndicator::StreamTypingIndicator()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.club.v1.StreamTypingIndicator)
+}
+
+void StreamTypingIndicator::InitAsDefaultInstance() {
+  author_id_ = const_cast< ::bgs::protocol::club::v1::MemberId*>(&::bgs::protocol::club::v1::MemberId::default_instance());
+}
+
+StreamTypingIndicator::StreamTypingIndicator(const StreamTypingIndicator& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.club.v1.StreamTypingIndicator)
+}
+
+void StreamTypingIndicator::SharedCtor() {
+  _cached_size_ = 0;
+  author_id_ = NULL;
+  indicator_ = 0;
+  epoch_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StreamTypingIndicator::~StreamTypingIndicator() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.club.v1.StreamTypingIndicator)
+  SharedDtor();
+}
+
+void StreamTypingIndicator::SharedDtor() {
+  if (this != default_instance_) {
+    delete author_id_;
+  }
+}
+
+void StreamTypingIndicator::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StreamTypingIndicator::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StreamTypingIndicator_descriptor_;
+}
+
+const StreamTypingIndicator& StreamTypingIndicator::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_club_5fstream_2eproto();
+  return *default_instance_;
+}
+
+StreamTypingIndicator* StreamTypingIndicator::default_instance_ = NULL;
+
+StreamTypingIndicator* StreamTypingIndicator::New() const {
+  return new StreamTypingIndicator;
+}
+
+void StreamTypingIndicator::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StreamTypingIndicator*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(epoch_, indicator_);
+    if (has_author_id()) {
+      if (author_id_ != NULL) author_id_->::bgs::protocol::club::v1::MemberId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StreamTypingIndicator::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.club.v1.StreamTypingIndicator)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.club.v1.MemberId author_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_author_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_indicator;
+        break;
+      }
+
+      // optional .bgs.protocol.TypingIndicator indicator = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_indicator:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::TypingIndicator_IsValid(value)) {
+            set_indicator(static_cast< ::bgs::protocol::TypingIndicator >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(2, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_epoch;
+        break;
+      }
+
+      // optional uint64 epoch = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_epoch:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &epoch_)));
+          set_has_epoch();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.club.v1.StreamTypingIndicator)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.club.v1.StreamTypingIndicator)
+  return false;
+#undef DO_
+}
+
+void StreamTypingIndicator::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.club.v1.StreamTypingIndicator)
+  // optional .bgs.protocol.club.v1.MemberId author_id = 1;
+  if (has_author_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->author_id(), output);
+  }
+
+  // optional .bgs.protocol.TypingIndicator indicator = 2;
+  if (has_indicator()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->indicator(), output);
+  }
+
+  // optional uint64 epoch = 3;
+  if (has_epoch()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->epoch(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.club.v1.StreamTypingIndicator)
+}
+
+::google::protobuf::uint8* StreamTypingIndicator::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.club.v1.StreamTypingIndicator)
+  // optional .bgs.protocol.club.v1.MemberId author_id = 1;
+  if (has_author_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->author_id(), target);
+  }
+
+  // optional .bgs.protocol.TypingIndicator indicator = 2;
+  if (has_indicator()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->indicator(), target);
+  }
+
+  // optional uint64 epoch = 3;
+  if (has_epoch()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->epoch(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.club.v1.StreamTypingIndicator)
+  return target;
+}
+
+int StreamTypingIndicator::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.club.v1.MemberId author_id = 1;
+    if (has_author_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->author_id());
+    }
+
+    // optional .bgs.protocol.TypingIndicator indicator = 2;
+    if (has_indicator()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->indicator());
+    }
+
+    // optional uint64 epoch = 3;
+    if (has_epoch()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->epoch());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StreamTypingIndicator::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StreamTypingIndicator* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StreamTypingIndicator*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StreamTypingIndicator::MergeFrom(const StreamTypingIndicator& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_author_id()) {
+      mutable_author_id()->::bgs::protocol::club::v1::MemberId::MergeFrom(from.author_id());
+    }
+    if (from.has_indicator()) {
+      set_indicator(from.indicator());
+    }
+    if (from.has_epoch()) {
+      set_epoch(from.epoch());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StreamTypingIndicator::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StreamTypingIndicator::CopyFrom(const StreamTypingIndicator& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StreamTypingIndicator::IsInitialized() const {
+
+  if (has_author_id()) {
+    if (!this->author_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void StreamTypingIndicator::Swap(StreamTypingIndicator* other) {
+  if (other != this) {
+    std::swap(author_id_, other->author_id_);
+    std::swap(indicator_, other->indicator_);
+    std::swap(epoch_, other->epoch_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StreamTypingIndicator::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StreamTypingIndicator_descriptor_;
+  metadata.reflection = StreamTypingIndicator_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_stream.pb.h b/src/server/proto/Client/club_stream.pb.h
new file mode 100644
index 00000000000..bfc00df71f9
--- /dev/null
+++ b/src/server/proto/Client/club_stream.pb.h
@@ -0,0 +1,4488 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_stream.proto
+
+#ifndef PROTOBUF_club_5fstream_2eproto__INCLUDED
+#define PROTOBUF_club_5fstream_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "club_enum.pb.h"
+#include "club_member.pb.h"
+#include "api/client/v2/attribute_types.pb.h"
+#include "embed_types.pb.h"
+#include "event_view_types.pb.h"
+#include "message_types.pb.h"
+#include "ets_types.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+void protobuf_AssignDesc_club_5fstream_2eproto();
+void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+class StreamPosition;
+class StreamAccess;
+class CreateStreamOptions;
+class Stream;
+class MentionContent;
+class CreateMessageOptions;
+class ClubStreamMessageContainer;
+class ContentChain;
+class StreamMessage;
+class StreamMention;
+class StreamView;
+class StreamAdvanceViewTime;
+class StreamEventTime;
+class StreamMentionView;
+class StreamStateOptions;
+class StreamStateAssignment;
+class StreamTypingIndicator;
+
+// ===================================================================
+
+class TC_PROTO_API StreamPosition : public ::google::protobuf::Message {
+ public:
+  StreamPosition();
+  virtual ~StreamPosition();
+
+  StreamPosition(const StreamPosition& from);
+
+  inline StreamPosition& operator=(const StreamPosition& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamPosition& default_instance();
+
+  void Swap(StreamPosition* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamPosition* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamPosition& from);
+  void MergeFrom(const StreamPosition& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated uint64 stream_id = 1 [packed = true];
+  inline int stream_id_size() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 stream_id(int index) const;
+  inline void set_stream_id(int index, ::google::protobuf::uint64 value);
+  inline void add_stream_id(::google::protobuf::uint64 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+      stream_id() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+      mutable_stream_id();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamPosition)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > stream_id_;
+  mutable int _stream_id_cached_byte_size_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamPosition* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamAccess : public ::google::protobuf::Message {
+ public:
+  StreamAccess();
+  virtual ~StreamAccess();
+
+  StreamAccess(const StreamAccess& from);
+
+  inline StreamAccess& operator=(const StreamAccess& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamAccess& default_instance();
+
+  void Swap(StreamAccess* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamAccess* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamAccess& from);
+  void MergeFrom(const StreamAccess& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated uint32 role = 1 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 1;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamAccess)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamAccess* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateStreamOptions : public ::google::protobuf::Message {
+ public:
+  CreateStreamOptions();
+  virtual ~CreateStreamOptions();
+
+  CreateStreamOptions(const CreateStreamOptions& from);
+
+  inline CreateStreamOptions& operator=(const CreateStreamOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateStreamOptions& default_instance();
+
+  void Swap(CreateStreamOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateStreamOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateStreamOptions& from);
+  void MergeFrom(const CreateStreamOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string name = 2;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string subject = 3;
+  inline bool has_subject() const;
+  inline void clear_subject();
+  static const int kSubjectFieldNumber = 3;
+  inline const ::std::string& subject() const;
+  inline void set_subject(const ::std::string& value);
+  inline void set_subject(const char* value);
+  inline void set_subject(const char* value, size_t size);
+  inline ::std::string* mutable_subject();
+  inline ::std::string* release_subject();
+  inline void set_allocated_subject(::std::string* subject);
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+  inline bool has_access() const;
+  inline void clear_access();
+  static const int kAccessFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::StreamAccess& access() const;
+  inline ::bgs::protocol::club::v1::StreamAccess* mutable_access();
+  inline ::bgs::protocol::club::v1::StreamAccess* release_access();
+  inline void set_allocated_access(::bgs::protocol::club::v1::StreamAccess* access);
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+  inline bool has_voice_level() const;
+  inline void clear_voice_level();
+  static const int kVoiceLevelFieldNumber = 5;
+  inline ::bgs::protocol::club::v1::StreamVoiceLevel voice_level() const;
+  inline void set_voice_level(::bgs::protocol::club::v1::StreamVoiceLevel value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateStreamOptions)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_subject();
+  inline void clear_has_subject();
+  inline void set_has_access();
+  inline void clear_has_access();
+  inline void set_has_voice_level();
+  inline void clear_has_voice_level();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* name_;
+  ::std::string* subject_;
+  ::bgs::protocol::club::v1::StreamAccess* access_;
+  int voice_level_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateStreamOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API Stream : public ::google::protobuf::Message {
+ public:
+  Stream();
+  virtual ~Stream();
+
+  Stream(const Stream& from);
+
+  inline Stream& operator=(const Stream& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Stream& default_instance();
+
+  void Swap(Stream* other);
+
+  // implements Message ----------------------------------------------
+
+  Stream* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Stream& from);
+  void MergeFrom(const Stream& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 club_id = 1;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 id = 2;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 id() const;
+  inline void set_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 3;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 3;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string name = 4;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 4;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string subject = 5;
+  inline bool has_subject() const;
+  inline void clear_subject();
+  static const int kSubjectFieldNumber = 5;
+  inline const ::std::string& subject() const;
+  inline void set_subject(const ::std::string& value);
+  inline void set_subject(const char* value);
+  inline void set_subject(const char* value, size_t size);
+  inline ::std::string* mutable_subject();
+  inline ::std::string* release_subject();
+  inline void set_allocated_subject(::std::string* subject);
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 6;
+  inline bool has_access() const;
+  inline void clear_access();
+  static const int kAccessFieldNumber = 6;
+  inline const ::bgs::protocol::club::v1::StreamAccess& access() const;
+  inline ::bgs::protocol::club::v1::StreamAccess* mutable_access();
+  inline ::bgs::protocol::club::v1::StreamAccess* release_access();
+  inline void set_allocated_access(::bgs::protocol::club::v1::StreamAccess* access);
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+  inline bool has_voice_level() const;
+  inline void clear_voice_level();
+  static const int kVoiceLevelFieldNumber = 7;
+  inline ::bgs::protocol::club::v1::StreamVoiceLevel voice_level() const;
+  inline void set_voice_level(::bgs::protocol::club::v1::StreamVoiceLevel value);
+
+  // optional uint64 creation_time = 8;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 8;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.Stream)
+ private:
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_subject();
+  inline void clear_has_subject();
+  inline void set_has_access();
+  inline void clear_has_access();
+  inline void set_has_voice_level();
+  inline void clear_has_voice_level();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* name_;
+  ::std::string* subject_;
+  ::bgs::protocol::club::v1::StreamAccess* access_;
+  ::google::protobuf::uint64 creation_time_;
+  int voice_level_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static Stream* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MentionContent : public ::google::protobuf::Message {
+ public:
+  MentionContent();
+  virtual ~MentionContent();
+
+  MentionContent(const MentionContent& from);
+
+  inline MentionContent& operator=(const MentionContent& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MentionContent& default_instance();
+
+  void Swap(MentionContent* other);
+
+  // implements Message ----------------------------------------------
+
+  MentionContent* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MentionContent& from);
+  void MergeFrom(const MentionContent& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bool all = 1;
+  inline bool has_all() const;
+  inline void clear_all();
+  static const int kAllFieldNumber = 1;
+  inline bool all() const;
+  inline void set_all(bool value);
+
+  // optional bool here = 2;
+  inline bool has_here() const;
+  inline void clear_here();
+  static const int kHereFieldNumber = 2;
+  inline bool here() const;
+  inline void set_here(bool value);
+
+  // repeated .bgs.protocol.club.v1.MemberId member_id = 3;
+  inline int member_id_size() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id(int index) const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id(int index);
+  inline ::bgs::protocol::club::v1::MemberId* add_member_id();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberId >&
+      member_id() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberId >*
+      mutable_member_id();
+
+  // repeated uint32 role = 4 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 4;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.MentionContent)
+ private:
+  inline void set_has_all();
+  inline void clear_has_all();
+  inline void set_has_here();
+  inline void clear_has_here();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberId > member_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  bool all_;
+  bool here_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static MentionContent* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API CreateMessageOptions : public ::google::protobuf::Message {
+ public:
+  CreateMessageOptions();
+  virtual ~CreateMessageOptions();
+
+  CreateMessageOptions(const CreateMessageOptions& from);
+
+  inline CreateMessageOptions& operator=(const CreateMessageOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateMessageOptions& default_instance();
+
+  void Swap(CreateMessageOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateMessageOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateMessageOptions& from);
+  void MergeFrom(const CreateMessageOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string content = 2;
+  inline bool has_content() const;
+  inline void clear_content();
+  static const int kContentFieldNumber = 2;
+  inline const ::std::string& content() const;
+  inline void set_content(const ::std::string& value);
+  inline void set_content(const char* value);
+  inline void set_content(const char* value, size_t size);
+  inline ::std::string* mutable_content();
+  inline ::std::string* release_content();
+  inline void set_allocated_content(::std::string* content);
+
+  // optional .bgs.protocol.club.v1.MentionContent mention = 3;
+  inline bool has_mention() const;
+  inline void clear_mention();
+  static const int kMentionFieldNumber = 3;
+  inline const ::bgs::protocol::club::v1::MentionContent& mention() const;
+  inline ::bgs::protocol::club::v1::MentionContent* mutable_mention();
+  inline ::bgs::protocol::club::v1::MentionContent* release_mention();
+  inline void set_allocated_mention(::bgs::protocol::club::v1::MentionContent* mention);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.CreateMessageOptions)
+ private:
+  inline void set_has_content();
+  inline void clear_has_content();
+  inline void set_has_mention();
+  inline void clear_has_mention();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* content_;
+  ::bgs::protocol::club::v1::MentionContent* mention_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateMessageOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ClubStreamMessageContainer : public ::google::protobuf::Message {
+ public:
+  ClubStreamMessageContainer();
+  virtual ~ClubStreamMessageContainer();
+
+  ClubStreamMessageContainer(const ClubStreamMessageContainer& from);
+
+  inline ClubStreamMessageContainer& operator=(const ClubStreamMessageContainer& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ClubStreamMessageContainer& default_instance();
+
+  void Swap(ClubStreamMessageContainer* other);
+
+  // implements Message ----------------------------------------------
+
+  ClubStreamMessageContainer* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClubStreamMessageContainer& from);
+  void MergeFrom(const ClubStreamMessageContainer& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+  inline int message_size() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::StreamMessage& message(int index) const;
+  inline ::bgs::protocol::club::v1::StreamMessage* mutable_message(int index);
+  inline ::bgs::protocol::club::v1::StreamMessage* add_message();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage >&
+      message() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage >*
+      mutable_message();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ClubStreamMessageContainer)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage > message_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClubStreamMessageContainer* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ContentChain : public ::google::protobuf::Message {
+ public:
+  ContentChain();
+  virtual ~ContentChain();
+
+  ContentChain(const ContentChain& from);
+
+  inline ContentChain& operator=(const ContentChain& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ContentChain& default_instance();
+
+  void Swap(ContentChain* other);
+
+  // implements Message ----------------------------------------------
+
+  ContentChain* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ContentChain& from);
+  void MergeFrom(const ContentChain& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string content = 5;
+  inline bool has_content() const;
+  inline void clear_content();
+  static const int kContentFieldNumber = 5;
+  inline const ::std::string& content() const;
+  inline void set_content(const ::std::string& value);
+  inline void set_content(const char* value);
+  inline void set_content(const char* value, size_t size);
+  inline ::std::string* mutable_content();
+  inline ::std::string* release_content();
+  inline void set_allocated_content(::std::string* content);
+
+  // repeated .bgs.protocol.EmbedInfo embed = 6;
+  inline int embed_size() const;
+  inline void clear_embed();
+  static const int kEmbedFieldNumber = 6;
+  inline const ::bgs::protocol::EmbedInfo& embed(int index) const;
+  inline ::bgs::protocol::EmbedInfo* mutable_embed(int index);
+  inline ::bgs::protocol::EmbedInfo* add_embed();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EmbedInfo >&
+      embed() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EmbedInfo >*
+      mutable_embed();
+
+  // optional .bgs.protocol.club.v1.MentionContent mention = 7;
+  inline bool has_mention() const;
+  inline void clear_mention();
+  static const int kMentionFieldNumber = 7;
+  inline const ::bgs::protocol::club::v1::MentionContent& mention() const;
+  inline ::bgs::protocol::club::v1::MentionContent* mutable_mention();
+  inline ::bgs::protocol::club::v1::MentionContent* release_mention();
+  inline void set_allocated_mention(::bgs::protocol::club::v1::MentionContent* mention);
+
+  // optional uint64 edit_time = 8;
+  inline bool has_edit_time() const;
+  inline void clear_edit_time();
+  static const int kEditTimeFieldNumber = 8;
+  inline ::google::protobuf::uint64 edit_time() const;
+  inline void set_edit_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.ContentChain)
+ private:
+  inline void set_has_content();
+  inline void clear_has_content();
+  inline void set_has_mention();
+  inline void clear_has_mention();
+  inline void set_has_edit_time();
+  inline void clear_has_edit_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* content_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EmbedInfo > embed_;
+  ::bgs::protocol::club::v1::MentionContent* mention_;
+  ::google::protobuf::uint64 edit_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static ContentChain* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamMessage : public ::google::protobuf::Message {
+ public:
+  StreamMessage();
+  virtual ~StreamMessage();
+
+  StreamMessage(const StreamMessage& from);
+
+  inline StreamMessage& operator=(const StreamMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamMessage& default_instance();
+
+  void Swap(StreamMessage* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamMessage* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamMessage& from);
+  void MergeFrom(const StreamMessage& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.MessageId id = 3;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 3;
+  inline const ::bgs::protocol::MessageId& id() const;
+  inline ::bgs::protocol::MessageId* mutable_id();
+  inline ::bgs::protocol::MessageId* release_id();
+  inline void set_allocated_id(::bgs::protocol::MessageId* id);
+
+  // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+  inline bool has_author() const;
+  inline void clear_author();
+  static const int kAuthorFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::MemberDescription& author() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_author();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_author();
+  inline void set_allocated_author(::bgs::protocol::club::v1::MemberDescription* author);
+
+  // repeated .bgs.protocol.club.v1.ContentChain content_chain = 6;
+  inline int content_chain_size() const;
+  inline void clear_content_chain();
+  static const int kContentChainFieldNumber = 6;
+  inline const ::bgs::protocol::club::v1::ContentChain& content_chain(int index) const;
+  inline ::bgs::protocol::club::v1::ContentChain* mutable_content_chain(int index);
+  inline ::bgs::protocol::club::v1::ContentChain* add_content_chain();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ContentChain >&
+      content_chain() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ContentChain >*
+      mutable_content_chain();
+
+  // optional .bgs.protocol.club.v1.MemberDescription destroyer = 15;
+  inline bool has_destroyer() const;
+  inline void clear_destroyer();
+  static const int kDestroyerFieldNumber = 15;
+  inline const ::bgs::protocol::club::v1::MemberDescription& destroyer() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_destroyer();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_destroyer();
+  inline void set_allocated_destroyer(::bgs::protocol::club::v1::MemberDescription* destroyer);
+
+  // optional bool destroyed = 16;
+  inline bool has_destroyed() const;
+  inline void clear_destroyed();
+  static const int kDestroyedFieldNumber = 16;
+  inline bool destroyed() const;
+  inline void set_destroyed(bool value);
+
+  // optional uint64 destroy_time = 17;
+  inline bool has_destroy_time() const;
+  inline void clear_destroy_time();
+  static const int kDestroyTimeFieldNumber = 17;
+  inline ::google::protobuf::uint64 destroy_time() const;
+  inline void set_destroy_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamMessage)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_author();
+  inline void clear_has_author();
+  inline void set_has_destroyer();
+  inline void clear_has_destroyer();
+  inline void set_has_destroyed();
+  inline void clear_has_destroyed();
+  inline void set_has_destroy_time();
+  inline void clear_has_destroy_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::MessageId* id_;
+  ::bgs::protocol::club::v1::MemberDescription* author_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ContentChain > content_chain_;
+  ::bgs::protocol::club::v1::MemberDescription* destroyer_;
+  ::google::protobuf::uint64 destroy_time_;
+  bool destroyed_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamMessage* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamMention : public ::google::protobuf::Message {
+ public:
+  StreamMention();
+  virtual ~StreamMention();
+
+  StreamMention(const StreamMention& from);
+
+  inline StreamMention& operator=(const StreamMention& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamMention& default_instance();
+
+  void Swap(StreamMention* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamMention* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamMention& from);
+  void MergeFrom(const StreamMention& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 club_id = 1;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 2;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.MessageId message_id = 3;
+  inline bool has_message_id() const;
+  inline void clear_message_id();
+  static const int kMessageIdFieldNumber = 3;
+  inline const ::bgs::protocol::MessageId& message_id() const;
+  inline ::bgs::protocol::MessageId* mutable_message_id();
+  inline ::bgs::protocol::MessageId* release_message_id();
+  inline void set_allocated_message_id(::bgs::protocol::MessageId* message_id);
+
+  // optional .bgs.protocol.club.v1.MemberDescription author = 4;
+  inline bool has_author() const;
+  inline void clear_author();
+  static const int kAuthorFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::MemberDescription& author() const;
+  inline ::bgs::protocol::club::v1::MemberDescription* mutable_author();
+  inline ::bgs::protocol::club::v1::MemberDescription* release_author();
+  inline void set_allocated_author(::bgs::protocol::club::v1::MemberDescription* author);
+
+  // optional bool destroyed = 5;
+  inline bool has_destroyed() const;
+  inline void clear_destroyed();
+  static const int kDestroyedFieldNumber = 5;
+  inline bool destroyed() const;
+  inline void set_destroyed(bool value);
+
+  // optional .bgs.protocol.TimeSeriesId mention_id = 6;
+  inline bool has_mention_id() const;
+  inline void clear_mention_id();
+  static const int kMentionIdFieldNumber = 6;
+  inline const ::bgs::protocol::TimeSeriesId& mention_id() const;
+  inline ::bgs::protocol::TimeSeriesId* mutable_mention_id();
+  inline ::bgs::protocol::TimeSeriesId* release_mention_id();
+  inline void set_allocated_mention_id(::bgs::protocol::TimeSeriesId* mention_id);
+
+  // optional .bgs.protocol.club.v1.MemberId member_id = 7;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 7;
+  inline const ::bgs::protocol::club::v1::MemberId& member_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_member_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamMention)
+ private:
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_message_id();
+  inline void clear_has_message_id();
+  inline void set_has_author();
+  inline void clear_has_author();
+  inline void set_has_destroyed();
+  inline void clear_has_destroyed();
+  inline void set_has_mention_id();
+  inline void clear_has_mention_id();
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::MessageId* message_id_;
+  ::bgs::protocol::club::v1::MemberDescription* author_;
+  ::bgs::protocol::TimeSeriesId* mention_id_;
+  ::bgs::protocol::club::v1::MemberId* member_id_;
+  bool destroyed_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamMention* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamView : public ::google::protobuf::Message {
+ public:
+  StreamView();
+  virtual ~StreamView();
+
+  StreamView(const StreamView& from);
+
+  inline StreamView& operator=(const StreamView& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamView& default_instance();
+
+  void Swap(StreamView* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamView* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamView& from);
+  void MergeFrom(const StreamView& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 club_id = 1;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 2;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.ViewMarker marker = 3;
+  inline bool has_marker() const;
+  inline void clear_marker();
+  static const int kMarkerFieldNumber = 3;
+  inline const ::bgs::protocol::ViewMarker& marker() const;
+  inline ::bgs::protocol::ViewMarker* mutable_marker();
+  inline ::bgs::protocol::ViewMarker* release_marker();
+  inline void set_allocated_marker(::bgs::protocol::ViewMarker* marker);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamView)
+ private:
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_marker();
+  inline void clear_has_marker();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::ViewMarker* marker_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamView* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamAdvanceViewTime : public ::google::protobuf::Message {
+ public:
+  StreamAdvanceViewTime();
+  virtual ~StreamAdvanceViewTime();
+
+  StreamAdvanceViewTime(const StreamAdvanceViewTime& from);
+
+  inline StreamAdvanceViewTime& operator=(const StreamAdvanceViewTime& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamAdvanceViewTime& default_instance();
+
+  void Swap(StreamAdvanceViewTime* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamAdvanceViewTime* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamAdvanceViewTime& from);
+  void MergeFrom(const StreamAdvanceViewTime& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 stream_id = 1;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional uint64 view_time = 2;
+  inline bool has_view_time() const;
+  inline void clear_view_time();
+  static const int kViewTimeFieldNumber = 2;
+  inline ::google::protobuf::uint64 view_time() const;
+  inline void set_view_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamAdvanceViewTime)
+ private:
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_view_time();
+  inline void clear_has_view_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 stream_id_;
+  ::google::protobuf::uint64 view_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamAdvanceViewTime* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamEventTime : public ::google::protobuf::Message {
+ public:
+  StreamEventTime();
+  virtual ~StreamEventTime();
+
+  StreamEventTime(const StreamEventTime& from);
+
+  inline StreamEventTime& operator=(const StreamEventTime& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamEventTime& default_instance();
+
+  void Swap(StreamEventTime* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamEventTime* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamEventTime& from);
+  void MergeFrom(const StreamEventTime& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 stream_id = 1;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional uint64 event_time = 2;
+  inline bool has_event_time() const;
+  inline void clear_event_time();
+  static const int kEventTimeFieldNumber = 2;
+  inline ::google::protobuf::uint64 event_time() const;
+  inline void set_event_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamEventTime)
+ private:
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_event_time();
+  inline void clear_has_event_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 stream_id_;
+  ::google::protobuf::uint64 event_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamEventTime* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamMentionView : public ::google::protobuf::Message {
+ public:
+  StreamMentionView();
+  virtual ~StreamMentionView();
+
+  StreamMentionView(const StreamMentionView& from);
+
+  inline StreamMentionView& operator=(const StreamMentionView& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamMentionView& default_instance();
+
+  void Swap(StreamMentionView* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamMentionView* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamMentionView& from);
+  void MergeFrom(const StreamMentionView& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 club_id = 1;
+  inline bool has_club_id() const;
+  inline void clear_club_id();
+  static const int kClubIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 club_id() const;
+  inline void set_club_id(::google::protobuf::uint64 value);
+
+  // optional uint64 stream_id = 2;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.ViewMarker marker = 3;
+  inline bool has_marker() const;
+  inline void clear_marker();
+  static const int kMarkerFieldNumber = 3;
+  inline const ::bgs::protocol::ViewMarker& marker() const;
+  inline ::bgs::protocol::ViewMarker* mutable_marker();
+  inline ::bgs::protocol::ViewMarker* release_marker();
+  inline void set_allocated_marker(::bgs::protocol::ViewMarker* marker);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamMentionView)
+ private:
+  inline void set_has_club_id();
+  inline void clear_has_club_id();
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_marker();
+  inline void clear_has_marker();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 club_id_;
+  ::google::protobuf::uint64 stream_id_;
+  ::bgs::protocol::ViewMarker* marker_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamMentionView* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamStateOptions : public ::google::protobuf::Message {
+ public:
+  StreamStateOptions();
+  virtual ~StreamStateOptions();
+
+  StreamStateOptions(const StreamStateOptions& from);
+
+  inline StreamStateOptions& operator=(const StreamStateOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamStateOptions& default_instance();
+
+  void Swap(StreamStateOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamStateOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamStateOptions& from);
+  void MergeFrom(const StreamStateOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string name = 2;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string subject = 3;
+  inline bool has_subject() const;
+  inline void clear_subject();
+  static const int kSubjectFieldNumber = 3;
+  inline const ::std::string& subject() const;
+  inline void set_subject(const ::std::string& value);
+  inline void set_subject(const char* value);
+  inline void set_subject(const char* value, size_t size);
+  inline ::std::string* mutable_subject();
+  inline ::std::string* release_subject();
+  inline void set_allocated_subject(::std::string* subject);
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 4;
+  inline bool has_access() const;
+  inline void clear_access();
+  static const int kAccessFieldNumber = 4;
+  inline const ::bgs::protocol::club::v1::StreamAccess& access() const;
+  inline ::bgs::protocol::club::v1::StreamAccess* mutable_access();
+  inline ::bgs::protocol::club::v1::StreamAccess* release_access();
+  inline void set_allocated_access(::bgs::protocol::club::v1::StreamAccess* access);
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+  inline bool has_voice_level() const;
+  inline void clear_voice_level();
+  static const int kVoiceLevelFieldNumber = 5;
+  inline ::bgs::protocol::club::v1::StreamVoiceLevel voice_level() const;
+  inline void set_voice_level(::bgs::protocol::club::v1::StreamVoiceLevel value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamStateOptions)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_subject();
+  inline void clear_has_subject();
+  inline void set_has_access();
+  inline void clear_has_access();
+  inline void set_has_voice_level();
+  inline void clear_has_voice_level();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* name_;
+  ::std::string* subject_;
+  ::bgs::protocol::club::v1::StreamAccess* access_;
+  int voice_level_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamStateOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamStateAssignment : public ::google::protobuf::Message {
+ public:
+  StreamStateAssignment();
+  virtual ~StreamStateAssignment();
+
+  StreamStateAssignment(const StreamStateAssignment& from);
+
+  inline StreamStateAssignment& operator=(const StreamStateAssignment& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamStateAssignment& default_instance();
+
+  void Swap(StreamStateAssignment* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamStateAssignment* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamStateAssignment& from);
+  void MergeFrom(const StreamStateAssignment& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 stream_id = 1;
+  inline bool has_stream_id() const;
+  inline void clear_stream_id();
+  static const int kStreamIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 stream_id() const;
+  inline void set_stream_id(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.v2.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::v2::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::v2::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::v2::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+      mutable_attribute();
+
+  // optional string name = 3;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 3;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string subject = 4;
+  inline bool has_subject() const;
+  inline void clear_subject();
+  static const int kSubjectFieldNumber = 4;
+  inline const ::std::string& subject() const;
+  inline void set_subject(const ::std::string& value);
+  inline void set_subject(const char* value);
+  inline void set_subject(const char* value, size_t size);
+  inline ::std::string* mutable_subject();
+  inline ::std::string* release_subject();
+  inline void set_allocated_subject(::std::string* subject);
+
+  // optional .bgs.protocol.club.v1.StreamAccess access = 5;
+  inline bool has_access() const;
+  inline void clear_access();
+  static const int kAccessFieldNumber = 5;
+  inline const ::bgs::protocol::club::v1::StreamAccess& access() const;
+  inline ::bgs::protocol::club::v1::StreamAccess* mutable_access();
+  inline ::bgs::protocol::club::v1::StreamAccess* release_access();
+  inline void set_allocated_access(::bgs::protocol::club::v1::StreamAccess* access);
+
+  // optional bool stream_subscription_removed = 6;
+  inline bool has_stream_subscription_removed() const;
+  inline void clear_stream_subscription_removed();
+  static const int kStreamSubscriptionRemovedFieldNumber = 6;
+  inline bool stream_subscription_removed() const;
+  inline void set_stream_subscription_removed(bool value);
+
+  // optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+  inline bool has_voice_level() const;
+  inline void clear_voice_level();
+  static const int kVoiceLevelFieldNumber = 7;
+  inline ::bgs::protocol::club::v1::StreamVoiceLevel voice_level() const;
+  inline void set_voice_level(::bgs::protocol::club::v1::StreamVoiceLevel value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamStateAssignment)
+ private:
+  inline void set_has_stream_id();
+  inline void clear_has_stream_id();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_subject();
+  inline void clear_has_subject();
+  inline void set_has_access();
+  inline void clear_has_access();
+  inline void set_has_stream_subscription_removed();
+  inline void clear_has_stream_subscription_removed();
+  inline void set_has_voice_level();
+  inline void clear_has_voice_level();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 stream_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute > attribute_;
+  ::std::string* name_;
+  ::std::string* subject_;
+  ::bgs::protocol::club::v1::StreamAccess* access_;
+  bool stream_subscription_removed_;
+  int voice_level_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamStateAssignment* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StreamTypingIndicator : public ::google::protobuf::Message {
+ public:
+  StreamTypingIndicator();
+  virtual ~StreamTypingIndicator();
+
+  StreamTypingIndicator(const StreamTypingIndicator& from);
+
+  inline StreamTypingIndicator& operator=(const StreamTypingIndicator& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StreamTypingIndicator& default_instance();
+
+  void Swap(StreamTypingIndicator* other);
+
+  // implements Message ----------------------------------------------
+
+  StreamTypingIndicator* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StreamTypingIndicator& from);
+  void MergeFrom(const StreamTypingIndicator& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.club.v1.MemberId author_id = 1;
+  inline bool has_author_id() const;
+  inline void clear_author_id();
+  static const int kAuthorIdFieldNumber = 1;
+  inline const ::bgs::protocol::club::v1::MemberId& author_id() const;
+  inline ::bgs::protocol::club::v1::MemberId* mutable_author_id();
+  inline ::bgs::protocol::club::v1::MemberId* release_author_id();
+  inline void set_allocated_author_id(::bgs::protocol::club::v1::MemberId* author_id);
+
+  // optional .bgs.protocol.TypingIndicator indicator = 2;
+  inline bool has_indicator() const;
+  inline void clear_indicator();
+  static const int kIndicatorFieldNumber = 2;
+  inline ::bgs::protocol::TypingIndicator indicator() const;
+  inline void set_indicator(::bgs::protocol::TypingIndicator value);
+
+  // optional uint64 epoch = 3;
+  inline bool has_epoch() const;
+  inline void clear_epoch();
+  static const int kEpochFieldNumber = 3;
+  inline ::google::protobuf::uint64 epoch() const;
+  inline void set_epoch(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.club.v1.StreamTypingIndicator)
+ private:
+  inline void set_has_author_id();
+  inline void clear_has_author_id();
+  inline void set_has_indicator();
+  inline void clear_has_indicator();
+  inline void set_has_epoch();
+  inline void clear_has_epoch();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::club::v1::MemberId* author_id_;
+  ::google::protobuf::uint64 epoch_;
+  int indicator_;
+  friend void TC_PROTO_API protobuf_AddDesc_club_5fstream_2eproto();
+  friend void protobuf_AssignDesc_club_5fstream_2eproto();
+  friend void protobuf_ShutdownFile_club_5fstream_2eproto();
+
+  void InitAsDefaultInstance();
+  static StreamTypingIndicator* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// StreamPosition
+
+// repeated uint64 stream_id = 1 [packed = true];
+inline int StreamPosition::stream_id_size() const {
+  return stream_id_.size();
+}
+inline void StreamPosition::clear_stream_id() {
+  stream_id_.Clear();
+}
+inline ::google::protobuf::uint64 StreamPosition::stream_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamPosition.stream_id)
+  return stream_id_.Get(index);
+}
+inline void StreamPosition::set_stream_id(int index, ::google::protobuf::uint64 value) {
+  stream_id_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamPosition.stream_id)
+}
+inline void StreamPosition::add_stream_id(::google::protobuf::uint64 value) {
+  stream_id_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.StreamPosition.stream_id)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+StreamPosition::stream_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.StreamPosition.stream_id)
+  return stream_id_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+StreamPosition::mutable_stream_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.StreamPosition.stream_id)
+  return &stream_id_;
+}
+
+// -------------------------------------------------------------------
+
+// StreamAccess
+
+// repeated uint32 role = 1 [packed = true];
+inline int StreamAccess::role_size() const {
+  return role_.size();
+}
+inline void StreamAccess::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 StreamAccess::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAccess.role)
+  return role_.Get(index);
+}
+inline void StreamAccess::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamAccess.role)
+}
+inline void StreamAccess::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.StreamAccess.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+StreamAccess::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.StreamAccess.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+StreamAccess::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.StreamAccess.role)
+  return &role_;
+}
+
+// -------------------------------------------------------------------
+
+// CreateStreamOptions
+
+// repeated .bgs.protocol.v2.Attribute attribute = 1;
+inline int CreateStreamOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void CreateStreamOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& CreateStreamOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateStreamOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* CreateStreamOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateStreamOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* CreateStreamOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.CreateStreamOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+CreateStreamOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.CreateStreamOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+CreateStreamOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.CreateStreamOptions.attribute)
+  return &attribute_;
+}
+
+// optional string name = 2;
+inline bool CreateStreamOptions::has_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CreateStreamOptions::set_has_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CreateStreamOptions::clear_has_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CreateStreamOptions::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& CreateStreamOptions::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateStreamOptions.name)
+  return *name_;
+}
+inline void CreateStreamOptions::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateStreamOptions.name)
+}
+inline void CreateStreamOptions::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.CreateStreamOptions.name)
+}
+inline void CreateStreamOptions::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.CreateStreamOptions.name)
+}
+inline ::std::string* CreateStreamOptions::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateStreamOptions.name)
+  return name_;
+}
+inline ::std::string* CreateStreamOptions::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void CreateStreamOptions::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateStreamOptions.name)
+}
+
+// optional string subject = 3;
+inline bool CreateStreamOptions::has_subject() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CreateStreamOptions::set_has_subject() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CreateStreamOptions::clear_has_subject() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CreateStreamOptions::clear_subject() {
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_->clear();
+  }
+  clear_has_subject();
+}
+inline const ::std::string& CreateStreamOptions::subject() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateStreamOptions.subject)
+  return *subject_;
+}
+inline void CreateStreamOptions::set_subject(const ::std::string& value) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateStreamOptions.subject)
+}
+inline void CreateStreamOptions::set_subject(const char* value) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.CreateStreamOptions.subject)
+}
+inline void CreateStreamOptions::set_subject(const char* value, size_t size) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.CreateStreamOptions.subject)
+}
+inline ::std::string* CreateStreamOptions::mutable_subject() {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateStreamOptions.subject)
+  return subject_;
+}
+inline ::std::string* CreateStreamOptions::release_subject() {
+  clear_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = subject_;
+    subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void CreateStreamOptions::set_allocated_subject(::std::string* subject) {
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subject_;
+  }
+  if (subject) {
+    set_has_subject();
+    subject_ = subject;
+  } else {
+    clear_has_subject();
+    subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateStreamOptions.subject)
+}
+
+// optional .bgs.protocol.club.v1.StreamAccess access = 4;
+inline bool CreateStreamOptions::has_access() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void CreateStreamOptions::set_has_access() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void CreateStreamOptions::clear_has_access() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void CreateStreamOptions::clear_access() {
+  if (access_ != NULL) access_->::bgs::protocol::club::v1::StreamAccess::Clear();
+  clear_has_access();
+}
+inline const ::bgs::protocol::club::v1::StreamAccess& CreateStreamOptions::access() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateStreamOptions.access)
+  return access_ != NULL ? *access_ : *default_instance_->access_;
+}
+inline ::bgs::protocol::club::v1::StreamAccess* CreateStreamOptions::mutable_access() {
+  set_has_access();
+  if (access_ == NULL) access_ = new ::bgs::protocol::club::v1::StreamAccess;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateStreamOptions.access)
+  return access_;
+}
+inline ::bgs::protocol::club::v1::StreamAccess* CreateStreamOptions::release_access() {
+  clear_has_access();
+  ::bgs::protocol::club::v1::StreamAccess* temp = access_;
+  access_ = NULL;
+  return temp;
+}
+inline void CreateStreamOptions::set_allocated_access(::bgs::protocol::club::v1::StreamAccess* access) {
+  delete access_;
+  access_ = access;
+  if (access) {
+    set_has_access();
+  } else {
+    clear_has_access();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateStreamOptions.access)
+}
+
+// optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+inline bool CreateStreamOptions::has_voice_level() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void CreateStreamOptions::set_has_voice_level() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void CreateStreamOptions::clear_has_voice_level() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void CreateStreamOptions::clear_voice_level() {
+  voice_level_ = 0;
+  clear_has_voice_level();
+}
+inline ::bgs::protocol::club::v1::StreamVoiceLevel CreateStreamOptions::voice_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateStreamOptions.voice_level)
+  return static_cast< ::bgs::protocol::club::v1::StreamVoiceLevel >(voice_level_);
+}
+inline void CreateStreamOptions::set_voice_level(::bgs::protocol::club::v1::StreamVoiceLevel value) {
+  assert(::bgs::protocol::club::v1::StreamVoiceLevel_IsValid(value));
+  set_has_voice_level();
+  voice_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateStreamOptions.voice_level)
+}
+
+// -------------------------------------------------------------------
+
+// Stream
+
+// optional uint64 club_id = 1;
+inline bool Stream::has_club_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Stream::set_has_club_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Stream::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Stream::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 Stream::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Stream.club_id)
+  return club_id_;
+}
+inline void Stream::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Stream.club_id)
+}
+
+// optional uint64 id = 2;
+inline bool Stream::has_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Stream::set_has_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Stream::clear_has_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Stream::clear_id() {
+  id_ = GOOGLE_ULONGLONG(0);
+  clear_has_id();
+}
+inline ::google::protobuf::uint64 Stream::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Stream.id)
+  return id_;
+}
+inline void Stream::set_id(::google::protobuf::uint64 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Stream.id)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 3;
+inline int Stream::attribute_size() const {
+  return attribute_.size();
+}
+inline void Stream::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& Stream::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Stream.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* Stream::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Stream.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* Stream::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.Stream.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+Stream::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.Stream.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+Stream::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.Stream.attribute)
+  return &attribute_;
+}
+
+// optional string name = 4;
+inline bool Stream::has_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Stream::set_has_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Stream::clear_has_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Stream::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& Stream::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Stream.name)
+  return *name_;
+}
+inline void Stream::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Stream.name)
+}
+inline void Stream::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.Stream.name)
+}
+inline void Stream::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.Stream.name)
+}
+inline ::std::string* Stream::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Stream.name)
+  return name_;
+}
+inline ::std::string* Stream::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Stream::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Stream.name)
+}
+
+// optional string subject = 5;
+inline bool Stream::has_subject() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Stream::set_has_subject() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Stream::clear_has_subject() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Stream::clear_subject() {
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_->clear();
+  }
+  clear_has_subject();
+}
+inline const ::std::string& Stream::subject() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Stream.subject)
+  return *subject_;
+}
+inline void Stream::set_subject(const ::std::string& value) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Stream.subject)
+}
+inline void Stream::set_subject(const char* value) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.Stream.subject)
+}
+inline void Stream::set_subject(const char* value, size_t size) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.Stream.subject)
+}
+inline ::std::string* Stream::mutable_subject() {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Stream.subject)
+  return subject_;
+}
+inline ::std::string* Stream::release_subject() {
+  clear_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = subject_;
+    subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Stream::set_allocated_subject(::std::string* subject) {
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subject_;
+  }
+  if (subject) {
+    set_has_subject();
+    subject_ = subject;
+  } else {
+    clear_has_subject();
+    subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Stream.subject)
+}
+
+// optional .bgs.protocol.club.v1.StreamAccess access = 6;
+inline bool Stream::has_access() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Stream::set_has_access() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Stream::clear_has_access() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Stream::clear_access() {
+  if (access_ != NULL) access_->::bgs::protocol::club::v1::StreamAccess::Clear();
+  clear_has_access();
+}
+inline const ::bgs::protocol::club::v1::StreamAccess& Stream::access() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Stream.access)
+  return access_ != NULL ? *access_ : *default_instance_->access_;
+}
+inline ::bgs::protocol::club::v1::StreamAccess* Stream::mutable_access() {
+  set_has_access();
+  if (access_ == NULL) access_ = new ::bgs::protocol::club::v1::StreamAccess;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.Stream.access)
+  return access_;
+}
+inline ::bgs::protocol::club::v1::StreamAccess* Stream::release_access() {
+  clear_has_access();
+  ::bgs::protocol::club::v1::StreamAccess* temp = access_;
+  access_ = NULL;
+  return temp;
+}
+inline void Stream::set_allocated_access(::bgs::protocol::club::v1::StreamAccess* access) {
+  delete access_;
+  access_ = access;
+  if (access) {
+    set_has_access();
+  } else {
+    clear_has_access();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.Stream.access)
+}
+
+// optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+inline bool Stream::has_voice_level() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void Stream::set_has_voice_level() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void Stream::clear_has_voice_level() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void Stream::clear_voice_level() {
+  voice_level_ = 0;
+  clear_has_voice_level();
+}
+inline ::bgs::protocol::club::v1::StreamVoiceLevel Stream::voice_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Stream.voice_level)
+  return static_cast< ::bgs::protocol::club::v1::StreamVoiceLevel >(voice_level_);
+}
+inline void Stream::set_voice_level(::bgs::protocol::club::v1::StreamVoiceLevel value) {
+  assert(::bgs::protocol::club::v1::StreamVoiceLevel_IsValid(value));
+  set_has_voice_level();
+  voice_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Stream.voice_level)
+}
+
+// optional uint64 creation_time = 8;
+inline bool Stream::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void Stream::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void Stream::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void Stream::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 Stream::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.Stream.creation_time)
+  return creation_time_;
+}
+inline void Stream::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.Stream.creation_time)
+}
+
+// -------------------------------------------------------------------
+
+// MentionContent
+
+// optional bool all = 1;
+inline bool MentionContent::has_all() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MentionContent::set_has_all() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MentionContent::clear_has_all() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MentionContent::clear_all() {
+  all_ = false;
+  clear_has_all();
+}
+inline bool MentionContent::all() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MentionContent.all)
+  return all_;
+}
+inline void MentionContent::set_all(bool value) {
+  set_has_all();
+  all_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MentionContent.all)
+}
+
+// optional bool here = 2;
+inline bool MentionContent::has_here() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MentionContent::set_has_here() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MentionContent::clear_has_here() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MentionContent::clear_here() {
+  here_ = false;
+  clear_has_here();
+}
+inline bool MentionContent::here() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MentionContent.here)
+  return here_;
+}
+inline void MentionContent::set_here(bool value) {
+  set_has_here();
+  here_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MentionContent.here)
+}
+
+// repeated .bgs.protocol.club.v1.MemberId member_id = 3;
+inline int MentionContent::member_id_size() const {
+  return member_id_.size();
+}
+inline void MentionContent::clear_member_id() {
+  member_id_.Clear();
+}
+inline const ::bgs::protocol::club::v1::MemberId& MentionContent::member_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MentionContent.member_id)
+  return member_id_.Get(index);
+}
+inline ::bgs::protocol::club::v1::MemberId* MentionContent::mutable_member_id(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.MentionContent.member_id)
+  return member_id_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::MemberId* MentionContent::add_member_id() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.MentionContent.member_id)
+  return member_id_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberId >&
+MentionContent::member_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.MentionContent.member_id)
+  return member_id_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::MemberId >*
+MentionContent::mutable_member_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.MentionContent.member_id)
+  return &member_id_;
+}
+
+// repeated uint32 role = 4 [packed = true];
+inline int MentionContent::role_size() const {
+  return role_.size();
+}
+inline void MentionContent::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 MentionContent::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.MentionContent.role)
+  return role_.Get(index);
+}
+inline void MentionContent::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.MentionContent.role)
+}
+inline void MentionContent::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.MentionContent.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+MentionContent::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.MentionContent.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+MentionContent::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.MentionContent.role)
+  return &role_;
+}
+
+// -------------------------------------------------------------------
+
+// CreateMessageOptions
+
+// optional string content = 2;
+inline bool CreateMessageOptions::has_content() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateMessageOptions::set_has_content() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateMessageOptions::clear_has_content() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateMessageOptions::clear_content() {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_->clear();
+  }
+  clear_has_content();
+}
+inline const ::std::string& CreateMessageOptions::content() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateMessageOptions.content)
+  return *content_;
+}
+inline void CreateMessageOptions::set_content(const ::std::string& value) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.CreateMessageOptions.content)
+}
+inline void CreateMessageOptions::set_content(const char* value) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.CreateMessageOptions.content)
+}
+inline void CreateMessageOptions::set_content(const char* value, size_t size) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.CreateMessageOptions.content)
+}
+inline ::std::string* CreateMessageOptions::mutable_content() {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateMessageOptions.content)
+  return content_;
+}
+inline ::std::string* CreateMessageOptions::release_content() {
+  clear_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = content_;
+    content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void CreateMessageOptions::set_allocated_content(::std::string* content) {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete content_;
+  }
+  if (content) {
+    set_has_content();
+    content_ = content;
+  } else {
+    clear_has_content();
+    content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateMessageOptions.content)
+}
+
+// optional .bgs.protocol.club.v1.MentionContent mention = 3;
+inline bool CreateMessageOptions::has_mention() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CreateMessageOptions::set_has_mention() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CreateMessageOptions::clear_has_mention() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CreateMessageOptions::clear_mention() {
+  if (mention_ != NULL) mention_->::bgs::protocol::club::v1::MentionContent::Clear();
+  clear_has_mention();
+}
+inline const ::bgs::protocol::club::v1::MentionContent& CreateMessageOptions::mention() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.CreateMessageOptions.mention)
+  return mention_ != NULL ? *mention_ : *default_instance_->mention_;
+}
+inline ::bgs::protocol::club::v1::MentionContent* CreateMessageOptions::mutable_mention() {
+  set_has_mention();
+  if (mention_ == NULL) mention_ = new ::bgs::protocol::club::v1::MentionContent;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.CreateMessageOptions.mention)
+  return mention_;
+}
+inline ::bgs::protocol::club::v1::MentionContent* CreateMessageOptions::release_mention() {
+  clear_has_mention();
+  ::bgs::protocol::club::v1::MentionContent* temp = mention_;
+  mention_ = NULL;
+  return temp;
+}
+inline void CreateMessageOptions::set_allocated_mention(::bgs::protocol::club::v1::MentionContent* mention) {
+  delete mention_;
+  mention_ = mention;
+  if (mention) {
+    set_has_mention();
+  } else {
+    clear_has_mention();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.CreateMessageOptions.mention)
+}
+
+// -------------------------------------------------------------------
+
+// ClubStreamMessageContainer
+
+// repeated .bgs.protocol.club.v1.StreamMessage message = 1;
+inline int ClubStreamMessageContainer::message_size() const {
+  return message_.size();
+}
+inline void ClubStreamMessageContainer::clear_message() {
+  message_.Clear();
+}
+inline const ::bgs::protocol::club::v1::StreamMessage& ClubStreamMessageContainer::message(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ClubStreamMessageContainer.message)
+  return message_.Get(index);
+}
+inline ::bgs::protocol::club::v1::StreamMessage* ClubStreamMessageContainer::mutable_message(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ClubStreamMessageContainer.message)
+  return message_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::StreamMessage* ClubStreamMessageContainer::add_message() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ClubStreamMessageContainer.message)
+  return message_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage >&
+ClubStreamMessageContainer::message() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ClubStreamMessageContainer.message)
+  return message_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::StreamMessage >*
+ClubStreamMessageContainer::mutable_message() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ClubStreamMessageContainer.message)
+  return &message_;
+}
+
+// -------------------------------------------------------------------
+
+// ContentChain
+
+// optional string content = 5;
+inline bool ContentChain::has_content() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ContentChain::set_has_content() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ContentChain::clear_has_content() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ContentChain::clear_content() {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_->clear();
+  }
+  clear_has_content();
+}
+inline const ::std::string& ContentChain::content() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ContentChain.content)
+  return *content_;
+}
+inline void ContentChain::set_content(const ::std::string& value) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ContentChain.content)
+}
+inline void ContentChain::set_content(const char* value) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.ContentChain.content)
+}
+inline void ContentChain::set_content(const char* value, size_t size) {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  content_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.ContentChain.content)
+}
+inline ::std::string* ContentChain::mutable_content() {
+  set_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    content_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ContentChain.content)
+  return content_;
+}
+inline ::std::string* ContentChain::release_content() {
+  clear_has_content();
+  if (content_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = content_;
+    content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ContentChain::set_allocated_content(::std::string* content) {
+  if (content_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete content_;
+  }
+  if (content) {
+    set_has_content();
+    content_ = content;
+  } else {
+    clear_has_content();
+    content_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ContentChain.content)
+}
+
+// repeated .bgs.protocol.EmbedInfo embed = 6;
+inline int ContentChain::embed_size() const {
+  return embed_.size();
+}
+inline void ContentChain::clear_embed() {
+  embed_.Clear();
+}
+inline const ::bgs::protocol::EmbedInfo& ContentChain::embed(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ContentChain.embed)
+  return embed_.Get(index);
+}
+inline ::bgs::protocol::EmbedInfo* ContentChain::mutable_embed(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ContentChain.embed)
+  return embed_.Mutable(index);
+}
+inline ::bgs::protocol::EmbedInfo* ContentChain::add_embed() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.ContentChain.embed)
+  return embed_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EmbedInfo >&
+ContentChain::embed() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.ContentChain.embed)
+  return embed_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EmbedInfo >*
+ContentChain::mutable_embed() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.ContentChain.embed)
+  return &embed_;
+}
+
+// optional .bgs.protocol.club.v1.MentionContent mention = 7;
+inline bool ContentChain::has_mention() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ContentChain::set_has_mention() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ContentChain::clear_has_mention() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ContentChain::clear_mention() {
+  if (mention_ != NULL) mention_->::bgs::protocol::club::v1::MentionContent::Clear();
+  clear_has_mention();
+}
+inline const ::bgs::protocol::club::v1::MentionContent& ContentChain::mention() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ContentChain.mention)
+  return mention_ != NULL ? *mention_ : *default_instance_->mention_;
+}
+inline ::bgs::protocol::club::v1::MentionContent* ContentChain::mutable_mention() {
+  set_has_mention();
+  if (mention_ == NULL) mention_ = new ::bgs::protocol::club::v1::MentionContent;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.ContentChain.mention)
+  return mention_;
+}
+inline ::bgs::protocol::club::v1::MentionContent* ContentChain::release_mention() {
+  clear_has_mention();
+  ::bgs::protocol::club::v1::MentionContent* temp = mention_;
+  mention_ = NULL;
+  return temp;
+}
+inline void ContentChain::set_allocated_mention(::bgs::protocol::club::v1::MentionContent* mention) {
+  delete mention_;
+  mention_ = mention;
+  if (mention) {
+    set_has_mention();
+  } else {
+    clear_has_mention();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.ContentChain.mention)
+}
+
+// optional uint64 edit_time = 8;
+inline bool ContentChain::has_edit_time() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ContentChain::set_has_edit_time() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ContentChain::clear_has_edit_time() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ContentChain::clear_edit_time() {
+  edit_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_edit_time();
+}
+inline ::google::protobuf::uint64 ContentChain::edit_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.ContentChain.edit_time)
+  return edit_time_;
+}
+inline void ContentChain::set_edit_time(::google::protobuf::uint64 value) {
+  set_has_edit_time();
+  edit_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.ContentChain.edit_time)
+}
+
+// -------------------------------------------------------------------
+
+// StreamMessage
+
+// optional .bgs.protocol.MessageId id = 3;
+inline bool StreamMessage::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamMessage::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamMessage::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamMessage::clear_id() {
+  if (id_ != NULL) id_->::bgs::protocol::MessageId::Clear();
+  clear_has_id();
+}
+inline const ::bgs::protocol::MessageId& StreamMessage::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessage.id)
+  return id_ != NULL ? *id_ : *default_instance_->id_;
+}
+inline ::bgs::protocol::MessageId* StreamMessage::mutable_id() {
+  set_has_id();
+  if (id_ == NULL) id_ = new ::bgs::protocol::MessageId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessage.id)
+  return id_;
+}
+inline ::bgs::protocol::MessageId* StreamMessage::release_id() {
+  clear_has_id();
+  ::bgs::protocol::MessageId* temp = id_;
+  id_ = NULL;
+  return temp;
+}
+inline void StreamMessage::set_allocated_id(::bgs::protocol::MessageId* id) {
+  delete id_;
+  id_ = id;
+  if (id) {
+    set_has_id();
+  } else {
+    clear_has_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMessage.id)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription author = 4;
+inline bool StreamMessage::has_author() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamMessage::set_has_author() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamMessage::clear_has_author() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamMessage::clear_author() {
+  if (author_ != NULL) author_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_author();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& StreamMessage::author() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessage.author)
+  return author_ != NULL ? *author_ : *default_instance_->author_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* StreamMessage::mutable_author() {
+  set_has_author();
+  if (author_ == NULL) author_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessage.author)
+  return author_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* StreamMessage::release_author() {
+  clear_has_author();
+  ::bgs::protocol::club::v1::MemberDescription* temp = author_;
+  author_ = NULL;
+  return temp;
+}
+inline void StreamMessage::set_allocated_author(::bgs::protocol::club::v1::MemberDescription* author) {
+  delete author_;
+  author_ = author;
+  if (author) {
+    set_has_author();
+  } else {
+    clear_has_author();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMessage.author)
+}
+
+// repeated .bgs.protocol.club.v1.ContentChain content_chain = 6;
+inline int StreamMessage::content_chain_size() const {
+  return content_chain_.size();
+}
+inline void StreamMessage::clear_content_chain() {
+  content_chain_.Clear();
+}
+inline const ::bgs::protocol::club::v1::ContentChain& StreamMessage::content_chain(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessage.content_chain)
+  return content_chain_.Get(index);
+}
+inline ::bgs::protocol::club::v1::ContentChain* StreamMessage::mutable_content_chain(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessage.content_chain)
+  return content_chain_.Mutable(index);
+}
+inline ::bgs::protocol::club::v1::ContentChain* StreamMessage::add_content_chain() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.StreamMessage.content_chain)
+  return content_chain_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ContentChain >&
+StreamMessage::content_chain() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.StreamMessage.content_chain)
+  return content_chain_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::club::v1::ContentChain >*
+StreamMessage::mutable_content_chain() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.StreamMessage.content_chain)
+  return &content_chain_;
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription destroyer = 15;
+inline bool StreamMessage::has_destroyer() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamMessage::set_has_destroyer() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamMessage::clear_has_destroyer() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamMessage::clear_destroyer() {
+  if (destroyer_ != NULL) destroyer_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_destroyer();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& StreamMessage::destroyer() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessage.destroyer)
+  return destroyer_ != NULL ? *destroyer_ : *default_instance_->destroyer_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* StreamMessage::mutable_destroyer() {
+  set_has_destroyer();
+  if (destroyer_ == NULL) destroyer_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMessage.destroyer)
+  return destroyer_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* StreamMessage::release_destroyer() {
+  clear_has_destroyer();
+  ::bgs::protocol::club::v1::MemberDescription* temp = destroyer_;
+  destroyer_ = NULL;
+  return temp;
+}
+inline void StreamMessage::set_allocated_destroyer(::bgs::protocol::club::v1::MemberDescription* destroyer) {
+  delete destroyer_;
+  destroyer_ = destroyer;
+  if (destroyer) {
+    set_has_destroyer();
+  } else {
+    clear_has_destroyer();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMessage.destroyer)
+}
+
+// optional bool destroyed = 16;
+inline bool StreamMessage::has_destroyed() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void StreamMessage::set_has_destroyed() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void StreamMessage::clear_has_destroyed() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void StreamMessage::clear_destroyed() {
+  destroyed_ = false;
+  clear_has_destroyed();
+}
+inline bool StreamMessage::destroyed() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessage.destroyed)
+  return destroyed_;
+}
+inline void StreamMessage::set_destroyed(bool value) {
+  set_has_destroyed();
+  destroyed_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMessage.destroyed)
+}
+
+// optional uint64 destroy_time = 17;
+inline bool StreamMessage::has_destroy_time() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void StreamMessage::set_has_destroy_time() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void StreamMessage::clear_has_destroy_time() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void StreamMessage::clear_destroy_time() {
+  destroy_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_destroy_time();
+}
+inline ::google::protobuf::uint64 StreamMessage::destroy_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMessage.destroy_time)
+  return destroy_time_;
+}
+inline void StreamMessage::set_destroy_time(::google::protobuf::uint64 value) {
+  set_has_destroy_time();
+  destroy_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMessage.destroy_time)
+}
+
+// -------------------------------------------------------------------
+
+// StreamMention
+
+// optional uint64 club_id = 1;
+inline bool StreamMention::has_club_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamMention::set_has_club_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamMention::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamMention::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamMention::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMention.club_id)
+  return club_id_;
+}
+inline void StreamMention::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMention.club_id)
+}
+
+// optional uint64 stream_id = 2;
+inline bool StreamMention::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamMention::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamMention::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamMention::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamMention::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMention.stream_id)
+  return stream_id_;
+}
+inline void StreamMention::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMention.stream_id)
+}
+
+// optional .bgs.protocol.MessageId message_id = 3;
+inline bool StreamMention::has_message_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamMention::set_has_message_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamMention::clear_has_message_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamMention::clear_message_id() {
+  if (message_id_ != NULL) message_id_->::bgs::protocol::MessageId::Clear();
+  clear_has_message_id();
+}
+inline const ::bgs::protocol::MessageId& StreamMention::message_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMention.message_id)
+  return message_id_ != NULL ? *message_id_ : *default_instance_->message_id_;
+}
+inline ::bgs::protocol::MessageId* StreamMention::mutable_message_id() {
+  set_has_message_id();
+  if (message_id_ == NULL) message_id_ = new ::bgs::protocol::MessageId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMention.message_id)
+  return message_id_;
+}
+inline ::bgs::protocol::MessageId* StreamMention::release_message_id() {
+  clear_has_message_id();
+  ::bgs::protocol::MessageId* temp = message_id_;
+  message_id_ = NULL;
+  return temp;
+}
+inline void StreamMention::set_allocated_message_id(::bgs::protocol::MessageId* message_id) {
+  delete message_id_;
+  message_id_ = message_id;
+  if (message_id) {
+    set_has_message_id();
+  } else {
+    clear_has_message_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMention.message_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberDescription author = 4;
+inline bool StreamMention::has_author() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamMention::set_has_author() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamMention::clear_has_author() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamMention::clear_author() {
+  if (author_ != NULL) author_->::bgs::protocol::club::v1::MemberDescription::Clear();
+  clear_has_author();
+}
+inline const ::bgs::protocol::club::v1::MemberDescription& StreamMention::author() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMention.author)
+  return author_ != NULL ? *author_ : *default_instance_->author_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* StreamMention::mutable_author() {
+  set_has_author();
+  if (author_ == NULL) author_ = new ::bgs::protocol::club::v1::MemberDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMention.author)
+  return author_;
+}
+inline ::bgs::protocol::club::v1::MemberDescription* StreamMention::release_author() {
+  clear_has_author();
+  ::bgs::protocol::club::v1::MemberDescription* temp = author_;
+  author_ = NULL;
+  return temp;
+}
+inline void StreamMention::set_allocated_author(::bgs::protocol::club::v1::MemberDescription* author) {
+  delete author_;
+  author_ = author;
+  if (author) {
+    set_has_author();
+  } else {
+    clear_has_author();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMention.author)
+}
+
+// optional bool destroyed = 5;
+inline bool StreamMention::has_destroyed() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void StreamMention::set_has_destroyed() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void StreamMention::clear_has_destroyed() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void StreamMention::clear_destroyed() {
+  destroyed_ = false;
+  clear_has_destroyed();
+}
+inline bool StreamMention::destroyed() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMention.destroyed)
+  return destroyed_;
+}
+inline void StreamMention::set_destroyed(bool value) {
+  set_has_destroyed();
+  destroyed_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMention.destroyed)
+}
+
+// optional .bgs.protocol.TimeSeriesId mention_id = 6;
+inline bool StreamMention::has_mention_id() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void StreamMention::set_has_mention_id() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void StreamMention::clear_has_mention_id() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void StreamMention::clear_mention_id() {
+  if (mention_id_ != NULL) mention_id_->::bgs::protocol::TimeSeriesId::Clear();
+  clear_has_mention_id();
+}
+inline const ::bgs::protocol::TimeSeriesId& StreamMention::mention_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMention.mention_id)
+  return mention_id_ != NULL ? *mention_id_ : *default_instance_->mention_id_;
+}
+inline ::bgs::protocol::TimeSeriesId* StreamMention::mutable_mention_id() {
+  set_has_mention_id();
+  if (mention_id_ == NULL) mention_id_ = new ::bgs::protocol::TimeSeriesId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMention.mention_id)
+  return mention_id_;
+}
+inline ::bgs::protocol::TimeSeriesId* StreamMention::release_mention_id() {
+  clear_has_mention_id();
+  ::bgs::protocol::TimeSeriesId* temp = mention_id_;
+  mention_id_ = NULL;
+  return temp;
+}
+inline void StreamMention::set_allocated_mention_id(::bgs::protocol::TimeSeriesId* mention_id) {
+  delete mention_id_;
+  mention_id_ = mention_id;
+  if (mention_id) {
+    set_has_mention_id();
+  } else {
+    clear_has_mention_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMention.mention_id)
+}
+
+// optional .bgs.protocol.club.v1.MemberId member_id = 7;
+inline bool StreamMention::has_member_id() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void StreamMention::set_has_member_id() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void StreamMention::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void StreamMention::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamMention::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMention.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMention::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMention.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamMention::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::club::v1::MemberId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void StreamMention::set_allocated_member_id(::bgs::protocol::club::v1::MemberId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMention.member_id)
+}
+
+// -------------------------------------------------------------------
+
+// StreamView
+
+// optional uint64 club_id = 1;
+inline bool StreamView::has_club_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamView::set_has_club_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamView::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamView::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamView::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamView.club_id)
+  return club_id_;
+}
+inline void StreamView::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamView.club_id)
+}
+
+// optional uint64 stream_id = 2;
+inline bool StreamView::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamView::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamView::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamView::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamView::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamView.stream_id)
+  return stream_id_;
+}
+inline void StreamView::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamView.stream_id)
+}
+
+// optional .bgs.protocol.ViewMarker marker = 3;
+inline bool StreamView::has_marker() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamView::set_has_marker() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamView::clear_has_marker() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamView::clear_marker() {
+  if (marker_ != NULL) marker_->::bgs::protocol::ViewMarker::Clear();
+  clear_has_marker();
+}
+inline const ::bgs::protocol::ViewMarker& StreamView::marker() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamView.marker)
+  return marker_ != NULL ? *marker_ : *default_instance_->marker_;
+}
+inline ::bgs::protocol::ViewMarker* StreamView::mutable_marker() {
+  set_has_marker();
+  if (marker_ == NULL) marker_ = new ::bgs::protocol::ViewMarker;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamView.marker)
+  return marker_;
+}
+inline ::bgs::protocol::ViewMarker* StreamView::release_marker() {
+  clear_has_marker();
+  ::bgs::protocol::ViewMarker* temp = marker_;
+  marker_ = NULL;
+  return temp;
+}
+inline void StreamView::set_allocated_marker(::bgs::protocol::ViewMarker* marker) {
+  delete marker_;
+  marker_ = marker;
+  if (marker) {
+    set_has_marker();
+  } else {
+    clear_has_marker();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamView.marker)
+}
+
+// -------------------------------------------------------------------
+
+// StreamAdvanceViewTime
+
+// optional uint64 stream_id = 1;
+inline bool StreamAdvanceViewTime::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamAdvanceViewTime::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamAdvanceViewTime::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamAdvanceViewTime::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamAdvanceViewTime::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAdvanceViewTime.stream_id)
+  return stream_id_;
+}
+inline void StreamAdvanceViewTime::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamAdvanceViewTime.stream_id)
+}
+
+// optional uint64 view_time = 2;
+inline bool StreamAdvanceViewTime::has_view_time() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamAdvanceViewTime::set_has_view_time() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamAdvanceViewTime::clear_has_view_time() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamAdvanceViewTime::clear_view_time() {
+  view_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_view_time();
+}
+inline ::google::protobuf::uint64 StreamAdvanceViewTime::view_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamAdvanceViewTime.view_time)
+  return view_time_;
+}
+inline void StreamAdvanceViewTime::set_view_time(::google::protobuf::uint64 value) {
+  set_has_view_time();
+  view_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamAdvanceViewTime.view_time)
+}
+
+// -------------------------------------------------------------------
+
+// StreamEventTime
+
+// optional uint64 stream_id = 1;
+inline bool StreamEventTime::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamEventTime::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamEventTime::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamEventTime::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamEventTime::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamEventTime.stream_id)
+  return stream_id_;
+}
+inline void StreamEventTime::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamEventTime.stream_id)
+}
+
+// optional uint64 event_time = 2;
+inline bool StreamEventTime::has_event_time() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamEventTime::set_has_event_time() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamEventTime::clear_has_event_time() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamEventTime::clear_event_time() {
+  event_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_event_time();
+}
+inline ::google::protobuf::uint64 StreamEventTime::event_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamEventTime.event_time)
+  return event_time_;
+}
+inline void StreamEventTime::set_event_time(::google::protobuf::uint64 value) {
+  set_has_event_time();
+  event_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamEventTime.event_time)
+}
+
+// -------------------------------------------------------------------
+
+// StreamMentionView
+
+// optional uint64 club_id = 1;
+inline bool StreamMentionView::has_club_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamMentionView::set_has_club_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamMentionView::clear_has_club_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamMentionView::clear_club_id() {
+  club_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_club_id();
+}
+inline ::google::protobuf::uint64 StreamMentionView::club_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMentionView.club_id)
+  return club_id_;
+}
+inline void StreamMentionView::set_club_id(::google::protobuf::uint64 value) {
+  set_has_club_id();
+  club_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMentionView.club_id)
+}
+
+// optional uint64 stream_id = 2;
+inline bool StreamMentionView::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamMentionView::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamMentionView::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamMentionView::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamMentionView::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMentionView.stream_id)
+  return stream_id_;
+}
+inline void StreamMentionView::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamMentionView.stream_id)
+}
+
+// optional .bgs.protocol.ViewMarker marker = 3;
+inline bool StreamMentionView::has_marker() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamMentionView::set_has_marker() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamMentionView::clear_has_marker() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamMentionView::clear_marker() {
+  if (marker_ != NULL) marker_->::bgs::protocol::ViewMarker::Clear();
+  clear_has_marker();
+}
+inline const ::bgs::protocol::ViewMarker& StreamMentionView::marker() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamMentionView.marker)
+  return marker_ != NULL ? *marker_ : *default_instance_->marker_;
+}
+inline ::bgs::protocol::ViewMarker* StreamMentionView::mutable_marker() {
+  set_has_marker();
+  if (marker_ == NULL) marker_ = new ::bgs::protocol::ViewMarker;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamMentionView.marker)
+  return marker_;
+}
+inline ::bgs::protocol::ViewMarker* StreamMentionView::release_marker() {
+  clear_has_marker();
+  ::bgs::protocol::ViewMarker* temp = marker_;
+  marker_ = NULL;
+  return temp;
+}
+inline void StreamMentionView::set_allocated_marker(::bgs::protocol::ViewMarker* marker) {
+  delete marker_;
+  marker_ = marker;
+  if (marker) {
+    set_has_marker();
+  } else {
+    clear_has_marker();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamMentionView.marker)
+}
+
+// -------------------------------------------------------------------
+
+// StreamStateOptions
+
+// repeated .bgs.protocol.v2.Attribute attribute = 1;
+inline int StreamStateOptions::attribute_size() const {
+  return attribute_.size();
+}
+inline void StreamStateOptions::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& StreamStateOptions::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateOptions.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* StreamStateOptions::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateOptions.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* StreamStateOptions::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.StreamStateOptions.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+StreamStateOptions::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.StreamStateOptions.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+StreamStateOptions::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.StreamStateOptions.attribute)
+  return &attribute_;
+}
+
+// optional string name = 2;
+inline bool StreamStateOptions::has_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamStateOptions::set_has_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamStateOptions::clear_has_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamStateOptions::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& StreamStateOptions::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateOptions.name)
+  return *name_;
+}
+inline void StreamStateOptions::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateOptions.name)
+}
+inline void StreamStateOptions::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.StreamStateOptions.name)
+}
+inline void StreamStateOptions::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.StreamStateOptions.name)
+}
+inline ::std::string* StreamStateOptions::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateOptions.name)
+  return name_;
+}
+inline ::std::string* StreamStateOptions::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void StreamStateOptions::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamStateOptions.name)
+}
+
+// optional string subject = 3;
+inline bool StreamStateOptions::has_subject() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamStateOptions::set_has_subject() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamStateOptions::clear_has_subject() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamStateOptions::clear_subject() {
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_->clear();
+  }
+  clear_has_subject();
+}
+inline const ::std::string& StreamStateOptions::subject() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateOptions.subject)
+  return *subject_;
+}
+inline void StreamStateOptions::set_subject(const ::std::string& value) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateOptions.subject)
+}
+inline void StreamStateOptions::set_subject(const char* value) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.StreamStateOptions.subject)
+}
+inline void StreamStateOptions::set_subject(const char* value, size_t size) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.StreamStateOptions.subject)
+}
+inline ::std::string* StreamStateOptions::mutable_subject() {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateOptions.subject)
+  return subject_;
+}
+inline ::std::string* StreamStateOptions::release_subject() {
+  clear_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = subject_;
+    subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void StreamStateOptions::set_allocated_subject(::std::string* subject) {
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subject_;
+  }
+  if (subject) {
+    set_has_subject();
+    subject_ = subject;
+  } else {
+    clear_has_subject();
+    subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamStateOptions.subject)
+}
+
+// optional .bgs.protocol.club.v1.StreamAccess access = 4;
+inline bool StreamStateOptions::has_access() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamStateOptions::set_has_access() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamStateOptions::clear_has_access() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamStateOptions::clear_access() {
+  if (access_ != NULL) access_->::bgs::protocol::club::v1::StreamAccess::Clear();
+  clear_has_access();
+}
+inline const ::bgs::protocol::club::v1::StreamAccess& StreamStateOptions::access() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateOptions.access)
+  return access_ != NULL ? *access_ : *default_instance_->access_;
+}
+inline ::bgs::protocol::club::v1::StreamAccess* StreamStateOptions::mutable_access() {
+  set_has_access();
+  if (access_ == NULL) access_ = new ::bgs::protocol::club::v1::StreamAccess;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateOptions.access)
+  return access_;
+}
+inline ::bgs::protocol::club::v1::StreamAccess* StreamStateOptions::release_access() {
+  clear_has_access();
+  ::bgs::protocol::club::v1::StreamAccess* temp = access_;
+  access_ = NULL;
+  return temp;
+}
+inline void StreamStateOptions::set_allocated_access(::bgs::protocol::club::v1::StreamAccess* access) {
+  delete access_;
+  access_ = access;
+  if (access) {
+    set_has_access();
+  } else {
+    clear_has_access();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamStateOptions.access)
+}
+
+// optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 5;
+inline bool StreamStateOptions::has_voice_level() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void StreamStateOptions::set_has_voice_level() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void StreamStateOptions::clear_has_voice_level() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void StreamStateOptions::clear_voice_level() {
+  voice_level_ = 0;
+  clear_has_voice_level();
+}
+inline ::bgs::protocol::club::v1::StreamVoiceLevel StreamStateOptions::voice_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateOptions.voice_level)
+  return static_cast< ::bgs::protocol::club::v1::StreamVoiceLevel >(voice_level_);
+}
+inline void StreamStateOptions::set_voice_level(::bgs::protocol::club::v1::StreamVoiceLevel value) {
+  assert(::bgs::protocol::club::v1::StreamVoiceLevel_IsValid(value));
+  set_has_voice_level();
+  voice_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateOptions.voice_level)
+}
+
+// -------------------------------------------------------------------
+
+// StreamStateAssignment
+
+// optional uint64 stream_id = 1;
+inline bool StreamStateAssignment::has_stream_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamStateAssignment::set_has_stream_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamStateAssignment::clear_has_stream_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamStateAssignment::clear_stream_id() {
+  stream_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_stream_id();
+}
+inline ::google::protobuf::uint64 StreamStateAssignment::stream_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateAssignment.stream_id)
+  return stream_id_;
+}
+inline void StreamStateAssignment::set_stream_id(::google::protobuf::uint64 value) {
+  set_has_stream_id();
+  stream_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateAssignment.stream_id)
+}
+
+// repeated .bgs.protocol.v2.Attribute attribute = 2;
+inline int StreamStateAssignment::attribute_size() const {
+  return attribute_.size();
+}
+inline void StreamStateAssignment::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::v2::Attribute& StreamStateAssignment::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateAssignment.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::v2::Attribute* StreamStateAssignment::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateAssignment.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::v2::Attribute* StreamStateAssignment::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.club.v1.StreamStateAssignment.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >&
+StreamStateAssignment::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.club.v1.StreamStateAssignment.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::v2::Attribute >*
+StreamStateAssignment::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.club.v1.StreamStateAssignment.attribute)
+  return &attribute_;
+}
+
+// optional string name = 3;
+inline bool StreamStateAssignment::has_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamStateAssignment::set_has_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamStateAssignment::clear_has_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamStateAssignment::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& StreamStateAssignment::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateAssignment.name)
+  return *name_;
+}
+inline void StreamStateAssignment::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateAssignment.name)
+}
+inline void StreamStateAssignment::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.StreamStateAssignment.name)
+}
+inline void StreamStateAssignment::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.StreamStateAssignment.name)
+}
+inline ::std::string* StreamStateAssignment::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateAssignment.name)
+  return name_;
+}
+inline ::std::string* StreamStateAssignment::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void StreamStateAssignment::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamStateAssignment.name)
+}
+
+// optional string subject = 4;
+inline bool StreamStateAssignment::has_subject() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StreamStateAssignment::set_has_subject() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StreamStateAssignment::clear_has_subject() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StreamStateAssignment::clear_subject() {
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_->clear();
+  }
+  clear_has_subject();
+}
+inline const ::std::string& StreamStateAssignment::subject() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateAssignment.subject)
+  return *subject_;
+}
+inline void StreamStateAssignment::set_subject(const ::std::string& value) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateAssignment.subject)
+}
+inline void StreamStateAssignment::set_subject(const char* value) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.club.v1.StreamStateAssignment.subject)
+}
+inline void StreamStateAssignment::set_subject(const char* value, size_t size) {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  subject_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.club.v1.StreamStateAssignment.subject)
+}
+inline ::std::string* StreamStateAssignment::mutable_subject() {
+  set_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    subject_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateAssignment.subject)
+  return subject_;
+}
+inline ::std::string* StreamStateAssignment::release_subject() {
+  clear_has_subject();
+  if (subject_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = subject_;
+    subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void StreamStateAssignment::set_allocated_subject(::std::string* subject) {
+  if (subject_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete subject_;
+  }
+  if (subject) {
+    set_has_subject();
+    subject_ = subject;
+  } else {
+    clear_has_subject();
+    subject_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamStateAssignment.subject)
+}
+
+// optional .bgs.protocol.club.v1.StreamAccess access = 5;
+inline bool StreamStateAssignment::has_access() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void StreamStateAssignment::set_has_access() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void StreamStateAssignment::clear_has_access() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void StreamStateAssignment::clear_access() {
+  if (access_ != NULL) access_->::bgs::protocol::club::v1::StreamAccess::Clear();
+  clear_has_access();
+}
+inline const ::bgs::protocol::club::v1::StreamAccess& StreamStateAssignment::access() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateAssignment.access)
+  return access_ != NULL ? *access_ : *default_instance_->access_;
+}
+inline ::bgs::protocol::club::v1::StreamAccess* StreamStateAssignment::mutable_access() {
+  set_has_access();
+  if (access_ == NULL) access_ = new ::bgs::protocol::club::v1::StreamAccess;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamStateAssignment.access)
+  return access_;
+}
+inline ::bgs::protocol::club::v1::StreamAccess* StreamStateAssignment::release_access() {
+  clear_has_access();
+  ::bgs::protocol::club::v1::StreamAccess* temp = access_;
+  access_ = NULL;
+  return temp;
+}
+inline void StreamStateAssignment::set_allocated_access(::bgs::protocol::club::v1::StreamAccess* access) {
+  delete access_;
+  access_ = access;
+  if (access) {
+    set_has_access();
+  } else {
+    clear_has_access();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamStateAssignment.access)
+}
+
+// optional bool stream_subscription_removed = 6;
+inline bool StreamStateAssignment::has_stream_subscription_removed() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void StreamStateAssignment::set_has_stream_subscription_removed() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void StreamStateAssignment::clear_has_stream_subscription_removed() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void StreamStateAssignment::clear_stream_subscription_removed() {
+  stream_subscription_removed_ = false;
+  clear_has_stream_subscription_removed();
+}
+inline bool StreamStateAssignment::stream_subscription_removed() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateAssignment.stream_subscription_removed)
+  return stream_subscription_removed_;
+}
+inline void StreamStateAssignment::set_stream_subscription_removed(bool value) {
+  set_has_stream_subscription_removed();
+  stream_subscription_removed_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateAssignment.stream_subscription_removed)
+}
+
+// optional .bgs.protocol.club.v1.StreamVoiceLevel voice_level = 7;
+inline bool StreamStateAssignment::has_voice_level() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void StreamStateAssignment::set_has_voice_level() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void StreamStateAssignment::clear_has_voice_level() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void StreamStateAssignment::clear_voice_level() {
+  voice_level_ = 0;
+  clear_has_voice_level();
+}
+inline ::bgs::protocol::club::v1::StreamVoiceLevel StreamStateAssignment::voice_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamStateAssignment.voice_level)
+  return static_cast< ::bgs::protocol::club::v1::StreamVoiceLevel >(voice_level_);
+}
+inline void StreamStateAssignment::set_voice_level(::bgs::protocol::club::v1::StreamVoiceLevel value) {
+  assert(::bgs::protocol::club::v1::StreamVoiceLevel_IsValid(value));
+  set_has_voice_level();
+  voice_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamStateAssignment.voice_level)
+}
+
+// -------------------------------------------------------------------
+
+// StreamTypingIndicator
+
+// optional .bgs.protocol.club.v1.MemberId author_id = 1;
+inline bool StreamTypingIndicator::has_author_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StreamTypingIndicator::set_has_author_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StreamTypingIndicator::clear_has_author_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StreamTypingIndicator::clear_author_id() {
+  if (author_id_ != NULL) author_id_->::bgs::protocol::club::v1::MemberId::Clear();
+  clear_has_author_id();
+}
+inline const ::bgs::protocol::club::v1::MemberId& StreamTypingIndicator::author_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamTypingIndicator.author_id)
+  return author_id_ != NULL ? *author_id_ : *default_instance_->author_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamTypingIndicator::mutable_author_id() {
+  set_has_author_id();
+  if (author_id_ == NULL) author_id_ = new ::bgs::protocol::club::v1::MemberId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.club.v1.StreamTypingIndicator.author_id)
+  return author_id_;
+}
+inline ::bgs::protocol::club::v1::MemberId* StreamTypingIndicator::release_author_id() {
+  clear_has_author_id();
+  ::bgs::protocol::club::v1::MemberId* temp = author_id_;
+  author_id_ = NULL;
+  return temp;
+}
+inline void StreamTypingIndicator::set_allocated_author_id(::bgs::protocol::club::v1::MemberId* author_id) {
+  delete author_id_;
+  author_id_ = author_id;
+  if (author_id) {
+    set_has_author_id();
+  } else {
+    clear_has_author_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.club.v1.StreamTypingIndicator.author_id)
+}
+
+// optional .bgs.protocol.TypingIndicator indicator = 2;
+inline bool StreamTypingIndicator::has_indicator() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StreamTypingIndicator::set_has_indicator() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StreamTypingIndicator::clear_has_indicator() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StreamTypingIndicator::clear_indicator() {
+  indicator_ = 0;
+  clear_has_indicator();
+}
+inline ::bgs::protocol::TypingIndicator StreamTypingIndicator::indicator() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamTypingIndicator.indicator)
+  return static_cast< ::bgs::protocol::TypingIndicator >(indicator_);
+}
+inline void StreamTypingIndicator::set_indicator(::bgs::protocol::TypingIndicator value) {
+  assert(::bgs::protocol::TypingIndicator_IsValid(value));
+  set_has_indicator();
+  indicator_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamTypingIndicator.indicator)
+}
+
+// optional uint64 epoch = 3;
+inline bool StreamTypingIndicator::has_epoch() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StreamTypingIndicator::set_has_epoch() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StreamTypingIndicator::clear_has_epoch() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StreamTypingIndicator::clear_epoch() {
+  epoch_ = GOOGLE_ULONGLONG(0);
+  clear_has_epoch();
+}
+inline ::google::protobuf::uint64 StreamTypingIndicator::epoch() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.club.v1.StreamTypingIndicator.epoch)
+  return epoch_;
+}
+inline void StreamTypingIndicator::set_epoch(::google::protobuf::uint64 value) {
+  set_has_epoch();
+  epoch_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.club.v1.StreamTypingIndicator.epoch)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5fstream_2eproto__INCLUDED
diff --git a/src/server/proto/Client/club_types.pb.cc b/src/server/proto/Client/club_types.pb.cc
new file mode 100644
index 00000000000..9bc22ab8f75
--- /dev/null
+++ b/src/server/proto/Client/club_types.pb.cc
@@ -0,0 +1,111 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "club_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+namespace {
+
+
+}  // namespace
+
+
+void protobuf_AssignDesc_club_5ftypes_2eproto() {
+  protobuf_AddDesc_club_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "club_types.proto");
+  GOOGLE_CHECK(file != NULL);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_club_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_club_5ftypes_2eproto() {
+}
+
+void protobuf_AddDesc_club_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fmembership_5ftypes_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fenum_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5frole_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5frange_5fset_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fcore_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fmember_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5finvitation_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fban_2eproto();
+  ::bgs::protocol::club::v1::protobuf_AddDesc_club_5fstream_2eproto();
+  ::bgs::protocol::v2::protobuf_AddDesc_api_2fclient_2fv2_2fattribute_5ftypes_2eproto();
+  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_invitation_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_message_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_ets_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_voice_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\020club_types.proto\022\024bgs.protocol.club.v1"
+    "\032\033club_membership_types.proto\032\017club_enum"
+    ".proto\032\017club_role.proto\032\024club_range_set."
+    "proto\032\017club_core.proto\032\021club_member.prot"
+    "o\032\025club_invitation.proto\032\016club_ban.proto"
+    "\032\021club_stream.proto\032#api/client/v2/attri"
+    "bute_types.proto\032\023account_types.proto\032\026e"
+    "vent_view_types.proto\032\026invitation_types."
+    "proto\032\023message_types.proto\032\017ets_types.pr"
+    "oto\032\021voice_types.proto\032\017rpc_types.protoB"
+    "\002H\001P\000P\001P\002P\003P\004P\005P\006P\007P\010P\tP\nP\013P\014P\rP\016P\017P\020", 437);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "club_types.proto", &protobuf_RegisterTypes);
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_club_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_club_5ftypes_2eproto {
+  StaticDescriptorInitializer_club_5ftypes_2eproto() {
+    protobuf_AddDesc_club_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_club_5ftypes_2eproto_;
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/club_types.pb.h b/src/server/proto/Client/club_types.pb.h
new file mode 100644
index 00000000000..f32f93cdd78
--- /dev/null
+++ b/src/server/proto/Client/club_types.pb.h
@@ -0,0 +1,86 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: club_types.proto
+
+#ifndef PROTOBUF_club_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_club_5ftypes_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include "club_membership_types.pb.h"  // IWYU pragma: export
+#include "club_enum.pb.h"  // IWYU pragma: export
+#include "club_role.pb.h"  // IWYU pragma: export
+#include "club_range_set.pb.h"  // IWYU pragma: export
+#include "club_core.pb.h"  // IWYU pragma: export
+#include "club_member.pb.h"  // IWYU pragma: export
+#include "club_invitation.pb.h"  // IWYU pragma: export
+#include "club_ban.pb.h"  // IWYU pragma: export
+#include "club_stream.pb.h"  // IWYU pragma: export
+#include "api/client/v2/attribute_types.pb.h"  // IWYU pragma: export
+#include "account_types.pb.h"  // IWYU pragma: export
+#include "event_view_types.pb.h"  // IWYU pragma: export
+#include "invitation_types.pb.h"  // IWYU pragma: export
+#include "message_types.pb.h"  // IWYU pragma: export
+#include "ets_types.pb.h"  // IWYU pragma: export
+#include "voice_types.pb.h"  // IWYU pragma: export
+#include "rpc_types.pb.h"  // IWYU pragma: export
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace club {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_club_5ftypes_2eproto();
+void protobuf_AssignDesc_club_5ftypes_2eproto();
+void protobuf_ShutdownFile_club_5ftypes_2eproto();
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace club
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_club_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/connection_service.pb.cc b/src/server/proto/Client/connection_service.pb.cc
index 61956fbd484..107b796205c 100644
--- a/src/server/proto/Client/connection_service.pb.cc
+++ b/src/server/proto/Client/connection_service.pb.cc
@@ -175,10 +175,12 @@ void protobuf_AssignDesc_connection_5fservice_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(BindResponse));
   EchoRequest_descriptor_ = file->message_type(6);
-  static const int EchoRequest_offsets_[3] = {
+  static const int EchoRequest_offsets_[5] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, time_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, network_only_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, payload_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, forward_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, forward_client_id_),
   };
   EchoRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -354,32 +356,35 @@ void protobuf_AddDesc_connection_5fservice_2eproto() {
     "ce\022B\n\020imported_service\030\004 \003(\0132(.bgs.proto"
     "col.connection.v1.BoundService\"1\n\014BindRe"
     "sponse\022!\n\023imported_service_id\030\001 \003(\rB\004\020\001\030"
-    "\001\"I\n\013EchoRequest\022\014\n\004time\030\001 \001(\006\022\033\n\014networ"
-    "k_only\030\002 \001(\010:\005false\022\017\n\007payload\030\003 \001(\014\"-\n\014"
-    "EchoResponse\022\014\n\004time\030\001 \001(\006\022\017\n\007payload\030\002 "
-    "\001(\014\"\'\n\021DisconnectRequest\022\022\n\nerror_code\030\001"
-    " \002(\r\"<\n\026DisconnectNotification\022\022\n\nerror_"
-    "code\030\001 \002(\r\022\016\n\006reason\030\002 \001(\t\"\020\n\016EncryptReq"
-    "uest2\330\005\n\021ConnectionService\022h\n\007Connect\022*."
-    "bgs.protocol.connection.v1.ConnectReques"
-    "t\032+.bgs.protocol.connection.v1.ConnectRe"
-    "sponse\"\004\200\265\030\001\022b\n\004Bind\022\'.bgs.protocol.conn"
-    "ection.v1.BindRequest\032(.bgs.protocol.con"
-    "nection.v1.BindResponse\"\007\210\002\001\200\265\030\002\022_\n\004Echo"
-    "\022\'.bgs.protocol.connection.v1.EchoReques"
-    "t\032(.bgs.protocol.connection.v1.EchoRespo"
-    "nse\"\004\200\265\030\003\022f\n\017ForceDisconnect\0222.bgs.proto"
-    "col.connection.v1.DisconnectNotification"
-    "\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\004\022B\n\tKee"
-    "pAlive\022\024.bgs.protocol.NoData\032\031.bgs.proto"
-    "col.NO_RESPONSE\"\004\200\265\030\005\022T\n\007Encrypt\022*.bgs.p"
+    "\001\"\216\001\n\013EchoRequest\022\014\n\004time\030\001 \001(\006\022\033\n\014netwo"
+    "rk_only\030\002 \001(\010:\005false\022\017\n\007payload\030\003 \001(\014\022(\n"
+    "\007forward\030\004 \001(\0132\027.bgs.protocol.ProcessId\022"
+    "\031\n\021forward_client_id\030\005 \001(\t\"-\n\014EchoRespon"
+    "se\022\014\n\004time\030\001 \001(\006\022\017\n\007payload\030\002 \001(\014\"\'\n\021Dis"
+    "connectRequest\022\022\n\nerror_code\030\001 \002(\r\"<\n\026Di"
+    "sconnectNotification\022\022\n\nerror_code\030\001 \002(\r"
+    "\022\016\n\006reason\030\002 \001(\t\"\020\n\016EncryptRequest2\361\005\n\021C"
+    "onnectionService\022j\n\007Connect\022*.bgs.protoc"
+    "ol.connection.v1.ConnectRequest\032+.bgs.pr"
+    "otocol.connection.v1.ConnectResponse\"\006\202\371"
+    "+\002\010\001\022d\n\004Bind\022\'.bgs.protocol.connection.v"
+    "1.BindRequest\032(.bgs.protocol.connection."
+    "v1.BindResponse\"\t\210\002\001\202\371+\002\010\002\022a\n\004Echo\022\'.bgs"
+    ".protocol.connection.v1.EchoRequest\032(.bg"
+    "s.protocol.connection.v1.EchoResponse\"\006\202"
+    "\371+\002\010\003\022h\n\017ForceDisconnect\0222.bgs.protocol."
+    "connection.v1.DisconnectNotification\032\031.b"
+    "gs.protocol.NO_RESPONSE\"\006\202\371+\002\010\004\022D\n\tKeepA"
+    "live\022\024.bgs.protocol.NoData\032\031.bgs.protoco"
+    "l.NO_RESPONSE\"\006\202\371+\002\010\005\022V\n\007Encrypt\022*.bgs.p"
     "rotocol.connection.v1.EncryptRequest\032\024.b"
-    "gs.protocol.NoData\"\007\210\002\001\200\265\030\006\022c\n\021RequestDi"
-    "sconnect\022-.bgs.protocol.connection.v1.Di"
-    "sconnectRequest\032\031.bgs.protocol.NO_RESPON"
-    "SE\"\004\200\265\030\007\032-\312>*bnet.protocol.connection.Co"
-    "nnectionServiceB=\n\033bnet.protocol.connect"
-    "ion.v1B\026ConnectionServiceProtoH\001\200\001\000\210\001\001", 2198);
+    "gs.protocol.NoData\"\t\210\002\001\202\371+\002\010\006\022e\n\021Request"
+    "Disconnect\022-.bgs.protocol.connection.v1."
+    "DisconnectRequest\032\031.bgs.protocol.NO_RESP"
+    "ONSE\"\006\202\371+\002\010\007\0328\202\371+,\n*bnet.protocol.connec"
+    "tion.ConnectionService\212\371+\004\010\001\020\001B=\n\033bnet.p"
+    "rotocol.connection.v1B\026ConnectionService"
+    "ProtoH\001\200\001\000\210\001\001", 2293);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "connection_service.proto", &protobuf_RegisterTypes);
   ConnectRequest::default_instance_ = new ConnectRequest();
@@ -2377,6 +2382,8 @@ void BindResponse::Swap(BindResponse* other) {
 const int EchoRequest::kTimeFieldNumber;
 const int EchoRequest::kNetworkOnlyFieldNumber;
 const int EchoRequest::kPayloadFieldNumber;
+const int EchoRequest::kForwardFieldNumber;
+const int EchoRequest::kForwardClientIdFieldNumber;
 #endif  // !_MSC_VER
 
 EchoRequest::EchoRequest()
@@ -2386,6 +2393,7 @@ EchoRequest::EchoRequest()
 }
 
 void EchoRequest::InitAsDefaultInstance() {
+  forward_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
 }
 
 EchoRequest::EchoRequest(const EchoRequest& from)
@@ -2401,6 +2409,8 @@ void EchoRequest::SharedCtor() {
   time_ = GOOGLE_ULONGLONG(0);
   network_only_ = false;
   payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  forward_ = NULL;
+  forward_client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -2413,7 +2423,11 @@ void EchoRequest::SharedDtor() {
   if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete payload_;
   }
+  if (forward_client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete forward_client_id_;
+  }
   if (this != default_instance_) {
+    delete forward_;
   }
 }
 
@@ -2439,7 +2453,7 @@ EchoRequest* EchoRequest::New() const {
 }
 
 void EchoRequest::Clear() {
-  if (_has_bits_[0 / 32] & 7) {
+  if (_has_bits_[0 / 32] & 31) {
     time_ = GOOGLE_ULONGLONG(0);
     network_only_ = false;
     if (has_payload()) {
@@ -2447,6 +2461,14 @@ void EchoRequest::Clear() {
         payload_->clear();
       }
     }
+    if (has_forward()) {
+      if (forward_ != NULL) forward_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_forward_client_id()) {
+      if (forward_client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        forward_client_id_->clear();
+      }
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -2500,6 +2522,36 @@ bool EchoRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(34)) goto parse_forward;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId forward = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_forward:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_forward()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_forward_client_id;
+        break;
+      }
+
+      // optional string forward_client_id = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_forward_client_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_forward_client_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->forward_client_id().data(), this->forward_client_id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "forward_client_id");
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -2545,6 +2597,22 @@ void EchoRequest::SerializeWithCachedSizes(
       3, this->payload(), output);
   }
 
+  // optional .bgs.protocol.ProcessId forward = 4;
+  if (has_forward()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->forward(), output);
+  }
+
+  // optional string forward_client_id = 5;
+  if (has_forward_client_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->forward_client_id().data(), this->forward_client_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "forward_client_id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->forward_client_id(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -2572,6 +2640,24 @@ void EchoRequest::SerializeWithCachedSizes(
         3, this->payload(), target);
   }
 
+  // optional .bgs.protocol.ProcessId forward = 4;
+  if (has_forward()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->forward(), target);
+  }
+
+  // optional string forward_client_id = 5;
+  if (has_forward_client_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->forward_client_id().data(), this->forward_client_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "forward_client_id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->forward_client_id(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -2601,6 +2687,20 @@ int EchoRequest::ByteSize() const {
           this->payload());
     }
 
+    // optional .bgs.protocol.ProcessId forward = 4;
+    if (has_forward()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->forward());
+    }
+
+    // optional string forward_client_id = 5;
+    if (has_forward_client_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->forward_client_id());
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -2637,6 +2737,12 @@ void EchoRequest::MergeFrom(const EchoRequest& from) {
     if (from.has_payload()) {
       set_payload(from.payload());
     }
+    if (from.has_forward()) {
+      mutable_forward()->::bgs::protocol::ProcessId::MergeFrom(from.forward());
+    }
+    if (from.has_forward_client_id()) {
+      set_forward_client_id(from.forward_client_id());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -2655,6 +2761,9 @@ void EchoRequest::CopyFrom(const EchoRequest& from) {
 
 bool EchoRequest::IsInitialized() const {
 
+  if (has_forward()) {
+    if (!this->forward().IsInitialized()) return false;
+  }
   return true;
 }
 
@@ -2663,6 +2772,8 @@ void EchoRequest::Swap(EchoRequest* other) {
     std::swap(time_, other->time_);
     std::swap(network_only_, other->network_only_);
     std::swap(payload_, other->payload_);
+    std::swap(forward_, other->forward_);
+    std::swap(forward_client_id_, other->forward_client_id_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
diff --git a/src/server/proto/Client/connection_service.pb.h b/src/server/proto/Client/connection_service.pb.h
index 1814ad024bb..be7e0e2f3b1 100644
--- a/src/server/proto/Client/connection_service.pb.h
+++ b/src/server/proto/Client/connection_service.pb.h
@@ -773,6 +773,27 @@ class TC_PROTO_API EchoRequest : public ::google::protobuf::Message {
   inline ::std::string* release_payload();
   inline void set_allocated_payload(::std::string* payload);
 
+  // optional .bgs.protocol.ProcessId forward = 4;
+  inline bool has_forward() const;
+  inline void clear_forward();
+  static const int kForwardFieldNumber = 4;
+  inline const ::bgs::protocol::ProcessId& forward() const;
+  inline ::bgs::protocol::ProcessId* mutable_forward();
+  inline ::bgs::protocol::ProcessId* release_forward();
+  inline void set_allocated_forward(::bgs::protocol::ProcessId* forward);
+
+  // optional string forward_client_id = 5;
+  inline bool has_forward_client_id() const;
+  inline void clear_forward_client_id();
+  static const int kForwardClientIdFieldNumber = 5;
+  inline const ::std::string& forward_client_id() const;
+  inline void set_forward_client_id(const ::std::string& value);
+  inline void set_forward_client_id(const char* value);
+  inline void set_forward_client_id(const char* value, size_t size);
+  inline ::std::string* mutable_forward_client_id();
+  inline ::std::string* release_forward_client_id();
+  inline void set_allocated_forward_client_id(::std::string* forward_client_id);
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.EchoRequest)
  private:
   inline void set_has_time();
@@ -781,6 +802,10 @@ class TC_PROTO_API EchoRequest : public ::google::protobuf::Message {
   inline void clear_has_network_only();
   inline void set_has_payload();
   inline void clear_has_payload();
+  inline void set_has_forward();
+  inline void clear_has_forward();
+  inline void set_has_forward_client_id();
+  inline void clear_has_forward_client_id();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -788,6 +813,8 @@ class TC_PROTO_API EchoRequest : public ::google::protobuf::Message {
   mutable int _cached_size_;
   ::google::protobuf::uint64 time_;
   ::std::string* payload_;
+  ::bgs::protocol::ProcessId* forward_;
+  ::std::string* forward_client_id_;
   bool network_only_;
   friend void TC_PROTO_API protobuf_AddDesc_connection_5fservice_2eproto();
   friend void protobuf_AssignDesc_connection_5fservice_2eproto();
@@ -1940,6 +1967,123 @@ inline void EchoRequest::set_allocated_payload(::std::string* payload) {
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.EchoRequest.payload)
 }
 
+// optional .bgs.protocol.ProcessId forward = 4;
+inline bool EchoRequest::has_forward() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void EchoRequest::set_has_forward() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void EchoRequest::clear_has_forward() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void EchoRequest::clear_forward() {
+  if (forward_ != NULL) forward_->::bgs::protocol::ProcessId::Clear();
+  clear_has_forward();
+}
+inline const ::bgs::protocol::ProcessId& EchoRequest::forward() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoRequest.forward)
+  return forward_ != NULL ? *forward_ : *default_instance_->forward_;
+}
+inline ::bgs::protocol::ProcessId* EchoRequest::mutable_forward() {
+  set_has_forward();
+  if (forward_ == NULL) forward_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.EchoRequest.forward)
+  return forward_;
+}
+inline ::bgs::protocol::ProcessId* EchoRequest::release_forward() {
+  clear_has_forward();
+  ::bgs::protocol::ProcessId* temp = forward_;
+  forward_ = NULL;
+  return temp;
+}
+inline void EchoRequest::set_allocated_forward(::bgs::protocol::ProcessId* forward) {
+  delete forward_;
+  forward_ = forward;
+  if (forward) {
+    set_has_forward();
+  } else {
+    clear_has_forward();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.EchoRequest.forward)
+}
+
+// optional string forward_client_id = 5;
+inline bool EchoRequest::has_forward_client_id() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void EchoRequest::set_has_forward_client_id() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void EchoRequest::clear_has_forward_client_id() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void EchoRequest::clear_forward_client_id() {
+  if (forward_client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    forward_client_id_->clear();
+  }
+  clear_has_forward_client_id();
+}
+inline const ::std::string& EchoRequest::forward_client_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoRequest.forward_client_id)
+  return *forward_client_id_;
+}
+inline void EchoRequest::set_forward_client_id(const ::std::string& value) {
+  set_has_forward_client_id();
+  if (forward_client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    forward_client_id_ = new ::std::string;
+  }
+  forward_client_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoRequest.forward_client_id)
+}
+inline void EchoRequest::set_forward_client_id(const char* value) {
+  set_has_forward_client_id();
+  if (forward_client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    forward_client_id_ = new ::std::string;
+  }
+  forward_client_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.connection.v1.EchoRequest.forward_client_id)
+}
+inline void EchoRequest::set_forward_client_id(const char* value, size_t size) {
+  set_has_forward_client_id();
+  if (forward_client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    forward_client_id_ = new ::std::string;
+  }
+  forward_client_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.connection.v1.EchoRequest.forward_client_id)
+}
+inline ::std::string* EchoRequest::mutable_forward_client_id() {
+  set_has_forward_client_id();
+  if (forward_client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    forward_client_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.EchoRequest.forward_client_id)
+  return forward_client_id_;
+}
+inline ::std::string* EchoRequest::release_forward_client_id() {
+  clear_has_forward_client_id();
+  if (forward_client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = forward_client_id_;
+    forward_client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void EchoRequest::set_allocated_forward_client_id(::std::string* forward_client_id) {
+  if (forward_client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete forward_client_id_;
+  }
+  if (forward_client_id) {
+    set_has_forward_client_id();
+    forward_client_id_ = forward_client_id;
+  } else {
+    clear_has_forward_client_id();
+    forward_client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.EchoRequest.forward_client_id)
+}
+
 // -------------------------------------------------------------------
 
 // EchoResponse
diff --git a/src/server/proto/Client/embed_types.pb.cc b/src/server/proto/Client/embed_types.pb.cc
new file mode 100644
index 00000000000..01733db2093
--- /dev/null
+++ b/src/server/proto/Client/embed_types.pb.cc
@@ -0,0 +1,1255 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: embed_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "embed_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* EmbedImage_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  EmbedImage_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Provider_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Provider_reflection_ = NULL;
+const ::google::protobuf::Descriptor* EmbedInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  EmbedInfo_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_embed_5ftypes_2eproto() {
+  protobuf_AddDesc_embed_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "embed_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  EmbedImage_descriptor_ = file->message_type(0);
+  static const int EmbedImage_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedImage, url_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedImage, width_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedImage, height_),
+  };
+  EmbedImage_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      EmbedImage_descriptor_,
+      EmbedImage::default_instance_,
+      EmbedImage_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedImage, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedImage, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(EmbedImage));
+  Provider_descriptor_ = file->message_type(1);
+  static const int Provider_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Provider, name_),
+  };
+  Provider_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Provider_descriptor_,
+      Provider::default_instance_,
+      Provider_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Provider, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Provider, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Provider));
+  EmbedInfo_descriptor_ = file->message_type(2);
+  static const int EmbedInfo_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedInfo, title_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedInfo, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedInfo, original_url_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedInfo, thumbnail_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedInfo, provider_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedInfo, description_),
+  };
+  EmbedInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      EmbedInfo_descriptor_,
+      EmbedInfo::default_instance_,
+      EmbedInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EmbedInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(EmbedInfo));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_embed_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    EmbedImage_descriptor_, &EmbedImage::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Provider_descriptor_, &Provider::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    EmbedInfo_descriptor_, &EmbedInfo::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_embed_5ftypes_2eproto() {
+  delete EmbedImage::default_instance_;
+  delete EmbedImage_reflection_;
+  delete Provider::default_instance_;
+  delete Provider_reflection_;
+  delete EmbedInfo::default_instance_;
+  delete EmbedInfo_reflection_;
+}
+
+void protobuf_AddDesc_embed_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\021embed_types.proto\022\014bgs.protocol\"8\n\nEmb"
+    "edImage\022\013\n\003url\030\001 \001(\t\022\r\n\005width\030\002 \001(\r\022\016\n\006h"
+    "eight\030\003 \001(\r\"\030\n\010Provider\022\014\n\004name\030\001 \001(\t\"\252\001"
+    "\n\tEmbedInfo\022\r\n\005title\030\001 \001(\t\022\014\n\004type\030\002 \001(\t"
+    "\022\024\n\014original_url\030\003 \001(\t\022+\n\tthumbnail\030\004 \001("
+    "\0132\030.bgs.protocol.EmbedImage\022(\n\010provider\030"
+    "\005 \001(\0132\026.bgs.protocol.Provider\022\023\n\013descrip"
+    "tion\030\006 \001(\tB\002H\001", 294);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "embed_types.proto", &protobuf_RegisterTypes);
+  EmbedImage::default_instance_ = new EmbedImage();
+  Provider::default_instance_ = new Provider();
+  EmbedInfo::default_instance_ = new EmbedInfo();
+  EmbedImage::default_instance_->InitAsDefaultInstance();
+  Provider::default_instance_->InitAsDefaultInstance();
+  EmbedInfo::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_embed_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_embed_5ftypes_2eproto {
+  StaticDescriptorInitializer_embed_5ftypes_2eproto() {
+    protobuf_AddDesc_embed_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_embed_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int EmbedImage::kUrlFieldNumber;
+const int EmbedImage::kWidthFieldNumber;
+const int EmbedImage::kHeightFieldNumber;
+#endif  // !_MSC_VER
+
+EmbedImage::EmbedImage()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.EmbedImage)
+}
+
+void EmbedImage::InitAsDefaultInstance() {
+}
+
+EmbedImage::EmbedImage(const EmbedImage& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.EmbedImage)
+}
+
+void EmbedImage::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  width_ = 0u;
+  height_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+EmbedImage::~EmbedImage() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.EmbedImage)
+  SharedDtor();
+}
+
+void EmbedImage::SharedDtor() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void EmbedImage::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* EmbedImage::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EmbedImage_descriptor_;
+}
+
+const EmbedImage& EmbedImage::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_embed_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+EmbedImage* EmbedImage::default_instance_ = NULL;
+
+EmbedImage* EmbedImage::New() const {
+  return new EmbedImage;
+}
+
+void EmbedImage::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<EmbedImage*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(width_, height_);
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool EmbedImage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.EmbedImage)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string url = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->url().data(), this->url().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "url");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_width;
+        break;
+      }
+
+      // optional uint32 width = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_width:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &width_)));
+          set_has_width();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_height;
+        break;
+      }
+
+      // optional uint32 height = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_height:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &height_)));
+          set_has_height();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.EmbedImage)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.EmbedImage)
+  return false;
+#undef DO_
+}
+
+void EmbedImage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.EmbedImage)
+  // optional string url = 1;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->url().data(), this->url().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "url");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->url(), output);
+  }
+
+  // optional uint32 width = 2;
+  if (has_width()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->width(), output);
+  }
+
+  // optional uint32 height = 3;
+  if (has_height()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->height(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.EmbedImage)
+}
+
+::google::protobuf::uint8* EmbedImage::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.EmbedImage)
+  // optional string url = 1;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->url().data(), this->url().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "url");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->url(), target);
+  }
+
+  // optional uint32 width = 2;
+  if (has_width()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->width(), target);
+  }
+
+  // optional uint32 height = 3;
+  if (has_height()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->height(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.EmbedImage)
+  return target;
+}
+
+int EmbedImage::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string url = 1;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // optional uint32 width = 2;
+    if (has_width()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->width());
+    }
+
+    // optional uint32 height = 3;
+    if (has_height()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->height());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void EmbedImage::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const EmbedImage* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const EmbedImage*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void EmbedImage::MergeFrom(const EmbedImage& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_width()) {
+      set_width(from.width());
+    }
+    if (from.has_height()) {
+      set_height(from.height());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void EmbedImage::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void EmbedImage::CopyFrom(const EmbedImage& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EmbedImage::IsInitialized() const {
+
+  return true;
+}
+
+void EmbedImage::Swap(EmbedImage* other) {
+  if (other != this) {
+    std::swap(url_, other->url_);
+    std::swap(width_, other->width_);
+    std::swap(height_, other->height_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata EmbedImage::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = EmbedImage_descriptor_;
+  metadata.reflection = EmbedImage_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Provider::kNameFieldNumber;
+#endif  // !_MSC_VER
+
+Provider::Provider()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.Provider)
+}
+
+void Provider::InitAsDefaultInstance() {
+}
+
+Provider::Provider(const Provider& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Provider)
+}
+
+void Provider::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Provider::~Provider() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.Provider)
+  SharedDtor();
+}
+
+void Provider::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void Provider::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Provider::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Provider_descriptor_;
+}
+
+const Provider& Provider::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_embed_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Provider* Provider::default_instance_ = NULL;
+
+Provider* Provider::New() const {
+  return new Provider;
+}
+
+void Provider::Clear() {
+  if (has_name()) {
+    if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      name_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Provider::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.Provider)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.Provider)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.Provider)
+  return false;
+#undef DO_
+}
+
+void Provider::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.Provider)
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->name(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.Provider)
+}
+
+::google::protobuf::uint8* Provider::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Provider)
+  // optional string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->name(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Provider)
+  return target;
+}
+
+int Provider::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Provider::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Provider* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Provider*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Provider::MergeFrom(const Provider& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Provider::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Provider::CopyFrom(const Provider& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Provider::IsInitialized() const {
+
+  return true;
+}
+
+void Provider::Swap(Provider* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Provider::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Provider_descriptor_;
+  metadata.reflection = Provider_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int EmbedInfo::kTitleFieldNumber;
+const int EmbedInfo::kTypeFieldNumber;
+const int EmbedInfo::kOriginalUrlFieldNumber;
+const int EmbedInfo::kThumbnailFieldNumber;
+const int EmbedInfo::kProviderFieldNumber;
+const int EmbedInfo::kDescriptionFieldNumber;
+#endif  // !_MSC_VER
+
+EmbedInfo::EmbedInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.EmbedInfo)
+}
+
+void EmbedInfo::InitAsDefaultInstance() {
+  thumbnail_ = const_cast< ::bgs::protocol::EmbedImage*>(&::bgs::protocol::EmbedImage::default_instance());
+  provider_ = const_cast< ::bgs::protocol::Provider*>(&::bgs::protocol::Provider::default_instance());
+}
+
+EmbedInfo::EmbedInfo(const EmbedInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.EmbedInfo)
+}
+
+void EmbedInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  title_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  original_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  thumbnail_ = NULL;
+  provider_ = NULL;
+  description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+EmbedInfo::~EmbedInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.EmbedInfo)
+  SharedDtor();
+}
+
+void EmbedInfo::SharedDtor() {
+  if (title_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete title_;
+  }
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete type_;
+  }
+  if (original_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete original_url_;
+  }
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (this != default_instance_) {
+    delete thumbnail_;
+    delete provider_;
+  }
+}
+
+void EmbedInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* EmbedInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EmbedInfo_descriptor_;
+}
+
+const EmbedInfo& EmbedInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_embed_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+EmbedInfo* EmbedInfo::default_instance_ = NULL;
+
+EmbedInfo* EmbedInfo::New() const {
+  return new EmbedInfo;
+}
+
+void EmbedInfo::Clear() {
+  if (_has_bits_[0 / 32] & 63) {
+    if (has_title()) {
+      if (title_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        title_->clear();
+      }
+    }
+    if (has_type()) {
+      if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        type_->clear();
+      }
+    }
+    if (has_original_url()) {
+      if (original_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        original_url_->clear();
+      }
+    }
+    if (has_thumbnail()) {
+      if (thumbnail_ != NULL) thumbnail_->::bgs::protocol::EmbedImage::Clear();
+    }
+    if (has_provider()) {
+      if (provider_ != NULL) provider_->::bgs::protocol::Provider::Clear();
+    }
+    if (has_description()) {
+      if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        description_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool EmbedInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.EmbedInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string title = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_title()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->title().data(), this->title().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "title");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_type;
+        break;
+      }
+
+      // optional string type = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->type().data(), this->type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "type");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_original_url;
+        break;
+      }
+
+      // optional string original_url = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_original_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_original_url()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->original_url().data(), this->original_url().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "original_url");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_thumbnail;
+        break;
+      }
+
+      // optional .bgs.protocol.EmbedImage thumbnail = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_thumbnail:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_thumbnail()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_provider;
+        break;
+      }
+
+      // optional .bgs.protocol.Provider provider = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_provider:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_provider()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_description;
+        break;
+      }
+
+      // optional string description = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_description:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_description()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->description().data(), this->description().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "description");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.EmbedInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.EmbedInfo)
+  return false;
+#undef DO_
+}
+
+void EmbedInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.EmbedInfo)
+  // optional string title = 1;
+  if (has_title()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->title().data(), this->title().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "title");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->title(), output);
+  }
+
+  // optional string type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "type");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->type(), output);
+  }
+
+  // optional string original_url = 3;
+  if (has_original_url()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->original_url().data(), this->original_url().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "original_url");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->original_url(), output);
+  }
+
+  // optional .bgs.protocol.EmbedImage thumbnail = 4;
+  if (has_thumbnail()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->thumbnail(), output);
+  }
+
+  // optional .bgs.protocol.Provider provider = 5;
+  if (has_provider()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->provider(), output);
+  }
+
+  // optional string description = 6;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      6, this->description(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.EmbedInfo)
+}
+
+::google::protobuf::uint8* EmbedInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.EmbedInfo)
+  // optional string title = 1;
+  if (has_title()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->title().data(), this->title().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "title");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->title(), target);
+  }
+
+  // optional string type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "type");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->type(), target);
+  }
+
+  // optional string original_url = 3;
+  if (has_original_url()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->original_url().data(), this->original_url().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "original_url");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->original_url(), target);
+  }
+
+  // optional .bgs.protocol.EmbedImage thumbnail = 4;
+  if (has_thumbnail()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->thumbnail(), target);
+  }
+
+  // optional .bgs.protocol.Provider provider = 5;
+  if (has_provider()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->provider(), target);
+  }
+
+  // optional string description = 6;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->description().data(), this->description().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "description");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->description(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.EmbedInfo)
+  return target;
+}
+
+int EmbedInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string title = 1;
+    if (has_title()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->title());
+    }
+
+    // optional string type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->type());
+    }
+
+    // optional string original_url = 3;
+    if (has_original_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->original_url());
+    }
+
+    // optional .bgs.protocol.EmbedImage thumbnail = 4;
+    if (has_thumbnail()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->thumbnail());
+    }
+
+    // optional .bgs.protocol.Provider provider = 5;
+    if (has_provider()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->provider());
+    }
+
+    // optional string description = 6;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->description());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void EmbedInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const EmbedInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const EmbedInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void EmbedInfo::MergeFrom(const EmbedInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_title()) {
+      set_title(from.title());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_original_url()) {
+      set_original_url(from.original_url());
+    }
+    if (from.has_thumbnail()) {
+      mutable_thumbnail()->::bgs::protocol::EmbedImage::MergeFrom(from.thumbnail());
+    }
+    if (from.has_provider()) {
+      mutable_provider()->::bgs::protocol::Provider::MergeFrom(from.provider());
+    }
+    if (from.has_description()) {
+      set_description(from.description());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void EmbedInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void EmbedInfo::CopyFrom(const EmbedInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EmbedInfo::IsInitialized() const {
+
+  return true;
+}
+
+void EmbedInfo::Swap(EmbedInfo* other) {
+  if (other != this) {
+    std::swap(title_, other->title_);
+    std::swap(type_, other->type_);
+    std::swap(original_url_, other->original_url_);
+    std::swap(thumbnail_, other->thumbnail_);
+    std::swap(provider_, other->provider_);
+    std::swap(description_, other->description_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata EmbedInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = EmbedInfo_descriptor_;
+  metadata.reflection = EmbedInfo_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/embed_types.pb.h b/src/server/proto/Client/embed_types.pb.h
new file mode 100644
index 00000000000..7b32b2c8d7a
--- /dev/null
+++ b/src/server/proto/Client/embed_types.pb.h
@@ -0,0 +1,1004 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: embed_types.proto
+
+#ifndef PROTOBUF_embed_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_embed_5ftypes_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_embed_5ftypes_2eproto();
+void protobuf_AssignDesc_embed_5ftypes_2eproto();
+void protobuf_ShutdownFile_embed_5ftypes_2eproto();
+
+class EmbedImage;
+class Provider;
+class EmbedInfo;
+
+// ===================================================================
+
+class TC_PROTO_API EmbedImage : public ::google::protobuf::Message {
+ public:
+  EmbedImage();
+  virtual ~EmbedImage();
+
+  EmbedImage(const EmbedImage& from);
+
+  inline EmbedImage& operator=(const EmbedImage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EmbedImage& default_instance();
+
+  void Swap(EmbedImage* other);
+
+  // implements Message ----------------------------------------------
+
+  EmbedImage* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const EmbedImage& from);
+  void MergeFrom(const EmbedImage& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string url = 1;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 1;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // optional uint32 width = 2;
+  inline bool has_width() const;
+  inline void clear_width();
+  static const int kWidthFieldNumber = 2;
+  inline ::google::protobuf::uint32 width() const;
+  inline void set_width(::google::protobuf::uint32 value);
+
+  // optional uint32 height = 3;
+  inline bool has_height() const;
+  inline void clear_height();
+  static const int kHeightFieldNumber = 3;
+  inline ::google::protobuf::uint32 height() const;
+  inline void set_height(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.EmbedImage)
+ private:
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_width();
+  inline void clear_has_width();
+  inline void set_has_height();
+  inline void clear_has_height();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* url_;
+  ::google::protobuf::uint32 width_;
+  ::google::protobuf::uint32 height_;
+  friend void TC_PROTO_API protobuf_AddDesc_embed_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_embed_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_embed_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static EmbedImage* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API Provider : public ::google::protobuf::Message {
+ public:
+  Provider();
+  virtual ~Provider();
+
+  Provider(const Provider& from);
+
+  inline Provider& operator=(const Provider& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Provider& default_instance();
+
+  void Swap(Provider* other);
+
+  // implements Message ----------------------------------------------
+
+  Provider* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Provider& from);
+  void MergeFrom(const Provider& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.Provider)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  friend void TC_PROTO_API protobuf_AddDesc_embed_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_embed_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_embed_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Provider* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API EmbedInfo : public ::google::protobuf::Message {
+ public:
+  EmbedInfo();
+  virtual ~EmbedInfo();
+
+  EmbedInfo(const EmbedInfo& from);
+
+  inline EmbedInfo& operator=(const EmbedInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EmbedInfo& default_instance();
+
+  void Swap(EmbedInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  EmbedInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const EmbedInfo& from);
+  void MergeFrom(const EmbedInfo& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string title = 1;
+  inline bool has_title() const;
+  inline void clear_title();
+  static const int kTitleFieldNumber = 1;
+  inline const ::std::string& title() const;
+  inline void set_title(const ::std::string& value);
+  inline void set_title(const char* value);
+  inline void set_title(const char* value, size_t size);
+  inline ::std::string* mutable_title();
+  inline ::std::string* release_title();
+  inline void set_allocated_title(::std::string* title);
+
+  // optional string type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline const ::std::string& type() const;
+  inline void set_type(const ::std::string& value);
+  inline void set_type(const char* value);
+  inline void set_type(const char* value, size_t size);
+  inline ::std::string* mutable_type();
+  inline ::std::string* release_type();
+  inline void set_allocated_type(::std::string* type);
+
+  // optional string original_url = 3;
+  inline bool has_original_url() const;
+  inline void clear_original_url();
+  static const int kOriginalUrlFieldNumber = 3;
+  inline const ::std::string& original_url() const;
+  inline void set_original_url(const ::std::string& value);
+  inline void set_original_url(const char* value);
+  inline void set_original_url(const char* value, size_t size);
+  inline ::std::string* mutable_original_url();
+  inline ::std::string* release_original_url();
+  inline void set_allocated_original_url(::std::string* original_url);
+
+  // optional .bgs.protocol.EmbedImage thumbnail = 4;
+  inline bool has_thumbnail() const;
+  inline void clear_thumbnail();
+  static const int kThumbnailFieldNumber = 4;
+  inline const ::bgs::protocol::EmbedImage& thumbnail() const;
+  inline ::bgs::protocol::EmbedImage* mutable_thumbnail();
+  inline ::bgs::protocol::EmbedImage* release_thumbnail();
+  inline void set_allocated_thumbnail(::bgs::protocol::EmbedImage* thumbnail);
+
+  // optional .bgs.protocol.Provider provider = 5;
+  inline bool has_provider() const;
+  inline void clear_provider();
+  static const int kProviderFieldNumber = 5;
+  inline const ::bgs::protocol::Provider& provider() const;
+  inline ::bgs::protocol::Provider* mutable_provider();
+  inline ::bgs::protocol::Provider* release_provider();
+  inline void set_allocated_provider(::bgs::protocol::Provider* provider);
+
+  // optional string description = 6;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 6;
+  inline const ::std::string& description() const;
+  inline void set_description(const ::std::string& value);
+  inline void set_description(const char* value);
+  inline void set_description(const char* value, size_t size);
+  inline ::std::string* mutable_description();
+  inline ::std::string* release_description();
+  inline void set_allocated_description(::std::string* description);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.EmbedInfo)
+ private:
+  inline void set_has_title();
+  inline void clear_has_title();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_original_url();
+  inline void clear_has_original_url();
+  inline void set_has_thumbnail();
+  inline void clear_has_thumbnail();
+  inline void set_has_provider();
+  inline void clear_has_provider();
+  inline void set_has_description();
+  inline void clear_has_description();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* title_;
+  ::std::string* type_;
+  ::std::string* original_url_;
+  ::bgs::protocol::EmbedImage* thumbnail_;
+  ::bgs::protocol::Provider* provider_;
+  ::std::string* description_;
+  friend void TC_PROTO_API protobuf_AddDesc_embed_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_embed_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_embed_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static EmbedInfo* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// EmbedImage
+
+// optional string url = 1;
+inline bool EmbedImage::has_url() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EmbedImage::set_has_url() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EmbedImage::clear_has_url() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EmbedImage::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& EmbedImage::url() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EmbedImage.url)
+  return *url_;
+}
+inline void EmbedImage::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.EmbedImage.url)
+}
+inline void EmbedImage::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.EmbedImage.url)
+}
+inline void EmbedImage::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.EmbedImage.url)
+}
+inline ::std::string* EmbedImage::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.EmbedImage.url)
+  return url_;
+}
+inline ::std::string* EmbedImage::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void EmbedImage::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.EmbedImage.url)
+}
+
+// optional uint32 width = 2;
+inline bool EmbedImage::has_width() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EmbedImage::set_has_width() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EmbedImage::clear_has_width() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EmbedImage::clear_width() {
+  width_ = 0u;
+  clear_has_width();
+}
+inline ::google::protobuf::uint32 EmbedImage::width() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EmbedImage.width)
+  return width_;
+}
+inline void EmbedImage::set_width(::google::protobuf::uint32 value) {
+  set_has_width();
+  width_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.EmbedImage.width)
+}
+
+// optional uint32 height = 3;
+inline bool EmbedImage::has_height() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void EmbedImage::set_has_height() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void EmbedImage::clear_has_height() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void EmbedImage::clear_height() {
+  height_ = 0u;
+  clear_has_height();
+}
+inline ::google::protobuf::uint32 EmbedImage::height() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EmbedImage.height)
+  return height_;
+}
+inline void EmbedImage::set_height(::google::protobuf::uint32 value) {
+  set_has_height();
+  height_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.EmbedImage.height)
+}
+
+// -------------------------------------------------------------------
+
+// Provider
+
+// optional string name = 1;
+inline bool Provider::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Provider::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Provider::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Provider::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& Provider::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Provider.name)
+  return *name_;
+}
+inline void Provider::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Provider.name)
+}
+inline void Provider::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Provider.name)
+}
+inline void Provider::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Provider.name)
+}
+inline ::std::string* Provider::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Provider.name)
+  return name_;
+}
+inline ::std::string* Provider::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Provider::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Provider.name)
+}
+
+// -------------------------------------------------------------------
+
+// EmbedInfo
+
+// optional string title = 1;
+inline bool EmbedInfo::has_title() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EmbedInfo::set_has_title() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EmbedInfo::clear_has_title() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EmbedInfo::clear_title() {
+  if (title_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    title_->clear();
+  }
+  clear_has_title();
+}
+inline const ::std::string& EmbedInfo::title() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EmbedInfo.title)
+  return *title_;
+}
+inline void EmbedInfo::set_title(const ::std::string& value) {
+  set_has_title();
+  if (title_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    title_ = new ::std::string;
+  }
+  title_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.EmbedInfo.title)
+}
+inline void EmbedInfo::set_title(const char* value) {
+  set_has_title();
+  if (title_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    title_ = new ::std::string;
+  }
+  title_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.EmbedInfo.title)
+}
+inline void EmbedInfo::set_title(const char* value, size_t size) {
+  set_has_title();
+  if (title_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    title_ = new ::std::string;
+  }
+  title_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.EmbedInfo.title)
+}
+inline ::std::string* EmbedInfo::mutable_title() {
+  set_has_title();
+  if (title_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    title_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.EmbedInfo.title)
+  return title_;
+}
+inline ::std::string* EmbedInfo::release_title() {
+  clear_has_title();
+  if (title_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = title_;
+    title_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void EmbedInfo::set_allocated_title(::std::string* title) {
+  if (title_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete title_;
+  }
+  if (title) {
+    set_has_title();
+    title_ = title;
+  } else {
+    clear_has_title();
+    title_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.EmbedInfo.title)
+}
+
+// optional string type = 2;
+inline bool EmbedInfo::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EmbedInfo::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EmbedInfo::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EmbedInfo::clear_type() {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_->clear();
+  }
+  clear_has_type();
+}
+inline const ::std::string& EmbedInfo::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EmbedInfo.type)
+  return *type_;
+}
+inline void EmbedInfo::set_type(const ::std::string& value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.EmbedInfo.type)
+}
+inline void EmbedInfo::set_type(const char* value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.EmbedInfo.type)
+}
+inline void EmbedInfo::set_type(const char* value, size_t size) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.EmbedInfo.type)
+}
+inline ::std::string* EmbedInfo::mutable_type() {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.EmbedInfo.type)
+  return type_;
+}
+inline ::std::string* EmbedInfo::release_type() {
+  clear_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = type_;
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void EmbedInfo::set_allocated_type(::std::string* type) {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete type_;
+  }
+  if (type) {
+    set_has_type();
+    type_ = type;
+  } else {
+    clear_has_type();
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.EmbedInfo.type)
+}
+
+// optional string original_url = 3;
+inline bool EmbedInfo::has_original_url() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void EmbedInfo::set_has_original_url() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void EmbedInfo::clear_has_original_url() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void EmbedInfo::clear_original_url() {
+  if (original_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    original_url_->clear();
+  }
+  clear_has_original_url();
+}
+inline const ::std::string& EmbedInfo::original_url() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EmbedInfo.original_url)
+  return *original_url_;
+}
+inline void EmbedInfo::set_original_url(const ::std::string& value) {
+  set_has_original_url();
+  if (original_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    original_url_ = new ::std::string;
+  }
+  original_url_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.EmbedInfo.original_url)
+}
+inline void EmbedInfo::set_original_url(const char* value) {
+  set_has_original_url();
+  if (original_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    original_url_ = new ::std::string;
+  }
+  original_url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.EmbedInfo.original_url)
+}
+inline void EmbedInfo::set_original_url(const char* value, size_t size) {
+  set_has_original_url();
+  if (original_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    original_url_ = new ::std::string;
+  }
+  original_url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.EmbedInfo.original_url)
+}
+inline ::std::string* EmbedInfo::mutable_original_url() {
+  set_has_original_url();
+  if (original_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    original_url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.EmbedInfo.original_url)
+  return original_url_;
+}
+inline ::std::string* EmbedInfo::release_original_url() {
+  clear_has_original_url();
+  if (original_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = original_url_;
+    original_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void EmbedInfo::set_allocated_original_url(::std::string* original_url) {
+  if (original_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete original_url_;
+  }
+  if (original_url) {
+    set_has_original_url();
+    original_url_ = original_url;
+  } else {
+    clear_has_original_url();
+    original_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.EmbedInfo.original_url)
+}
+
+// optional .bgs.protocol.EmbedImage thumbnail = 4;
+inline bool EmbedInfo::has_thumbnail() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void EmbedInfo::set_has_thumbnail() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void EmbedInfo::clear_has_thumbnail() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void EmbedInfo::clear_thumbnail() {
+  if (thumbnail_ != NULL) thumbnail_->::bgs::protocol::EmbedImage::Clear();
+  clear_has_thumbnail();
+}
+inline const ::bgs::protocol::EmbedImage& EmbedInfo::thumbnail() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EmbedInfo.thumbnail)
+  return thumbnail_ != NULL ? *thumbnail_ : *default_instance_->thumbnail_;
+}
+inline ::bgs::protocol::EmbedImage* EmbedInfo::mutable_thumbnail() {
+  set_has_thumbnail();
+  if (thumbnail_ == NULL) thumbnail_ = new ::bgs::protocol::EmbedImage;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.EmbedInfo.thumbnail)
+  return thumbnail_;
+}
+inline ::bgs::protocol::EmbedImage* EmbedInfo::release_thumbnail() {
+  clear_has_thumbnail();
+  ::bgs::protocol::EmbedImage* temp = thumbnail_;
+  thumbnail_ = NULL;
+  return temp;
+}
+inline void EmbedInfo::set_allocated_thumbnail(::bgs::protocol::EmbedImage* thumbnail) {
+  delete thumbnail_;
+  thumbnail_ = thumbnail;
+  if (thumbnail) {
+    set_has_thumbnail();
+  } else {
+    clear_has_thumbnail();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.EmbedInfo.thumbnail)
+}
+
+// optional .bgs.protocol.Provider provider = 5;
+inline bool EmbedInfo::has_provider() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void EmbedInfo::set_has_provider() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void EmbedInfo::clear_has_provider() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void EmbedInfo::clear_provider() {
+  if (provider_ != NULL) provider_->::bgs::protocol::Provider::Clear();
+  clear_has_provider();
+}
+inline const ::bgs::protocol::Provider& EmbedInfo::provider() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EmbedInfo.provider)
+  return provider_ != NULL ? *provider_ : *default_instance_->provider_;
+}
+inline ::bgs::protocol::Provider* EmbedInfo::mutable_provider() {
+  set_has_provider();
+  if (provider_ == NULL) provider_ = new ::bgs::protocol::Provider;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.EmbedInfo.provider)
+  return provider_;
+}
+inline ::bgs::protocol::Provider* EmbedInfo::release_provider() {
+  clear_has_provider();
+  ::bgs::protocol::Provider* temp = provider_;
+  provider_ = NULL;
+  return temp;
+}
+inline void EmbedInfo::set_allocated_provider(::bgs::protocol::Provider* provider) {
+  delete provider_;
+  provider_ = provider;
+  if (provider) {
+    set_has_provider();
+  } else {
+    clear_has_provider();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.EmbedInfo.provider)
+}
+
+// optional string description = 6;
+inline bool EmbedInfo::has_description() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void EmbedInfo::set_has_description() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void EmbedInfo::clear_has_description() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void EmbedInfo::clear_description() {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_->clear();
+  }
+  clear_has_description();
+}
+inline const ::std::string& EmbedInfo::description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EmbedInfo.description)
+  return *description_;
+}
+inline void EmbedInfo::set_description(const ::std::string& value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.EmbedInfo.description)
+}
+inline void EmbedInfo::set_description(const char* value) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.EmbedInfo.description)
+}
+inline void EmbedInfo::set_description(const char* value, size_t size) {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.EmbedInfo.description)
+}
+inline ::std::string* EmbedInfo::mutable_description() {
+  set_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    description_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.EmbedInfo.description)
+  return description_;
+}
+inline ::std::string* EmbedInfo::release_description() {
+  clear_has_description();
+  if (description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = description_;
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void EmbedInfo::set_allocated_description(::std::string* description) {
+  if (description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete description_;
+  }
+  if (description) {
+    set_has_description();
+    description_ = description;
+  } else {
+    clear_has_description();
+    description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.EmbedInfo.description)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_embed_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/entity_types.pb.cc b/src/server/proto/Client/entity_types.pb.cc
index ca9b0c88bc4..a04bd5d93c6 100644
--- a/src/server/proto/Client/entity_types.pb.cc
+++ b/src/server/proto/Client/entity_types.pb.cc
@@ -29,9 +29,6 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* Identity_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   Identity_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AccountInfo_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AccountInfo_reflection_ = NULL;
 
 }  // namespace
 
@@ -74,26 +71,6 @@ void protobuf_AssignDesc_entity_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(Identity));
-  AccountInfo_descriptor_ = file->message_type(2);
-  static const int AccountInfo_offsets_[6] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, account_paid_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, country_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, battle_tag_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, manual_review_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, identity_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, account_muted_),
-  };
-  AccountInfo_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      AccountInfo_descriptor_,
-      AccountInfo::default_instance_,
-      AccountInfo_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AccountInfo));
 }
 
 namespace {
@@ -110,8 +87,6 @@ void protobuf_RegisterTypes(const ::std::string&) {
     EntityId_descriptor_, &EntityId::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     Identity_descriptor_, &Identity::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AccountInfo_descriptor_, &AccountInfo::default_instance());
 }
 
 }  // namespace
@@ -121,8 +96,6 @@ void protobuf_ShutdownFile_entity_5ftypes_2eproto() {
   delete EntityId_reflection_;
   delete Identity::default_instance_;
   delete Identity_reflection_;
-  delete AccountInfo::default_instance_;
-  delete AccountInfo_reflection_;
 }
 
 void protobuf_AddDesc_entity_5ftypes_2eproto() {
@@ -132,27 +105,23 @@ void protobuf_AddDesc_entity_5ftypes_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
   ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2fmessage_5foptions_2eproto();
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\022entity_types.proto\022\014bgs.protocol\032%glob"
-    "al_extensions/field_options.proto\"1\n\010Ent"
-    "ityId\022\022\n\004high\030\001 \002(\006B\004\200\265\030\002\022\021\n\003low\030\002 \002(\006B\004"
-    "\200\265\030\002\"g\n\010Identity\022*\n\naccount_id\030\001 \001(\0132\026.b"
-    "gs.protocol.EntityId\022/\n\017game_account_id\030"
-    "\002 \001(\0132\026.bgs.protocol.EntityId\"\273\001\n\013Accoun"
-    "tInfo\022\033\n\014account_paid\030\001 \001(\010:\005false\022\025\n\nco"
-    "untry_id\030\002 \001(\007:\0010\022\022\n\nbattle_tag\030\003 \001(\t\022\034\n"
-    "\rmanual_review\030\004 \001(\010:\005false\022(\n\010identity\030"
-    "\005 \001(\0132\026.bgs.protocol.Identity\022\034\n\raccount"
-    "_muted\030\006 \001(\010:\005falseB\036\n\rbnet.protocolB\013En"
-    "tityProtoH\001", 451);
+    "al_extensions/field_options.proto\032\'globa"
+    "l_extensions/message_options.proto\"=\n\010En"
+    "tityId\022\024\n\004high\030\001 \002(\006B\006\202\371+\002\010\002\022\023\n\003low\030\002 \002("
+    "\006B\006\202\371+\002\010\002:\006\202\371+\002\010\001\"\177\n\010Identity\0226\n\naccount"
+    "_id\030\001 \001(\0132\026.bgs.protocol.EntityIdB\n\212\371+\006:"
+    "\004\010\001\020\001\022;\n\017game_account_id\030\002 \001(\0132\026.bgs.pro"
+    "tocol.EntityIdB\n\212\371+\006:\004\010\001\020\002B\036\n\rbnet.proto"
+    "colB\013EntityProtoH\001", 338);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "entity_types.proto", &protobuf_RegisterTypes);
   EntityId::default_instance_ = new EntityId();
   Identity::default_instance_ = new Identity();
-  AccountInfo::default_instance_ = new AccountInfo();
   EntityId::default_instance_->InitAsDefaultInstance();
   Identity::default_instance_->InitAsDefaultInstance();
-  AccountInfo::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_entity_5ftypes_2eproto);
 }
 
@@ -713,457 +682,6 @@ void Identity::Swap(Identity* other) {
 }
 
 
-// ===================================================================
-
-#ifndef _MSC_VER
-const int AccountInfo::kAccountPaidFieldNumber;
-const int AccountInfo::kCountryIdFieldNumber;
-const int AccountInfo::kBattleTagFieldNumber;
-const int AccountInfo::kManualReviewFieldNumber;
-const int AccountInfo::kIdentityFieldNumber;
-const int AccountInfo::kAccountMutedFieldNumber;
-#endif  // !_MSC_VER
-
-AccountInfo::AccountInfo()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.AccountInfo)
-}
-
-void AccountInfo::InitAsDefaultInstance() {
-  identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
-}
-
-AccountInfo::AccountInfo(const AccountInfo& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.AccountInfo)
-}
-
-void AccountInfo::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  account_paid_ = false;
-  country_id_ = 0u;
-  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  manual_review_ = false;
-  identity_ = NULL;
-  account_muted_ = false;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-AccountInfo::~AccountInfo() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.AccountInfo)
-  SharedDtor();
-}
-
-void AccountInfo::SharedDtor() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (this != default_instance_) {
-    delete identity_;
-  }
-}
-
-void AccountInfo::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* AccountInfo::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return AccountInfo_descriptor_;
-}
-
-const AccountInfo& AccountInfo::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_entity_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-AccountInfo* AccountInfo::default_instance_ = NULL;
-
-AccountInfo* AccountInfo::New() const {
-  return new AccountInfo;
-}
-
-void AccountInfo::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<AccountInfo*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 63) {
-    ZR_(country_id_, account_muted_);
-    if (has_battle_tag()) {
-      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        battle_tag_->clear();
-      }
-    }
-    if (has_identity()) {
-      if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
-    }
-  }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool AccountInfo::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.AccountInfo)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional bool account_paid = 1 [default = false];
-      case 1: {
-        if (tag == 8) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &account_paid_)));
-          set_has_account_paid();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(21)) goto parse_country_id;
-        break;
-      }
-
-      // optional fixed32 country_id = 2 [default = 0];
-      case 2: {
-        if (tag == 21) {
-         parse_country_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &country_id_)));
-          set_has_country_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_battle_tag;
-        break;
-      }
-
-      // optional string battle_tag = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_battle_tag:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_battle_tag()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->battle_tag().data(), this->battle_tag().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "battle_tag");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(32)) goto parse_manual_review;
-        break;
-      }
-
-      // optional bool manual_review = 4 [default = false];
-      case 4: {
-        if (tag == 32) {
-         parse_manual_review:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &manual_review_)));
-          set_has_manual_review();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_identity;
-        break;
-      }
-
-      // optional .bgs.protocol.Identity identity = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_identity:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_identity()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(48)) goto parse_account_muted;
-        break;
-      }
-
-      // optional bool account_muted = 6 [default = false];
-      case 6: {
-        if (tag == 48) {
-         parse_account_muted:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &account_muted_)));
-          set_has_account_muted();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.AccountInfo)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.AccountInfo)
-  return false;
-#undef DO_
-}
-
-void AccountInfo::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.AccountInfo)
-  // optional bool account_paid = 1 [default = false];
-  if (has_account_paid()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->account_paid(), output);
-  }
-
-  // optional fixed32 country_id = 2 [default = 0];
-  if (has_country_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->country_id(), output);
-  }
-
-  // optional string battle_tag = 3;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      3, this->battle_tag(), output);
-  }
-
-  // optional bool manual_review = 4 [default = false];
-  if (has_manual_review()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->manual_review(), output);
-  }
-
-  // optional .bgs.protocol.Identity identity = 5;
-  if (has_identity()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, this->identity(), output);
-  }
-
-  // optional bool account_muted = 6 [default = false];
-  if (has_account_muted()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->account_muted(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.AccountInfo)
-}
-
-::google::protobuf::uint8* AccountInfo::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.AccountInfo)
-  // optional bool account_paid = 1 [default = false];
-  if (has_account_paid()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->account_paid(), target);
-  }
-
-  // optional fixed32 country_id = 2 [default = 0];
-  if (has_country_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->country_id(), target);
-  }
-
-  // optional string battle_tag = 3;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        3, this->battle_tag(), target);
-  }
-
-  // optional bool manual_review = 4 [default = false];
-  if (has_manual_review()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->manual_review(), target);
-  }
-
-  // optional .bgs.protocol.Identity identity = 5;
-  if (has_identity()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->identity(), target);
-  }
-
-  // optional bool account_muted = 6 [default = false];
-  if (has_account_muted()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->account_muted(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.AccountInfo)
-  return target;
-}
-
-int AccountInfo::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional bool account_paid = 1 [default = false];
-    if (has_account_paid()) {
-      total_size += 1 + 1;
-    }
-
-    // optional fixed32 country_id = 2 [default = 0];
-    if (has_country_id()) {
-      total_size += 1 + 4;
-    }
-
-    // optional string battle_tag = 3;
-    if (has_battle_tag()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->battle_tag());
-    }
-
-    // optional bool manual_review = 4 [default = false];
-    if (has_manual_review()) {
-      total_size += 1 + 1;
-    }
-
-    // optional .bgs.protocol.Identity identity = 5;
-    if (has_identity()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->identity());
-    }
-
-    // optional bool account_muted = 6 [default = false];
-    if (has_account_muted()) {
-      total_size += 1 + 1;
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void AccountInfo::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const AccountInfo* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AccountInfo*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void AccountInfo::MergeFrom(const AccountInfo& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_account_paid()) {
-      set_account_paid(from.account_paid());
-    }
-    if (from.has_country_id()) {
-      set_country_id(from.country_id());
-    }
-    if (from.has_battle_tag()) {
-      set_battle_tag(from.battle_tag());
-    }
-    if (from.has_manual_review()) {
-      set_manual_review(from.manual_review());
-    }
-    if (from.has_identity()) {
-      mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity());
-    }
-    if (from.has_account_muted()) {
-      set_account_muted(from.account_muted());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void AccountInfo::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void AccountInfo::CopyFrom(const AccountInfo& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AccountInfo::IsInitialized() const {
-
-  if (has_identity()) {
-    if (!this->identity().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void AccountInfo::Swap(AccountInfo* other) {
-  if (other != this) {
-    std::swap(account_paid_, other->account_paid_);
-    std::swap(country_id_, other->country_id_);
-    std::swap(battle_tag_, other->battle_tag_);
-    std::swap(manual_review_, other->manual_review_);
-    std::swap(identity_, other->identity_);
-    std::swap(account_muted_, other->account_muted_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata AccountInfo::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AccountInfo_descriptor_;
-  metadata.reflection = AccountInfo_reflection_;
-  return metadata;
-}
-
-
 // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace protocol
diff --git a/src/server/proto/Client/entity_types.pb.h b/src/server/proto/Client/entity_types.pb.h
index 79872b06e40..4d0c829b78b 100644
--- a/src/server/proto/Client/entity_types.pb.h
+++ b/src/server/proto/Client/entity_types.pb.h
@@ -25,6 +25,7 @@
 #include <google/protobuf/extension_set.h>
 #include <google/protobuf/unknown_field_set.h>
 #include "global_extensions/field_options.pb.h"
+#include "global_extensions/message_options.pb.h"
 #include "Define.h" // for TC_PROTO_API
 // @@protoc_insertion_point(includes)
 
@@ -38,7 +39,6 @@ void protobuf_ShutdownFile_entity_5ftypes_2eproto();
 
 class EntityId;
 class Identity;
-class AccountInfo;
 
 // ===================================================================
 
@@ -222,142 +222,6 @@ class TC_PROTO_API Identity : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static Identity* default_instance_;
 };
-// -------------------------------------------------------------------
-
-class TC_PROTO_API AccountInfo : public ::google::protobuf::Message {
- public:
-  AccountInfo();
-  virtual ~AccountInfo();
-
-  AccountInfo(const AccountInfo& from);
-
-  inline AccountInfo& operator=(const AccountInfo& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const AccountInfo& default_instance();
-
-  void Swap(AccountInfo* other);
-
-  // implements Message ----------------------------------------------
-
-  AccountInfo* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AccountInfo& from);
-  void MergeFrom(const AccountInfo& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional bool account_paid = 1 [default = false];
-  inline bool has_account_paid() const;
-  inline void clear_account_paid();
-  static const int kAccountPaidFieldNumber = 1;
-  inline bool account_paid() const;
-  inline void set_account_paid(bool value);
-
-  // optional fixed32 country_id = 2 [default = 0];
-  inline bool has_country_id() const;
-  inline void clear_country_id();
-  static const int kCountryIdFieldNumber = 2;
-  inline ::google::protobuf::uint32 country_id() const;
-  inline void set_country_id(::google::protobuf::uint32 value);
-
-  // optional string battle_tag = 3;
-  inline bool has_battle_tag() const;
-  inline void clear_battle_tag();
-  static const int kBattleTagFieldNumber = 3;
-  inline const ::std::string& battle_tag() const;
-  inline void set_battle_tag(const ::std::string& value);
-  inline void set_battle_tag(const char* value);
-  inline void set_battle_tag(const char* value, size_t size);
-  inline ::std::string* mutable_battle_tag();
-  inline ::std::string* release_battle_tag();
-  inline void set_allocated_battle_tag(::std::string* battle_tag);
-
-  // optional bool manual_review = 4 [default = false];
-  inline bool has_manual_review() const;
-  inline void clear_manual_review();
-  static const int kManualReviewFieldNumber = 4;
-  inline bool manual_review() const;
-  inline void set_manual_review(bool value);
-
-  // optional .bgs.protocol.Identity identity = 5;
-  inline bool has_identity() const;
-  inline void clear_identity();
-  static const int kIdentityFieldNumber = 5;
-  inline const ::bgs::protocol::Identity& identity() const;
-  inline ::bgs::protocol::Identity* mutable_identity();
-  inline ::bgs::protocol::Identity* release_identity();
-  inline void set_allocated_identity(::bgs::protocol::Identity* identity);
-
-  // optional bool account_muted = 6 [default = false];
-  inline bool has_account_muted() const;
-  inline void clear_account_muted();
-  static const int kAccountMutedFieldNumber = 6;
-  inline bool account_muted() const;
-  inline void set_account_muted(bool value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.AccountInfo)
- private:
-  inline void set_has_account_paid();
-  inline void clear_has_account_paid();
-  inline void set_has_country_id();
-  inline void clear_has_country_id();
-  inline void set_has_battle_tag();
-  inline void clear_has_battle_tag();
-  inline void set_has_manual_review();
-  inline void clear_has_manual_review();
-  inline void set_has_identity();
-  inline void clear_has_identity();
-  inline void set_has_account_muted();
-  inline void clear_has_account_muted();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::std::string* battle_tag_;
-  ::google::protobuf::uint32 country_id_;
-  bool account_paid_;
-  bool manual_review_;
-  bool account_muted_;
-  ::bgs::protocol::Identity* identity_;
-  friend void TC_PROTO_API protobuf_AddDesc_entity_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_entity_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_entity_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static AccountInfo* default_instance_;
-};
 // ===================================================================
 
 
@@ -502,223 +366,6 @@ inline void Identity::set_allocated_game_account_id(::bgs::protocol::EntityId* g
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Identity.game_account_id)
 }
 
-// -------------------------------------------------------------------
-
-// AccountInfo
-
-// optional bool account_paid = 1 [default = false];
-inline bool AccountInfo::has_account_paid() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void AccountInfo::set_has_account_paid() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void AccountInfo::clear_has_account_paid() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void AccountInfo::clear_account_paid() {
-  account_paid_ = false;
-  clear_has_account_paid();
-}
-inline bool AccountInfo::account_paid() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.account_paid)
-  return account_paid_;
-}
-inline void AccountInfo::set_account_paid(bool value) {
-  set_has_account_paid();
-  account_paid_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.account_paid)
-}
-
-// optional fixed32 country_id = 2 [default = 0];
-inline bool AccountInfo::has_country_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void AccountInfo::set_has_country_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void AccountInfo::clear_has_country_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void AccountInfo::clear_country_id() {
-  country_id_ = 0u;
-  clear_has_country_id();
-}
-inline ::google::protobuf::uint32 AccountInfo::country_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.country_id)
-  return country_id_;
-}
-inline void AccountInfo::set_country_id(::google::protobuf::uint32 value) {
-  set_has_country_id();
-  country_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.country_id)
-}
-
-// optional string battle_tag = 3;
-inline bool AccountInfo::has_battle_tag() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void AccountInfo::set_has_battle_tag() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void AccountInfo::clear_has_battle_tag() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void AccountInfo::clear_battle_tag() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_->clear();
-  }
-  clear_has_battle_tag();
-}
-inline const ::std::string& AccountInfo::battle_tag() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.battle_tag)
-  return *battle_tag_;
-}
-inline void AccountInfo::set_battle_tag(const ::std::string& value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.battle_tag)
-}
-inline void AccountInfo::set_battle_tag(const char* value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.AccountInfo.battle_tag)
-}
-inline void AccountInfo::set_battle_tag(const char* value, size_t size) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.AccountInfo.battle_tag)
-}
-inline ::std::string* AccountInfo::mutable_battle_tag() {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.AccountInfo.battle_tag)
-  return battle_tag_;
-}
-inline ::std::string* AccountInfo::release_battle_tag() {
-  clear_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = battle_tag_;
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void AccountInfo::set_allocated_battle_tag(::std::string* battle_tag) {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (battle_tag) {
-    set_has_battle_tag();
-    battle_tag_ = battle_tag;
-  } else {
-    clear_has_battle_tag();
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.AccountInfo.battle_tag)
-}
-
-// optional bool manual_review = 4 [default = false];
-inline bool AccountInfo::has_manual_review() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void AccountInfo::set_has_manual_review() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void AccountInfo::clear_has_manual_review() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void AccountInfo::clear_manual_review() {
-  manual_review_ = false;
-  clear_has_manual_review();
-}
-inline bool AccountInfo::manual_review() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.manual_review)
-  return manual_review_;
-}
-inline void AccountInfo::set_manual_review(bool value) {
-  set_has_manual_review();
-  manual_review_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.manual_review)
-}
-
-// optional .bgs.protocol.Identity identity = 5;
-inline bool AccountInfo::has_identity() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void AccountInfo::set_has_identity() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void AccountInfo::clear_has_identity() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void AccountInfo::clear_identity() {
-  if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
-  clear_has_identity();
-}
-inline const ::bgs::protocol::Identity& AccountInfo::identity() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.identity)
-  return identity_ != NULL ? *identity_ : *default_instance_->identity_;
-}
-inline ::bgs::protocol::Identity* AccountInfo::mutable_identity() {
-  set_has_identity();
-  if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.AccountInfo.identity)
-  return identity_;
-}
-inline ::bgs::protocol::Identity* AccountInfo::release_identity() {
-  clear_has_identity();
-  ::bgs::protocol::Identity* temp = identity_;
-  identity_ = NULL;
-  return temp;
-}
-inline void AccountInfo::set_allocated_identity(::bgs::protocol::Identity* identity) {
-  delete identity_;
-  identity_ = identity;
-  if (identity) {
-    set_has_identity();
-  } else {
-    clear_has_identity();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.AccountInfo.identity)
-}
-
-// optional bool account_muted = 6 [default = false];
-inline bool AccountInfo::has_account_muted() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
-}
-inline void AccountInfo::set_has_account_muted() {
-  _has_bits_[0] |= 0x00000020u;
-}
-inline void AccountInfo::clear_has_account_muted() {
-  _has_bits_[0] &= ~0x00000020u;
-}
-inline void AccountInfo::clear_account_muted() {
-  account_muted_ = false;
-  clear_has_account_muted();
-}
-inline bool AccountInfo::account_muted() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.account_muted)
-  return account_muted_;
-}
-inline void AccountInfo::set_account_muted(bool value) {
-  set_has_account_muted();
-  account_muted_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.account_muted)
-}
-
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/src/server/proto/Client/ets_types.pb.cc b/src/server/proto/Client/ets_types.pb.cc
new file mode 100644
index 00000000000..e050d1bd594
--- /dev/null
+++ b/src/server/proto/Client/ets_types.pb.cc
@@ -0,0 +1,381 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ets_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "ets_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* TimeSeriesId_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  TimeSeriesId_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_ets_5ftypes_2eproto() {
+  protobuf_AddDesc_ets_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "ets_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  TimeSeriesId_descriptor_ = file->message_type(0);
+  static const int TimeSeriesId_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TimeSeriesId, epoch_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TimeSeriesId, position_),
+  };
+  TimeSeriesId_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      TimeSeriesId_descriptor_,
+      TimeSeriesId::default_instance_,
+      TimeSeriesId_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TimeSeriesId, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TimeSeriesId, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(TimeSeriesId));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_ets_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    TimeSeriesId_descriptor_, &TimeSeriesId::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_ets_5ftypes_2eproto() {
+  delete TimeSeriesId::default_instance_;
+  delete TimeSeriesId_reflection_;
+}
+
+void protobuf_AddDesc_ets_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\017ets_types.proto\022\014bgs.protocol\"/\n\014TimeS"
+    "eriesId\022\r\n\005epoch\030\001 \001(\004\022\020\n\010position\030\002 \001(\004"
+    "B\002H\001", 84);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "ets_types.proto", &protobuf_RegisterTypes);
+  TimeSeriesId::default_instance_ = new TimeSeriesId();
+  TimeSeriesId::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_ets_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_ets_5ftypes_2eproto {
+  StaticDescriptorInitializer_ets_5ftypes_2eproto() {
+    protobuf_AddDesc_ets_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_ets_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int TimeSeriesId::kEpochFieldNumber;
+const int TimeSeriesId::kPositionFieldNumber;
+#endif  // !_MSC_VER
+
+TimeSeriesId::TimeSeriesId()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.TimeSeriesId)
+}
+
+void TimeSeriesId::InitAsDefaultInstance() {
+}
+
+TimeSeriesId::TimeSeriesId(const TimeSeriesId& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.TimeSeriesId)
+}
+
+void TimeSeriesId::SharedCtor() {
+  _cached_size_ = 0;
+  epoch_ = GOOGLE_ULONGLONG(0);
+  position_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+TimeSeriesId::~TimeSeriesId() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.TimeSeriesId)
+  SharedDtor();
+}
+
+void TimeSeriesId::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void TimeSeriesId::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* TimeSeriesId::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return TimeSeriesId_descriptor_;
+}
+
+const TimeSeriesId& TimeSeriesId::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_ets_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+TimeSeriesId* TimeSeriesId::default_instance_ = NULL;
+
+TimeSeriesId* TimeSeriesId::New() const {
+  return new TimeSeriesId;
+}
+
+void TimeSeriesId::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<TimeSeriesId*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(epoch_, position_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool TimeSeriesId::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.TimeSeriesId)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 epoch = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &epoch_)));
+          set_has_epoch();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_position;
+        break;
+      }
+
+      // optional uint64 position = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_position:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &position_)));
+          set_has_position();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.TimeSeriesId)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.TimeSeriesId)
+  return false;
+#undef DO_
+}
+
+void TimeSeriesId::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.TimeSeriesId)
+  // optional uint64 epoch = 1;
+  if (has_epoch()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->epoch(), output);
+  }
+
+  // optional uint64 position = 2;
+  if (has_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->position(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.TimeSeriesId)
+}
+
+::google::protobuf::uint8* TimeSeriesId::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.TimeSeriesId)
+  // optional uint64 epoch = 1;
+  if (has_epoch()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->epoch(), target);
+  }
+
+  // optional uint64 position = 2;
+  if (has_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->position(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.TimeSeriesId)
+  return target;
+}
+
+int TimeSeriesId::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 epoch = 1;
+    if (has_epoch()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->epoch());
+    }
+
+    // optional uint64 position = 2;
+    if (has_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->position());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void TimeSeriesId::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const TimeSeriesId* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const TimeSeriesId*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void TimeSeriesId::MergeFrom(const TimeSeriesId& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_epoch()) {
+      set_epoch(from.epoch());
+    }
+    if (from.has_position()) {
+      set_position(from.position());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void TimeSeriesId::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void TimeSeriesId::CopyFrom(const TimeSeriesId& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TimeSeriesId::IsInitialized() const {
+
+  return true;
+}
+
+void TimeSeriesId::Swap(TimeSeriesId* other) {
+  if (other != this) {
+    std::swap(epoch_, other->epoch_);
+    std::swap(position_, other->position_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata TimeSeriesId::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = TimeSeriesId_descriptor_;
+  metadata.reflection = TimeSeriesId_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/ets_types.pb.h b/src/server/proto/Client/ets_types.pb.h
new file mode 100644
index 00000000000..336ad4f4ea0
--- /dev/null
+++ b/src/server/proto/Client/ets_types.pb.h
@@ -0,0 +1,204 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ets_types.proto
+
+#ifndef PROTOBUF_ets_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_ets_5ftypes_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_ets_5ftypes_2eproto();
+void protobuf_AssignDesc_ets_5ftypes_2eproto();
+void protobuf_ShutdownFile_ets_5ftypes_2eproto();
+
+class TimeSeriesId;
+
+// ===================================================================
+
+class TC_PROTO_API TimeSeriesId : public ::google::protobuf::Message {
+ public:
+  TimeSeriesId();
+  virtual ~TimeSeriesId();
+
+  TimeSeriesId(const TimeSeriesId& from);
+
+  inline TimeSeriesId& operator=(const TimeSeriesId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TimeSeriesId& default_instance();
+
+  void Swap(TimeSeriesId* other);
+
+  // implements Message ----------------------------------------------
+
+  TimeSeriesId* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const TimeSeriesId& from);
+  void MergeFrom(const TimeSeriesId& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 epoch = 1;
+  inline bool has_epoch() const;
+  inline void clear_epoch();
+  static const int kEpochFieldNumber = 1;
+  inline ::google::protobuf::uint64 epoch() const;
+  inline void set_epoch(::google::protobuf::uint64 value);
+
+  // optional uint64 position = 2;
+  inline bool has_position() const;
+  inline void clear_position();
+  static const int kPositionFieldNumber = 2;
+  inline ::google::protobuf::uint64 position() const;
+  inline void set_position(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.TimeSeriesId)
+ private:
+  inline void set_has_epoch();
+  inline void clear_has_epoch();
+  inline void set_has_position();
+  inline void clear_has_position();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 epoch_;
+  ::google::protobuf::uint64 position_;
+  friend void TC_PROTO_API protobuf_AddDesc_ets_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_ets_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_ets_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static TimeSeriesId* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// TimeSeriesId
+
+// optional uint64 epoch = 1;
+inline bool TimeSeriesId::has_epoch() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void TimeSeriesId::set_has_epoch() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void TimeSeriesId::clear_has_epoch() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void TimeSeriesId::clear_epoch() {
+  epoch_ = GOOGLE_ULONGLONG(0);
+  clear_has_epoch();
+}
+inline ::google::protobuf::uint64 TimeSeriesId::epoch() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.TimeSeriesId.epoch)
+  return epoch_;
+}
+inline void TimeSeriesId::set_epoch(::google::protobuf::uint64 value) {
+  set_has_epoch();
+  epoch_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.TimeSeriesId.epoch)
+}
+
+// optional uint64 position = 2;
+inline bool TimeSeriesId::has_position() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void TimeSeriesId::set_has_position() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void TimeSeriesId::clear_has_position() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void TimeSeriesId::clear_position() {
+  position_ = GOOGLE_ULONGLONG(0);
+  clear_has_position();
+}
+inline ::google::protobuf::uint64 TimeSeriesId::position() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.TimeSeriesId.position)
+  return position_;
+}
+inline void TimeSeriesId::set_position(::google::protobuf::uint64 value) {
+  set_has_position();
+  position_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.TimeSeriesId.position)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_ets_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/event_view_types.pb.cc b/src/server/proto/Client/event_view_types.pb.cc
new file mode 100644
index 00000000000..e590db136b3
--- /dev/null
+++ b/src/server/proto/Client/event_view_types.pb.cc
@@ -0,0 +1,785 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: event_view_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "event_view_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* GetEventOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetEventOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ViewMarker_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ViewMarker_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* EventOrder_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_event_5fview_5ftypes_2eproto() {
+  protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "event_view_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  GetEventOptions_descriptor_ = file->message_type(0);
+  static const int GetEventOptions_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetEventOptions, fetch_from_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetEventOptions, fetch_until_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetEventOptions, max_events_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetEventOptions, order_),
+  };
+  GetEventOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetEventOptions_descriptor_,
+      GetEventOptions::default_instance_,
+      GetEventOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetEventOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetEventOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetEventOptions));
+  ViewMarker_descriptor_ = file->message_type(1);
+  static const int ViewMarker_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewMarker, last_read_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewMarker, last_message_time_),
+  };
+  ViewMarker_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ViewMarker_descriptor_,
+      ViewMarker::default_instance_,
+      ViewMarker_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewMarker, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewMarker, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ViewMarker));
+  EventOrder_descriptor_ = file->enum_type(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_event_5fview_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetEventOptions_descriptor_, &GetEventOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ViewMarker_descriptor_, &ViewMarker::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_event_5fview_5ftypes_2eproto() {
+  delete GetEventOptions::default_instance_;
+  delete GetEventOptions_reflection_;
+  delete ViewMarker::default_instance_;
+  delete ViewMarker_reflection_;
+}
+
+void protobuf_AddDesc_event_5fview_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\026event_view_types.proto\022\014bgs.protocol\"w"
+    "\n\017GetEventOptions\022\022\n\nfetch_from\030\001 \001(\004\022\023\n"
+    "\013fetch_until\030\002 \001(\004\022\022\n\nmax_events\030\003 \001(\r\022\'"
+    "\n\005order\030\004 \001(\0162\030.bgs.protocol.EventOrder\""
+    "\?\n\nViewMarker\022\026\n\016last_read_time\030\001 \001(\004\022\031\n"
+    "\021last_message_time\030\002 \001(\004*7\n\nEventOrder\022\024"
+    "\n\020EVENT_DESCENDING\020\000\022\023\n\017EVENT_ASCENDING\020"
+    "\001B\002H\001", 285);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "event_view_types.proto", &protobuf_RegisterTypes);
+  GetEventOptions::default_instance_ = new GetEventOptions();
+  ViewMarker::default_instance_ = new ViewMarker();
+  GetEventOptions::default_instance_->InitAsDefaultInstance();
+  ViewMarker::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_event_5fview_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_event_5fview_5ftypes_2eproto {
+  StaticDescriptorInitializer_event_5fview_5ftypes_2eproto() {
+    protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_event_5fview_5ftypes_2eproto_;
+const ::google::protobuf::EnumDescriptor* EventOrder_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EventOrder_descriptor_;
+}
+bool EventOrder_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetEventOptions::kFetchFromFieldNumber;
+const int GetEventOptions::kFetchUntilFieldNumber;
+const int GetEventOptions::kMaxEventsFieldNumber;
+const int GetEventOptions::kOrderFieldNumber;
+#endif  // !_MSC_VER
+
+GetEventOptions::GetEventOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.GetEventOptions)
+}
+
+void GetEventOptions::InitAsDefaultInstance() {
+}
+
+GetEventOptions::GetEventOptions(const GetEventOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.GetEventOptions)
+}
+
+void GetEventOptions::SharedCtor() {
+  _cached_size_ = 0;
+  fetch_from_ = GOOGLE_ULONGLONG(0);
+  fetch_until_ = GOOGLE_ULONGLONG(0);
+  max_events_ = 0u;
+  order_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetEventOptions::~GetEventOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.GetEventOptions)
+  SharedDtor();
+}
+
+void GetEventOptions::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetEventOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetEventOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetEventOptions_descriptor_;
+}
+
+const GetEventOptions& GetEventOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GetEventOptions* GetEventOptions::default_instance_ = NULL;
+
+GetEventOptions* GetEventOptions::New() const {
+  return new GetEventOptions;
+}
+
+void GetEventOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetEventOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(fetch_from_, order_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetEventOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.GetEventOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 fetch_from = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &fetch_from_)));
+          set_has_fetch_from();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_fetch_until;
+        break;
+      }
+
+      // optional uint64 fetch_until = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_fetch_until:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &fetch_until_)));
+          set_has_fetch_until();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_max_events;
+        break;
+      }
+
+      // optional uint32 max_events = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_max_events:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &max_events_)));
+          set_has_max_events();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_order;
+        break;
+      }
+
+      // optional .bgs.protocol.EventOrder order = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_order:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::EventOrder_IsValid(value)) {
+            set_order(static_cast< ::bgs::protocol::EventOrder >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(4, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.GetEventOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.GetEventOptions)
+  return false;
+#undef DO_
+}
+
+void GetEventOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.GetEventOptions)
+  // optional uint64 fetch_from = 1;
+  if (has_fetch_from()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->fetch_from(), output);
+  }
+
+  // optional uint64 fetch_until = 2;
+  if (has_fetch_until()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->fetch_until(), output);
+  }
+
+  // optional uint32 max_events = 3;
+  if (has_max_events()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->max_events(), output);
+  }
+
+  // optional .bgs.protocol.EventOrder order = 4;
+  if (has_order()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->order(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.GetEventOptions)
+}
+
+::google::protobuf::uint8* GetEventOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.GetEventOptions)
+  // optional uint64 fetch_from = 1;
+  if (has_fetch_from()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->fetch_from(), target);
+  }
+
+  // optional uint64 fetch_until = 2;
+  if (has_fetch_until()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->fetch_until(), target);
+  }
+
+  // optional uint32 max_events = 3;
+  if (has_max_events()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->max_events(), target);
+  }
+
+  // optional .bgs.protocol.EventOrder order = 4;
+  if (has_order()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      4, this->order(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.GetEventOptions)
+  return target;
+}
+
+int GetEventOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 fetch_from = 1;
+    if (has_fetch_from()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->fetch_from());
+    }
+
+    // optional uint64 fetch_until = 2;
+    if (has_fetch_until()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->fetch_until());
+    }
+
+    // optional uint32 max_events = 3;
+    if (has_max_events()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->max_events());
+    }
+
+    // optional .bgs.protocol.EventOrder order = 4;
+    if (has_order()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->order());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetEventOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetEventOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetEventOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetEventOptions::MergeFrom(const GetEventOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_fetch_from()) {
+      set_fetch_from(from.fetch_from());
+    }
+    if (from.has_fetch_until()) {
+      set_fetch_until(from.fetch_until());
+    }
+    if (from.has_max_events()) {
+      set_max_events(from.max_events());
+    }
+    if (from.has_order()) {
+      set_order(from.order());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetEventOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetEventOptions::CopyFrom(const GetEventOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetEventOptions::IsInitialized() const {
+
+  return true;
+}
+
+void GetEventOptions::Swap(GetEventOptions* other) {
+  if (other != this) {
+    std::swap(fetch_from_, other->fetch_from_);
+    std::swap(fetch_until_, other->fetch_until_);
+    std::swap(max_events_, other->max_events_);
+    std::swap(order_, other->order_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetEventOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetEventOptions_descriptor_;
+  metadata.reflection = GetEventOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ViewMarker::kLastReadTimeFieldNumber;
+const int ViewMarker::kLastMessageTimeFieldNumber;
+#endif  // !_MSC_VER
+
+ViewMarker::ViewMarker()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.ViewMarker)
+}
+
+void ViewMarker::InitAsDefaultInstance() {
+}
+
+ViewMarker::ViewMarker(const ViewMarker& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.ViewMarker)
+}
+
+void ViewMarker::SharedCtor() {
+  _cached_size_ = 0;
+  last_read_time_ = GOOGLE_ULONGLONG(0);
+  last_message_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ViewMarker::~ViewMarker() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.ViewMarker)
+  SharedDtor();
+}
+
+void ViewMarker::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ViewMarker::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ViewMarker::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ViewMarker_descriptor_;
+}
+
+const ViewMarker& ViewMarker::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ViewMarker* ViewMarker::default_instance_ = NULL;
+
+ViewMarker* ViewMarker::New() const {
+  return new ViewMarker;
+}
+
+void ViewMarker::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ViewMarker*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(last_read_time_, last_message_time_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ViewMarker::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.ViewMarker)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 last_read_time = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &last_read_time_)));
+          set_has_last_read_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_last_message_time;
+        break;
+      }
+
+      // optional uint64 last_message_time = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_last_message_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &last_message_time_)));
+          set_has_last_message_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.ViewMarker)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.ViewMarker)
+  return false;
+#undef DO_
+}
+
+void ViewMarker::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.ViewMarker)
+  // optional uint64 last_read_time = 1;
+  if (has_last_read_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->last_read_time(), output);
+  }
+
+  // optional uint64 last_message_time = 2;
+  if (has_last_message_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->last_message_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.ViewMarker)
+}
+
+::google::protobuf::uint8* ViewMarker::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.ViewMarker)
+  // optional uint64 last_read_time = 1;
+  if (has_last_read_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->last_read_time(), target);
+  }
+
+  // optional uint64 last_message_time = 2;
+  if (has_last_message_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->last_message_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.ViewMarker)
+  return target;
+}
+
+int ViewMarker::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 last_read_time = 1;
+    if (has_last_read_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->last_read_time());
+    }
+
+    // optional uint64 last_message_time = 2;
+    if (has_last_message_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->last_message_time());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ViewMarker::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ViewMarker* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ViewMarker*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ViewMarker::MergeFrom(const ViewMarker& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_last_read_time()) {
+      set_last_read_time(from.last_read_time());
+    }
+    if (from.has_last_message_time()) {
+      set_last_message_time(from.last_message_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ViewMarker::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ViewMarker::CopyFrom(const ViewMarker& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ViewMarker::IsInitialized() const {
+
+  return true;
+}
+
+void ViewMarker::Swap(ViewMarker* other) {
+  if (other != this) {
+    std::swap(last_read_time_, other->last_read_time_);
+    std::swap(last_message_time_, other->last_message_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ViewMarker::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ViewMarker_descriptor_;
+  metadata.reflection = ViewMarker_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/event_view_types.pb.h b/src/server/proto/Client/event_view_types.pb.h
new file mode 100644
index 00000000000..4132f5cb9f9
--- /dev/null
+++ b/src/server/proto/Client/event_view_types.pb.h
@@ -0,0 +1,440 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: event_view_types.proto
+
+#ifndef PROTOBUF_event_5fview_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_event_5fview_5ftypes_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+void protobuf_AssignDesc_event_5fview_5ftypes_2eproto();
+void protobuf_ShutdownFile_event_5fview_5ftypes_2eproto();
+
+class GetEventOptions;
+class ViewMarker;
+
+enum EventOrder {
+  EVENT_DESCENDING = 0,
+  EVENT_ASCENDING = 1
+};
+TC_PROTO_API bool EventOrder_IsValid(int value);
+const EventOrder EventOrder_MIN = EVENT_DESCENDING;
+const EventOrder EventOrder_MAX = EVENT_ASCENDING;
+const int EventOrder_ARRAYSIZE = EventOrder_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* EventOrder_descriptor();
+inline const ::std::string& EventOrder_Name(EventOrder value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    EventOrder_descriptor(), value);
+}
+inline bool EventOrder_Parse(
+    const ::std::string& name, EventOrder* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<EventOrder>(
+    EventOrder_descriptor(), name, value);
+}
+// ===================================================================
+
+class TC_PROTO_API GetEventOptions : public ::google::protobuf::Message {
+ public:
+  GetEventOptions();
+  virtual ~GetEventOptions();
+
+  GetEventOptions(const GetEventOptions& from);
+
+  inline GetEventOptions& operator=(const GetEventOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GetEventOptions& default_instance();
+
+  void Swap(GetEventOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  GetEventOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetEventOptions& from);
+  void MergeFrom(const GetEventOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 fetch_from = 1;
+  inline bool has_fetch_from() const;
+  inline void clear_fetch_from();
+  static const int kFetchFromFieldNumber = 1;
+  inline ::google::protobuf::uint64 fetch_from() const;
+  inline void set_fetch_from(::google::protobuf::uint64 value);
+
+  // optional uint64 fetch_until = 2;
+  inline bool has_fetch_until() const;
+  inline void clear_fetch_until();
+  static const int kFetchUntilFieldNumber = 2;
+  inline ::google::protobuf::uint64 fetch_until() const;
+  inline void set_fetch_until(::google::protobuf::uint64 value);
+
+  // optional uint32 max_events = 3;
+  inline bool has_max_events() const;
+  inline void clear_max_events();
+  static const int kMaxEventsFieldNumber = 3;
+  inline ::google::protobuf::uint32 max_events() const;
+  inline void set_max_events(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.EventOrder order = 4;
+  inline bool has_order() const;
+  inline void clear_order();
+  static const int kOrderFieldNumber = 4;
+  inline ::bgs::protocol::EventOrder order() const;
+  inline void set_order(::bgs::protocol::EventOrder value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.GetEventOptions)
+ private:
+  inline void set_has_fetch_from();
+  inline void clear_has_fetch_from();
+  inline void set_has_fetch_until();
+  inline void clear_has_fetch_until();
+  inline void set_has_max_events();
+  inline void clear_has_max_events();
+  inline void set_has_order();
+  inline void clear_has_order();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 fetch_from_;
+  ::google::protobuf::uint64 fetch_until_;
+  ::google::protobuf::uint32 max_events_;
+  int order_;
+  friend void TC_PROTO_API protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_event_5fview_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_event_5fview_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetEventOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API ViewMarker : public ::google::protobuf::Message {
+ public:
+  ViewMarker();
+  virtual ~ViewMarker();
+
+  ViewMarker(const ViewMarker& from);
+
+  inline ViewMarker& operator=(const ViewMarker& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ViewMarker& default_instance();
+
+  void Swap(ViewMarker* other);
+
+  // implements Message ----------------------------------------------
+
+  ViewMarker* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ViewMarker& from);
+  void MergeFrom(const ViewMarker& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 last_read_time = 1;
+  inline bool has_last_read_time() const;
+  inline void clear_last_read_time();
+  static const int kLastReadTimeFieldNumber = 1;
+  inline ::google::protobuf::uint64 last_read_time() const;
+  inline void set_last_read_time(::google::protobuf::uint64 value);
+
+  // optional uint64 last_message_time = 2;
+  inline bool has_last_message_time() const;
+  inline void clear_last_message_time();
+  static const int kLastMessageTimeFieldNumber = 2;
+  inline ::google::protobuf::uint64 last_message_time() const;
+  inline void set_last_message_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.ViewMarker)
+ private:
+  inline void set_has_last_read_time();
+  inline void clear_has_last_read_time();
+  inline void set_has_last_message_time();
+  inline void clear_has_last_message_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 last_read_time_;
+  ::google::protobuf::uint64 last_message_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_event_5fview_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_event_5fview_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_event_5fview_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ViewMarker* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// GetEventOptions
+
+// optional uint64 fetch_from = 1;
+inline bool GetEventOptions::has_fetch_from() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetEventOptions::set_has_fetch_from() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetEventOptions::clear_has_fetch_from() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetEventOptions::clear_fetch_from() {
+  fetch_from_ = GOOGLE_ULONGLONG(0);
+  clear_has_fetch_from();
+}
+inline ::google::protobuf::uint64 GetEventOptions::fetch_from() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GetEventOptions.fetch_from)
+  return fetch_from_;
+}
+inline void GetEventOptions::set_fetch_from(::google::protobuf::uint64 value) {
+  set_has_fetch_from();
+  fetch_from_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.GetEventOptions.fetch_from)
+}
+
+// optional uint64 fetch_until = 2;
+inline bool GetEventOptions::has_fetch_until() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetEventOptions::set_has_fetch_until() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetEventOptions::clear_has_fetch_until() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetEventOptions::clear_fetch_until() {
+  fetch_until_ = GOOGLE_ULONGLONG(0);
+  clear_has_fetch_until();
+}
+inline ::google::protobuf::uint64 GetEventOptions::fetch_until() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GetEventOptions.fetch_until)
+  return fetch_until_;
+}
+inline void GetEventOptions::set_fetch_until(::google::protobuf::uint64 value) {
+  set_has_fetch_until();
+  fetch_until_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.GetEventOptions.fetch_until)
+}
+
+// optional uint32 max_events = 3;
+inline bool GetEventOptions::has_max_events() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetEventOptions::set_has_max_events() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetEventOptions::clear_has_max_events() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetEventOptions::clear_max_events() {
+  max_events_ = 0u;
+  clear_has_max_events();
+}
+inline ::google::protobuf::uint32 GetEventOptions::max_events() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GetEventOptions.max_events)
+  return max_events_;
+}
+inline void GetEventOptions::set_max_events(::google::protobuf::uint32 value) {
+  set_has_max_events();
+  max_events_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.GetEventOptions.max_events)
+}
+
+// optional .bgs.protocol.EventOrder order = 4;
+inline bool GetEventOptions::has_order() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GetEventOptions::set_has_order() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GetEventOptions::clear_has_order() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GetEventOptions::clear_order() {
+  order_ = 0;
+  clear_has_order();
+}
+inline ::bgs::protocol::EventOrder GetEventOptions::order() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GetEventOptions.order)
+  return static_cast< ::bgs::protocol::EventOrder >(order_);
+}
+inline void GetEventOptions::set_order(::bgs::protocol::EventOrder value) {
+  assert(::bgs::protocol::EventOrder_IsValid(value));
+  set_has_order();
+  order_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.GetEventOptions.order)
+}
+
+// -------------------------------------------------------------------
+
+// ViewMarker
+
+// optional uint64 last_read_time = 1;
+inline bool ViewMarker::has_last_read_time() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ViewMarker::set_has_last_read_time() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ViewMarker::clear_has_last_read_time() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ViewMarker::clear_last_read_time() {
+  last_read_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_last_read_time();
+}
+inline ::google::protobuf::uint64 ViewMarker::last_read_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ViewMarker.last_read_time)
+  return last_read_time_;
+}
+inline void ViewMarker::set_last_read_time(::google::protobuf::uint64 value) {
+  set_has_last_read_time();
+  last_read_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ViewMarker.last_read_time)
+}
+
+// optional uint64 last_message_time = 2;
+inline bool ViewMarker::has_last_message_time() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ViewMarker::set_has_last_message_time() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ViewMarker::clear_has_last_message_time() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ViewMarker::clear_last_message_time() {
+  last_message_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_last_message_time();
+}
+inline ::google::protobuf::uint64 ViewMarker::last_message_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ViewMarker.last_message_time)
+  return last_message_time_;
+}
+inline void ViewMarker::set_last_message_time(::google::protobuf::uint64 value) {
+  set_has_last_message_time();
+  last_message_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ViewMarker.last_message_time)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::EventOrder> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::EventOrder>() {
+  return ::bgs::protocol::EventOrder_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_event_5fview_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/friends_service.pb.cc b/src/server/proto/Client/friends_service.pb.cc
index d6ca845341f..75ad7243a13 100644
--- a/src/server/proto/Client/friends_service.pb.cc
+++ b/src/server/proto/Client/friends_service.pb.cc
@@ -33,15 +33,27 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* UnsubscribeRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   UnsubscribeRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* GenericFriendRequest_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* SendInvitationRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
-  GenericFriendRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* GenericFriendResponse_descriptor_ = NULL;
+  SendInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RevokeInvitationRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
-  GenericFriendResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AssignRoleRequest_descriptor_ = NULL;
+  RevokeInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AcceptInvitationRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
-  AssignRoleRequest_reflection_ = NULL;
+  AcceptInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DeclineInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DeclineInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* IgnoreInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  IgnoreInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RemoveFriendRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RemoveFriendRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RevokeAllInvitationsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RevokeAllInvitationsRequest_reflection_ = NULL;
 const ::google::protobuf::Descriptor* ViewFriendsRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   ViewFriendsRequest_reflection_ = NULL;
@@ -69,6 +81,12 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* InvitationNotification_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   InvitationNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SentInvitationAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SentInvitationAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SentInvitationRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SentInvitationRemovedNotification_reflection_ = NULL;
 const ::google::protobuf::ServiceDescriptor* FriendsService_descriptor_ = NULL;
 const ::google::protobuf::ServiceDescriptor* FriendsListener_descriptor_ = NULL;
 
@@ -82,9 +100,10 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       "friends_service.proto");
   GOOGLE_CHECK(file != NULL);
   SubscribeRequest_descriptor_ = file->message_type(0);
-  static const int SubscribeRequest_offsets_[2] = {
+  static const int SubscribeRequest_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, agent_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, object_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, forward_),
   };
   SubscribeRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -98,9 +117,10 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(SubscribeRequest));
   UnsubscribeRequest_descriptor_ = file->message_type(1);
-  static const int UnsubscribeRequest_offsets_[2] = {
+  static const int UnsubscribeRequest_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, agent_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, object_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, forward_),
   };
   UnsubscribeRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -113,59 +133,124 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(UnsubscribeRequest));
-  GenericFriendRequest_descriptor_ = file->message_type(2);
-  static const int GenericFriendRequest_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, target_id_),
+  SendInvitationRequest_descriptor_ = file->message_type(2);
+  static const int SendInvitationRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, agent_identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, params_),
+  };
+  SendInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendInvitationRequest_descriptor_,
+      SendInvitationRequest::default_instance_,
+      SendInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendInvitationRequest));
+  RevokeInvitationRequest_descriptor_ = file->message_type(3);
+  static const int RevokeInvitationRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeInvitationRequest, invitation_id_),
+  };
+  RevokeInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RevokeInvitationRequest_descriptor_,
+      RevokeInvitationRequest::default_instance_,
+      RevokeInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RevokeInvitationRequest));
+  AcceptInvitationRequest_descriptor_ = file->message_type(4);
+  static const int AcceptInvitationRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, invitation_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, options_),
   };
-  GenericFriendRequest_reflection_ =
+  AcceptInvitationRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
-      GenericFriendRequest_descriptor_,
-      GenericFriendRequest::default_instance_,
-      GenericFriendRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, _unknown_fields_),
+      AcceptInvitationRequest_descriptor_,
+      AcceptInvitationRequest::default_instance_,
+      AcceptInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationRequest, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GenericFriendRequest));
-  GenericFriendResponse_descriptor_ = file->message_type(3);
-  static const int GenericFriendResponse_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendResponse, target_friend_),
+      sizeof(AcceptInvitationRequest));
+  DeclineInvitationRequest_descriptor_ = file->message_type(5);
+  static const int DeclineInvitationRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineInvitationRequest, invitation_id_),
   };
-  GenericFriendResponse_reflection_ =
+  DeclineInvitationRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
-      GenericFriendResponse_descriptor_,
-      GenericFriendResponse::default_instance_,
-      GenericFriendResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendResponse, _unknown_fields_),
+      DeclineInvitationRequest_descriptor_,
+      DeclineInvitationRequest::default_instance_,
+      DeclineInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeclineInvitationRequest, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GenericFriendResponse));
-  AssignRoleRequest_descriptor_ = file->message_type(4);
-  static const int AssignRoleRequest_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, target_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, role_),
+      sizeof(DeclineInvitationRequest));
+  IgnoreInvitationRequest_descriptor_ = file->message_type(6);
+  static const int IgnoreInvitationRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IgnoreInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IgnoreInvitationRequest, invitation_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IgnoreInvitationRequest, program_),
   };
-  AssignRoleRequest_reflection_ =
+  IgnoreInvitationRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
-      AssignRoleRequest_descriptor_,
-      AssignRoleRequest::default_instance_,
-      AssignRoleRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, _unknown_fields_),
+      IgnoreInvitationRequest_descriptor_,
+      IgnoreInvitationRequest::default_instance_,
+      IgnoreInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IgnoreInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IgnoreInvitationRequest, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AssignRoleRequest));
-  ViewFriendsRequest_descriptor_ = file->message_type(5);
-  static const int ViewFriendsRequest_offsets_[3] = {
+      sizeof(IgnoreInvitationRequest));
+  RemoveFriendRequest_descriptor_ = file->message_type(7);
+  static const int RemoveFriendRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveFriendRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveFriendRequest, target_id_),
+  };
+  RemoveFriendRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RemoveFriendRequest_descriptor_,
+      RemoveFriendRequest::default_instance_,
+      RemoveFriendRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveFriendRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveFriendRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RemoveFriendRequest));
+  RevokeAllInvitationsRequest_descriptor_ = file->message_type(8);
+  static const int RevokeAllInvitationsRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeAllInvitationsRequest, agent_id_),
+  };
+  RevokeAllInvitationsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RevokeAllInvitationsRequest_descriptor_,
+      RevokeAllInvitationsRequest::default_instance_,
+      RevokeAllInvitationsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeAllInvitationsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RevokeAllInvitationsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RevokeAllInvitationsRequest));
+  ViewFriendsRequest_descriptor_ = file->message_type(9);
+  static const int ViewFriendsRequest_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, agent_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, target_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, role_),
   };
   ViewFriendsRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -178,7 +263,7 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ViewFriendsRequest));
-  ViewFriendsResponse_descriptor_ = file->message_type(6);
+  ViewFriendsResponse_descriptor_ = file->message_type(10);
   static const int ViewFriendsResponse_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsResponse, friends_),
   };
@@ -193,12 +278,11 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ViewFriendsResponse));
-  UpdateFriendStateRequest_descriptor_ = file->message_type(7);
-  static const int UpdateFriendStateRequest_offsets_[4] = {
+  UpdateFriendStateRequest_descriptor_ = file->message_type(11);
+  static const int UpdateFriendStateRequest_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, agent_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, target_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, attribute_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, attributes_epoch_),
   };
   UpdateFriendStateRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -211,10 +295,9 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(UpdateFriendStateRequest));
-  GetFriendListRequest_descriptor_ = file->message_type(8);
-  static const int GetFriendListRequest_offsets_[2] = {
+  GetFriendListRequest_descriptor_ = file->message_type(12);
+  static const int GetFriendListRequest_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetFriendListRequest, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetFriendListRequest, target_id_),
   };
   GetFriendListRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -227,7 +310,7 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetFriendListRequest));
-  GetFriendListResponse_descriptor_ = file->message_type(9);
+  GetFriendListResponse_descriptor_ = file->message_type(13);
   static const int GetFriendListResponse_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetFriendListResponse, friends_),
   };
@@ -242,10 +325,10 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(GetFriendListResponse));
-  CreateFriendshipRequest_descriptor_ = file->message_type(10);
+  CreateFriendshipRequest_descriptor_ = file->message_type(14);
   static const int CreateFriendshipRequest_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateFriendshipRequest, inviter_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateFriendshipRequest, invitee_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateFriendshipRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateFriendshipRequest, target_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateFriendshipRequest, role_),
   };
   CreateFriendshipRequest_reflection_ =
@@ -259,12 +342,11 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(CreateFriendshipRequest));
-  FriendNotification_descriptor_ = file->message_type(11);
-  static const int FriendNotification_offsets_[4] = {
+  FriendNotification_descriptor_ = file->message_type(15);
+  static const int FriendNotification_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, target_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, game_account_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, peer_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, forward_),
   };
   FriendNotification_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -277,12 +359,11 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(FriendNotification));
-  UpdateFriendStateNotification_descriptor_ = file->message_type(12);
-  static const int UpdateFriendStateNotification_offsets_[4] = {
+  UpdateFriendStateNotification_descriptor_ = file->message_type(16);
+  static const int UpdateFriendStateNotification_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, changed_friend_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, game_account_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, peer_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, forward_),
   };
   UpdateFriendStateNotification_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -295,13 +376,12 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(UpdateFriendStateNotification));
-  InvitationNotification_descriptor_ = file->message_type(13);
-  static const int InvitationNotification_offsets_[5] = {
+  InvitationNotification_descriptor_ = file->message_type(17);
+  static const int InvitationNotification_offsets_[4] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, invitation_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, game_account_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, reason_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, peer_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, forward_),
   };
   InvitationNotification_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -314,6 +394,41 @@ void protobuf_AssignDesc_friends_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(InvitationNotification));
+  SentInvitationAddedNotification_descriptor_ = file->message_type(18);
+  static const int SentInvitationAddedNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationAddedNotification, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationAddedNotification, invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationAddedNotification, forward_),
+  };
+  SentInvitationAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SentInvitationAddedNotification_descriptor_,
+      SentInvitationAddedNotification::default_instance_,
+      SentInvitationAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SentInvitationAddedNotification));
+  SentInvitationRemovedNotification_descriptor_ = file->message_type(19);
+  static const int SentInvitationRemovedNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationRemovedNotification, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationRemovedNotification, invitation_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationRemovedNotification, reason_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationRemovedNotification, forward_),
+  };
+  SentInvitationRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SentInvitationRemovedNotification_descriptor_,
+      SentInvitationRemovedNotification::default_instance_,
+      SentInvitationRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitationRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SentInvitationRemovedNotification));
   FriendsService_descriptor_ = file->service(0);
   FriendsListener_descriptor_ = file->service(1);
 }
@@ -333,11 +448,19 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     UnsubscribeRequest_descriptor_, &UnsubscribeRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GenericFriendRequest_descriptor_, &GenericFriendRequest::default_instance());
+    SendInvitationRequest_descriptor_, &SendInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RevokeInvitationRequest_descriptor_, &RevokeInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AcceptInvitationRequest_descriptor_, &AcceptInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DeclineInvitationRequest_descriptor_, &DeclineInvitationRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GenericFriendResponse_descriptor_, &GenericFriendResponse::default_instance());
+    IgnoreInvitationRequest_descriptor_, &IgnoreInvitationRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AssignRoleRequest_descriptor_, &AssignRoleRequest::default_instance());
+    RemoveFriendRequest_descriptor_, &RemoveFriendRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RevokeAllInvitationsRequest_descriptor_, &RevokeAllInvitationsRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     ViewFriendsRequest_descriptor_, &ViewFriendsRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
@@ -356,6 +479,10 @@ void protobuf_RegisterTypes(const ::std::string&) {
     UpdateFriendStateNotification_descriptor_, &UpdateFriendStateNotification::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     InvitationNotification_descriptor_, &InvitationNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SentInvitationAddedNotification_descriptor_, &SentInvitationAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SentInvitationRemovedNotification_descriptor_, &SentInvitationRemovedNotification::default_instance());
 }
 
 }  // namespace
@@ -365,12 +492,20 @@ void protobuf_ShutdownFile_friends_5fservice_2eproto() {
   delete SubscribeRequest_reflection_;
   delete UnsubscribeRequest::default_instance_;
   delete UnsubscribeRequest_reflection_;
-  delete GenericFriendRequest::default_instance_;
-  delete GenericFriendRequest_reflection_;
-  delete GenericFriendResponse::default_instance_;
-  delete GenericFriendResponse_reflection_;
-  delete AssignRoleRequest::default_instance_;
-  delete AssignRoleRequest_reflection_;
+  delete SendInvitationRequest::default_instance_;
+  delete SendInvitationRequest_reflection_;
+  delete RevokeInvitationRequest::default_instance_;
+  delete RevokeInvitationRequest_reflection_;
+  delete AcceptInvitationRequest::default_instance_;
+  delete AcceptInvitationRequest_reflection_;
+  delete DeclineInvitationRequest::default_instance_;
+  delete DeclineInvitationRequest_reflection_;
+  delete IgnoreInvitationRequest::default_instance_;
+  delete IgnoreInvitationRequest_reflection_;
+  delete RemoveFriendRequest::default_instance_;
+  delete RemoveFriendRequest_reflection_;
+  delete RevokeAllInvitationsRequest::default_instance_;
+  delete RevokeAllInvitationsRequest_reflection_;
   delete ViewFriendsRequest::default_instance_;
   delete ViewFriendsRequest_reflection_;
   delete ViewFriendsResponse::default_instance_;
@@ -389,6 +524,10 @@ void protobuf_ShutdownFile_friends_5fservice_2eproto() {
   delete UpdateFriendStateNotification_reflection_;
   delete InvitationNotification::default_instance_;
   delete InvitationNotification_reflection_;
+  delete SentInvitationAddedNotification::default_instance_;
+  delete SentInvitationAddedNotification_reflection_;
+  delete SentInvitationRemovedNotification::default_instance_;
+  delete SentInvitationRemovedNotification_reflection_;
 }
 
 void protobuf_AddDesc_friends_5fservice_2eproto() {
@@ -406,117 +545,141 @@ void protobuf_AddDesc_friends_5fservice_2eproto() {
     "\n\025friends_service.proto\022\027bgs.protocol.fr"
     "iends.v1\032\025attribute_types.proto\032\022entity_"
     "types.proto\032\023friends_types.proto\032\026invita"
-    "tion_types.proto\032\017rpc_types.proto\"O\n\020Sub"
-    "scribeRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.pr"
-    "otocol.EntityId\022\021\n\tobject_id\030\002 \002(\004\"Q\n\022Un"
-    "subscribeRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs"
-    ".protocol.EntityId\022\021\n\tobject_id\030\002 \001(\004\"k\n"
-    "\024GenericFriendRequest\022(\n\010agent_id\030\001 \001(\0132"
+    "tion_types.proto\032\017rpc_types.proto\"\201\001\n\020Su"
+    "bscribeRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.p"
+    "rotocol.EntityId\022\021\n\tobject_id\030\002 \002(\004\0220\n\007f"
+    "orward\030\003 \001(\0132\033.bgs.protocol.ObjectAddres"
+    "sB\002\030\001\"\203\001\n\022UnsubscribeRequest\022(\n\010agent_id"
+    "\030\001 \001(\0132\026.bgs.protocol.EntityId\022\021\n\tobject"
+    "_id\030\002 \001(\004\0220\n\007forward\030\003 \001(\0132\033.bgs.protoco"
+    "l.ObjectAddressB\002\030\001\"\242\001\n\025SendInvitationRe"
+    "quest\022.\n\016agent_identity\030\001 \001(\0132\026.bgs.prot"
+    "ocol.Identity\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.p"
+    "rotocol.EntityId\022.\n\006params\030\003 \002(\0132\036.bgs.p"
+    "rotocol.InvitationParams\"Z\n\027RevokeInvita"
+    "tionRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.prot"
+    "ocol.EntityId\022\025\n\rinvitation_id\030\002 \001(\006\"\235\001\n"
+    "\027AcceptInvitationRequest\022(\n\010agent_id\030\001 \001"
+    "(\0132\026.bgs.protocol.EntityId\022\025\n\rinvitation"
+    "_id\030\003 \002(\006\022A\n\007options\030\004 \001(\01320.bgs.protoco"
+    "l.friends.v1.AcceptInvitationOptions\"[\n\030"
+    "DeclineInvitationRequest\022(\n\010agent_id\030\001 \001"
+    "(\0132\026.bgs.protocol.EntityId\022\025\n\rinvitation"
+    "_id\030\003 \002(\006\"k\n\027IgnoreInvitationRequest\022(\n\010"
+    "agent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\025"
+    "\n\rinvitation_id\030\003 \002(\006\022\017\n\007program\030\004 \001(\007\"j"
+    "\n\023RemoveFriendRequest\022(\n\010agent_id\030\001 \001(\0132"
     "\026.bgs.protocol.EntityId\022)\n\ttarget_id\030\002 \002"
-    "(\0132\026.bgs.protocol.EntityId\"O\n\025GenericFri"
-    "endResponse\0226\n\rtarget_friend\030\001 \001(\0132\037.bgs"
-    ".protocol.friends.v1.Friend\"v\n\021AssignRol"
-    "eRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protoco"
-    "l.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.prot"
-    "ocol.EntityId\022\014\n\004role\030\003 \003(\005\"{\n\022ViewFrien"
-    "dsRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protoc"
-    "ol.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.pro"
-    "tocol.EntityId\022\020\n\004role\030\003 \003(\rB\002\020\001\"O\n\023View"
-    "FriendsResponse\0228\n\007friends\030\001 \003(\0132\'.bgs.p"
-    "rotocol.friends.v1.FriendOfFriend\"\265\001\n\030Up"
-    "dateFriendStateRequest\022(\n\010agent_id\030\001 \001(\013"
-    "2\026.bgs.protocol.EntityId\022)\n\ttarget_id\030\002 "
-    "\002(\0132\026.bgs.protocol.EntityId\022*\n\tattribute"
-    "\030\003 \003(\0132\027.bgs.protocol.Attribute\022\030\n\020attri"
-    "butes_epoch\030\004 \001(\004\"k\n\024GetFriendListReques"
+    "(\0132\026.bgs.protocol.EntityId\"G\n\033RevokeAllI"
+    "nvitationsRequest\022(\n\010agent_id\030\002 \001(\0132\026.bg"
+    "s.protocol.EntityId\"i\n\022ViewFriendsReques"
     "t\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.Entit"
-    "yId\022)\n\ttarget_id\030\002 \001(\0132\026.bgs.protocol.En"
-    "tityId\"I\n\025GetFriendListResponse\0220\n\007frien"
-    "ds\030\001 \003(\0132\037.bgs.protocol.friends.v1.Frien"
-    "d\"\203\001\n\027CreateFriendshipRequest\022*\n\ninviter"
-    "_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022*\n\ninv"
-    "itee_id\030\002 \001(\0132\026.bgs.protocol.EntityId\022\020\n"
-    "\004role\030\003 \003(\rB\002\020\001\"\311\001\n\022FriendNotification\022/"
-    "\n\006target\030\001 \002(\0132\037.bgs.protocol.friends.v1"
-    ".Friend\022/\n\017game_account_id\030\002 \001(\0132\026.bgs.p"
-    "rotocol.EntityId\022%\n\004peer\030\004 \001(\0132\027.bgs.pro"
-    "tocol.ProcessId\022*\n\naccount_id\030\005 \001(\0132\026.bg"
-    "s.protocol.EntityId\"\334\001\n\035UpdateFriendStat"
-    "eNotification\0227\n\016changed_friend\030\001 \002(\0132\037."
-    "bgs.protocol.friends.v1.Friend\022/\n\017game_a"
-    "ccount_id\030\002 \001(\0132\026.bgs.protocol.EntityId\022"
-    "%\n\004peer\030\004 \001(\0132\027.bgs.protocol.ProcessId\022*"
-    "\n\naccount_id\030\005 \001(\0132\026.bgs.protocol.Entity"
-    "Id\"\335\001\n\026InvitationNotification\022,\n\ninvitat"
-    "ion\030\001 \002(\0132\030.bgs.protocol.Invitation\022/\n\017g"
-    "ame_account_id\030\002 \001(\0132\026.bgs.protocol.Enti"
-    "tyId\022\021\n\006reason\030\003 \001(\r:\0010\022%\n\004peer\030\004 \001(\0132\027."
-    "bgs.protocol.ProcessId\022*\n\naccount_id\030\005 \001"
-    "(\0132\026.bgs.protocol.EntityId2\214\013\n\016FriendsSe"
-    "rvice\022h\n\tSubscribe\022).bgs.protocol.friend"
-    "s.v1.SubscribeRequest\032*.bgs.protocol.fri"
-    "ends.v1.SubscribeResponse\"\004\200\265\030\001\022Q\n\016SendI"
-    "nvitation\022#.bgs.protocol.SendInvitationR"
-    "equest\032\024.bgs.protocol.NoData\"\004\200\265\030\002\022V\n\020Ac"
-    "ceptInvitation\022&.bgs.protocol.GenericInv"
-    "itationRequest\032\024.bgs.protocol.NoData\"\004\200\265"
-    "\030\003\022Y\n\020RevokeInvitation\022&.bgs.protocol.Ge"
-    "nericInvitationRequest\032\024.bgs.protocol.No"
-    "Data\"\007\210\002\001\200\265\030\004\022W\n\021DeclineInvitation\022&.bgs"
-    ".protocol.GenericInvitationRequest\032\024.bgs"
-    ".protocol.NoData\"\004\200\265\030\005\022V\n\020IgnoreInvitati"
-    "on\022&.bgs.protocol.GenericInvitationReque"
-    "st\032\024.bgs.protocol.NoData\"\004\200\265\030\006\022T\n\nAssign"
-    "Role\022*.bgs.protocol.friends.v1.AssignRol"
-    "eRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\007\022s\n\014"
-    "RemoveFriend\022-.bgs.protocol.friends.v1.G"
-    "enericFriendRequest\032..bgs.protocol.frien"
-    "ds.v1.GenericFriendResponse\"\004\200\265\030\010\022n\n\013Vie"
-    "wFriends\022+.bgs.protocol.friends.v1.ViewF"
-    "riendsRequest\032,.bgs.protocol.friends.v1."
-    "ViewFriendsResponse\"\004\200\265\030\t\022b\n\021UpdateFrien"
-    "dState\0221.bgs.protocol.friends.v1.UpdateF"
-    "riendStateRequest\032\024.bgs.protocol.NoData\""
-    "\004\200\265\030\n\022V\n\013Unsubscribe\022+.bgs.protocol.frie"
-    "nds.v1.UnsubscribeRequest\032\024.bgs.protocol"
-    ".NoData\"\004\200\265\030\013\022a\n\024RevokeAllInvitations\022-."
-    "bgs.protocol.friends.v1.GenericFriendReq"
-    "uest\032\024.bgs.protocol.NoData\"\004\200\265\030\014\022t\n\rGetF"
-    "riendList\022-.bgs.protocol.friends.v1.GetF"
-    "riendListRequest\032..bgs.protocol.friends."
-    "v1.GetFriendListResponse\"\004\200\265\030\r\022`\n\020Create"
-    "Friendship\0220.bgs.protocol.friends.v1.Cre"
-    "ateFriendshipRequest\032\024.bgs.protocol.NoDa"
-    "ta\"\004\200\265\030\016\032\'\312>$bnet.protocol.friends.Frien"
-    "dsService2\247\006\n\017FriendsListener\022]\n\rOnFrien"
-    "dAdded\022+.bgs.protocol.friends.v1.FriendN"
-    "otification\032\031.bgs.protocol.NO_RESPONSE\"\004"
-    "\200\265\030\001\022_\n\017OnFriendRemoved\022+.bgs.protocol.f"
-    "riends.v1.FriendNotification\032\031.bgs.proto"
-    "col.NO_RESPONSE\"\004\200\265\030\002\022m\n\031OnReceivedInvit"
-    "ationAdded\022/.bgs.protocol.friends.v1.Inv"
-    "itationNotification\032\031.bgs.protocol.NO_RE"
-    "SPONSE\"\004\200\265\030\003\022o\n\033OnReceivedInvitationRemo"
-    "ved\022/.bgs.protocol.friends.v1.Invitation"
-    "Notification\032\031.bgs.protocol.NO_RESPONSE\""
-    "\004\200\265\030\004\022l\n\025OnSentInvitationAdded\022/.bgs.pro"
-    "tocol.friends.v1.InvitationNotification\032"
-    "\031.bgs.protocol.NO_RESPONSE\"\007\210\002\001\200\265\030\005\022n\n\027O"
-    "nSentInvitationRemoved\022/.bgs.protocol.fr"
-    "iends.v1.InvitationNotification\032\031.bgs.pr"
-    "otocol.NO_RESPONSE\"\007\210\002\001\200\265\030\006\022n\n\023OnUpdateF"
-    "riendState\0226.bgs.protocol.friends.v1.Upd"
-    "ateFriendStateNotification\032\031.bgs.protoco"
-    "l.NO_RESPONSE\"\004\200\265\030\007\032&\312>#bnet.protocol.fr"
-    "iends.FriendsNotifyB7\n\030bnet.protocol.fri"
-    "ends.v1B\023FriendsServiceProtoH\001\200\001\000\210\001\001", 4276);
+    "yId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.protocol.En"
+    "tityId\"O\n\023ViewFriendsResponse\0228\n\007friends"
+    "\030\001 \003(\0132\'.bgs.protocol.friends.v1.FriendO"
+    "fFriend\"\233\001\n\030UpdateFriendStateRequest\022(\n\010"
+    "agent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)"
+    "\n\ttarget_id\030\002 \002(\0132\026.bgs.protocol.EntityI"
+    "d\022*\n\tattribute\030\003 \003(\0132\027.bgs.protocol.Attr"
+    "ibute\"@\n\024GetFriendListRequest\022(\n\010agent_i"
+    "d\030\002 \001(\0132\026.bgs.protocol.EntityId\"I\n\025GetFr"
+    "iendListResponse\0220\n\007friends\030\001 \003(\0132\037.bgs."
+    "protocol.friends.v1.Friend\"\200\001\n\027CreateFri"
+    "endshipRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.p"
+    "rotocol.EntityId\022)\n\ttarget_id\030\002 \001(\0132\026.bg"
+    "s.protocol.EntityId\022\020\n\004role\030\003 \003(\rB\002\020\001\"\243\001"
+    "\n\022FriendNotification\022/\n\006target\030\001 \002(\0132\037.b"
+    "gs.protocol.friends.v1.Friend\022*\n\naccount"
+    "_id\030\005 \001(\0132\026.bgs.protocol.EntityId\0220\n\007for"
+    "ward\030\006 \001(\0132\033.bgs.protocol.ObjectAddressB"
+    "\002\030\001\"\266\001\n\035UpdateFriendStateNotification\0227\n"
+    "\016changed_friend\030\001 \002(\0132\037.bgs.protocol.fri"
+    "ends.v1.Friend\022*\n\naccount_id\030\005 \001(\0132\026.bgs"
+    ".protocol.EntityId\0220\n\007forward\030\006 \001(\0132\033.bg"
+    "s.protocol.ObjectAddressB\002\030\001\"\312\001\n\026Invitat"
+    "ionNotification\022\?\n\ninvitation\030\001 \002(\0132+.bg"
+    "s.protocol.friends.v1.ReceivedInvitation"
+    "\022\021\n\006reason\030\003 \001(\r:\0010\022*\n\naccount_id\030\005 \001(\0132"
+    "\026.bgs.protocol.EntityId\0220\n\007forward\030\006 \001(\013"
+    "2\033.bgs.protocol.ObjectAddressB\002\030\001\"\274\001\n\037Se"
+    "ntInvitationAddedNotification\022*\n\naccount"
+    "_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022;\n\ninv"
+    "itation\030\002 \001(\0132\'.bgs.protocol.friends.v1."
+    "SentInvitation\0220\n\007forward\030\003 \001(\0132\033.bgs.pr"
+    "otocol.ObjectAddressB\002\030\001\"\250\001\n!SentInvitat"
+    "ionRemovedNotification\022*\n\naccount_id\030\001 \001"
+    "(\0132\026.bgs.protocol.EntityId\022\025\n\rinvitation"
+    "_id\030\002 \001(\006\022\016\n\006reason\030\003 \001(\r\0220\n\007forward\030\004 \001"
+    "(\0132\033.bgs.protocol.ObjectAddressB\002\030\0012\202\013\n\016"
+    "FriendsService\022j\n\tSubscribe\022).bgs.protoc"
+    "ol.friends.v1.SubscribeRequest\032*.bgs.pro"
+    "tocol.friends.v1.SubscribeResponse\"\006\202\371+\002"
+    "\010\001\022^\n\016SendInvitation\022..bgs.protocol.frie"
+    "nds.v1.SendInvitationRequest\032\024.bgs.proto"
+    "col.NoData\"\006\202\371+\002\010\002\022b\n\020AcceptInvitation\0220"
+    ".bgs.protocol.friends.v1.AcceptInvitatio"
+    "nRequest\032\024.bgs.protocol.NoData\"\006\202\371+\002\010\003\022b"
+    "\n\020RevokeInvitation\0220.bgs.protocol.friend"
+    "s.v1.RevokeInvitationRequest\032\024.bgs.proto"
+    "col.NoData\"\006\202\371+\002\010\004\022g\n\021DeclineInvitation\022"
+    "1.bgs.protocol.friends.v1.DeclineInvitat"
+    "ionRequest\032\024.bgs.protocol.NoData\"\t\210\002\001\202\371+"
+    "\002\010\005\022b\n\020IgnoreInvitation\0220.bgs.protocol.f"
+    "riends.v1.IgnoreInvitationRequest\032\024.bgs."
+    "protocol.NoData\"\006\202\371+\002\010\006\022Z\n\014RemoveFriend\022"
+    ",.bgs.protocol.friends.v1.RemoveFriendRe"
+    "quest\032\024.bgs.protocol.NoData\"\006\202\371+\002\010\010\022p\n\013V"
+    "iewFriends\022+.bgs.protocol.friends.v1.Vie"
+    "wFriendsRequest\032,.bgs.protocol.friends.v"
+    "1.ViewFriendsResponse\"\006\202\371+\002\010\t\022d\n\021UpdateF"
+    "riendState\0221.bgs.protocol.friends.v1.Upd"
+    "ateFriendStateRequest\032\024.bgs.protocol.NoD"
+    "ata\"\006\202\371+\002\010\n\022X\n\013Unsubscribe\022+.bgs.protoco"
+    "l.friends.v1.UnsubscribeRequest\032\024.bgs.pr"
+    "otocol.NoData\"\006\202\371+\002\010\013\022j\n\024RevokeAllInvita"
+    "tions\0224.bgs.protocol.friends.v1.RevokeAl"
+    "lInvitationsRequest\032\024.bgs.protocol.NoDat"
+    "a\"\006\202\371+\002\010\014\022v\n\rGetFriendList\022-.bgs.protoco"
+    "l.friends.v1.GetFriendListRequest\032..bgs."
+    "protocol.friends.v1.GetFriendListRespons"
+    "e\"\006\202\371+\002\010\r\022b\n\020CreateFriendship\0220.bgs.prot"
+    "ocol.friends.v1.CreateFriendshipRequest\032"
+    "\024.bgs.protocol.NoData\"\006\202\371+\002\010\016\0329\202\371+/\n$bne"
+    "t.protocol.friends.FriendsService*\007frien"
+    "ds\212\371+\002\020\0012\314\006\n\017FriendsListener\022_\n\rOnFriend"
+    "Added\022+.bgs.protocol.friends.v1.FriendNo"
+    "tification\032\031.bgs.protocol.NO_RESPONSE\"\006\202"
+    "\371+\002\010\001\022a\n\017OnFriendRemoved\022+.bgs.protocol."
+    "friends.v1.FriendNotification\032\031.bgs.prot"
+    "ocol.NO_RESPONSE\"\006\202\371+\002\010\002\022o\n\031OnReceivedIn"
+    "vitationAdded\022/.bgs.protocol.friends.v1."
+    "InvitationNotification\032\031.bgs.protocol.NO"
+    "_RESPONSE\"\006\202\371+\002\010\003\022q\n\033OnReceivedInvitatio"
+    "nRemoved\022/.bgs.protocol.friends.v1.Invit"
+    "ationNotification\032\031.bgs.protocol.NO_RESP"
+    "ONSE\"\006\202\371+\002\010\004\022t\n\025OnSentInvitationAdded\0228."
+    "bgs.protocol.friends.v1.SentInvitationAd"
+    "dedNotification\032\031.bgs.protocol.NO_RESPON"
+    "SE\"\006\202\371+\002\010\005\022x\n\027OnSentInvitationRemoved\022:."
+    "bgs.protocol.friends.v1.SentInvitationRe"
+    "movedNotification\032\031.bgs.protocol.NO_RESP"
+    "ONSE\"\006\202\371+\002\010\006\022p\n\023OnUpdateFriendState\0226.bg"
+    "s.protocol.friends.v1.UpdateFriendStateN"
+    "otification\032\031.bgs.protocol.NO_RESPONSE\"\006"
+    "\202\371+\002\010\007\032/\202\371+%\n#bnet.protocol.friends.Frie"
+    "ndsNotify\212\371+\002\010\001B7\n\030bnet.protocol.friends"
+    ".v1B\023FriendsServiceProtoH\001\200\001\000\210\001\001", 5072);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "friends_service.proto", &protobuf_RegisterTypes);
   SubscribeRequest::default_instance_ = new SubscribeRequest();
   UnsubscribeRequest::default_instance_ = new UnsubscribeRequest();
-  GenericFriendRequest::default_instance_ = new GenericFriendRequest();
-  GenericFriendResponse::default_instance_ = new GenericFriendResponse();
-  AssignRoleRequest::default_instance_ = new AssignRoleRequest();
+  SendInvitationRequest::default_instance_ = new SendInvitationRequest();
+  RevokeInvitationRequest::default_instance_ = new RevokeInvitationRequest();
+  AcceptInvitationRequest::default_instance_ = new AcceptInvitationRequest();
+  DeclineInvitationRequest::default_instance_ = new DeclineInvitationRequest();
+  IgnoreInvitationRequest::default_instance_ = new IgnoreInvitationRequest();
+  RemoveFriendRequest::default_instance_ = new RemoveFriendRequest();
+  RevokeAllInvitationsRequest::default_instance_ = new RevokeAllInvitationsRequest();
   ViewFriendsRequest::default_instance_ = new ViewFriendsRequest();
   ViewFriendsResponse::default_instance_ = new ViewFriendsResponse();
   UpdateFriendStateRequest::default_instance_ = new UpdateFriendStateRequest();
@@ -526,11 +689,17 @@ void protobuf_AddDesc_friends_5fservice_2eproto() {
   FriendNotification::default_instance_ = new FriendNotification();
   UpdateFriendStateNotification::default_instance_ = new UpdateFriendStateNotification();
   InvitationNotification::default_instance_ = new InvitationNotification();
+  SentInvitationAddedNotification::default_instance_ = new SentInvitationAddedNotification();
+  SentInvitationRemovedNotification::default_instance_ = new SentInvitationRemovedNotification();
   SubscribeRequest::default_instance_->InitAsDefaultInstance();
   UnsubscribeRequest::default_instance_->InitAsDefaultInstance();
-  GenericFriendRequest::default_instance_->InitAsDefaultInstance();
-  GenericFriendResponse::default_instance_->InitAsDefaultInstance();
-  AssignRoleRequest::default_instance_->InitAsDefaultInstance();
+  SendInvitationRequest::default_instance_->InitAsDefaultInstance();
+  RevokeInvitationRequest::default_instance_->InitAsDefaultInstance();
+  AcceptInvitationRequest::default_instance_->InitAsDefaultInstance();
+  DeclineInvitationRequest::default_instance_->InitAsDefaultInstance();
+  IgnoreInvitationRequest::default_instance_->InitAsDefaultInstance();
+  RemoveFriendRequest::default_instance_->InitAsDefaultInstance();
+  RevokeAllInvitationsRequest::default_instance_->InitAsDefaultInstance();
   ViewFriendsRequest::default_instance_->InitAsDefaultInstance();
   ViewFriendsResponse::default_instance_->InitAsDefaultInstance();
   UpdateFriendStateRequest::default_instance_->InitAsDefaultInstance();
@@ -540,6 +709,8 @@ void protobuf_AddDesc_friends_5fservice_2eproto() {
   FriendNotification::default_instance_->InitAsDefaultInstance();
   UpdateFriendStateNotification::default_instance_->InitAsDefaultInstance();
   InvitationNotification::default_instance_->InitAsDefaultInstance();
+  SentInvitationAddedNotification::default_instance_->InitAsDefaultInstance();
+  SentInvitationRemovedNotification::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_friends_5fservice_2eproto);
 }
 
@@ -555,6 +726,7 @@ struct StaticDescriptorInitializer_friends_5fservice_2eproto {
 #ifndef _MSC_VER
 const int SubscribeRequest::kAgentIdFieldNumber;
 const int SubscribeRequest::kObjectIdFieldNumber;
+const int SubscribeRequest::kForwardFieldNumber;
 #endif  // !_MSC_VER
 
 SubscribeRequest::SubscribeRequest()
@@ -565,6 +737,7 @@ SubscribeRequest::SubscribeRequest()
 
 void SubscribeRequest::InitAsDefaultInstance() {
   agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  forward_ = const_cast< ::bgs::protocol::ObjectAddress*>(&::bgs::protocol::ObjectAddress::default_instance());
 }
 
 SubscribeRequest::SubscribeRequest(const SubscribeRequest& from)
@@ -578,6 +751,7 @@ void SubscribeRequest::SharedCtor() {
   _cached_size_ = 0;
   agent_id_ = NULL;
   object_id_ = GOOGLE_ULONGLONG(0);
+  forward_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -589,6 +763,7 @@ SubscribeRequest::~SubscribeRequest() {
 void SubscribeRequest::SharedDtor() {
   if (this != default_instance_) {
     delete agent_id_;
+    delete forward_;
   }
 }
 
@@ -614,11 +789,14 @@ SubscribeRequest* SubscribeRequest::New() const {
 }
 
 void SubscribeRequest::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
+  if (_has_bits_[0 / 32] & 7) {
     if (has_agent_id()) {
       if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
     }
     object_id_ = GOOGLE_ULONGLONG(0);
+    if (has_forward()) {
+      if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -657,6 +835,19 @@ bool SubscribeRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(26)) goto parse_forward;
+        break;
+      }
+
+      // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+      case 3: {
+        if (tag == 26) {
+         parse_forward:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_forward()));
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -697,6 +888,12 @@ void SubscribeRequest::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output);
   }
 
+  // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+  if (has_forward()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->forward(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -719,6 +916,13 @@ void SubscribeRequest::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target);
   }
 
+  // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+  if (has_forward()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->forward(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -745,6 +949,13 @@ int SubscribeRequest::ByteSize() const {
           this->object_id());
     }
 
+    // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+    if (has_forward()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->forward());
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -778,6 +989,9 @@ void SubscribeRequest::MergeFrom(const SubscribeRequest& from) {
     if (from.has_object_id()) {
       set_object_id(from.object_id());
     }
+    if (from.has_forward()) {
+      mutable_forward()->::bgs::protocol::ObjectAddress::MergeFrom(from.forward());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -800,6 +1014,9 @@ bool SubscribeRequest::IsInitialized() const {
   if (has_agent_id()) {
     if (!this->agent_id().IsInitialized()) return false;
   }
+  if (has_forward()) {
+    if (!this->forward().IsInitialized()) return false;
+  }
   return true;
 }
 
@@ -807,6 +1024,7 @@ void SubscribeRequest::Swap(SubscribeRequest* other) {
   if (other != this) {
     std::swap(agent_id_, other->agent_id_);
     std::swap(object_id_, other->object_id_);
+    std::swap(forward_, other->forward_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -827,6 +1045,7 @@ void SubscribeRequest::Swap(SubscribeRequest* other) {
 #ifndef _MSC_VER
 const int UnsubscribeRequest::kAgentIdFieldNumber;
 const int UnsubscribeRequest::kObjectIdFieldNumber;
+const int UnsubscribeRequest::kForwardFieldNumber;
 #endif  // !_MSC_VER
 
 UnsubscribeRequest::UnsubscribeRequest()
@@ -837,6 +1056,7 @@ UnsubscribeRequest::UnsubscribeRequest()
 
 void UnsubscribeRequest::InitAsDefaultInstance() {
   agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  forward_ = const_cast< ::bgs::protocol::ObjectAddress*>(&::bgs::protocol::ObjectAddress::default_instance());
 }
 
 UnsubscribeRequest::UnsubscribeRequest(const UnsubscribeRequest& from)
@@ -850,6 +1070,7 @@ void UnsubscribeRequest::SharedCtor() {
   _cached_size_ = 0;
   agent_id_ = NULL;
   object_id_ = GOOGLE_ULONGLONG(0);
+  forward_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -861,6 +1082,7 @@ UnsubscribeRequest::~UnsubscribeRequest() {
 void UnsubscribeRequest::SharedDtor() {
   if (this != default_instance_) {
     delete agent_id_;
+    delete forward_;
   }
 }
 
@@ -886,11 +1108,14 @@ UnsubscribeRequest* UnsubscribeRequest::New() const {
 }
 
 void UnsubscribeRequest::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
+  if (_has_bits_[0 / 32] & 7) {
     if (has_agent_id()) {
       if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
     }
     object_id_ = GOOGLE_ULONGLONG(0);
+    if (has_forward()) {
+      if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -929,6 +1154,19 @@ bool UnsubscribeRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(26)) goto parse_forward;
+        break;
+      }
+
+      // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+      case 3: {
+        if (tag == 26) {
+         parse_forward:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_forward()));
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -969,6 +1207,12 @@ void UnsubscribeRequest::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output);
   }
 
+  // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+  if (has_forward()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->forward(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -991,6 +1235,13 @@ void UnsubscribeRequest::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target);
   }
 
+  // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+  if (has_forward()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->forward(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -1017,6 +1268,13 @@ int UnsubscribeRequest::ByteSize() const {
           this->object_id());
     }
 
+    // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+    if (has_forward()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->forward());
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -1050,6 +1308,9 @@ void UnsubscribeRequest::MergeFrom(const UnsubscribeRequest& from) {
     if (from.has_object_id()) {
       set_object_id(from.object_id());
     }
+    if (from.has_forward()) {
+      mutable_forward()->::bgs::protocol::ObjectAddress::MergeFrom(from.forward());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -1071,6 +1332,9 @@ bool UnsubscribeRequest::IsInitialized() const {
   if (has_agent_id()) {
     if (!this->agent_id().IsInitialized()) return false;
   }
+  if (has_forward()) {
+    if (!this->forward().IsInitialized()) return false;
+  }
   return true;
 }
 
@@ -1078,6 +1342,7 @@ void UnsubscribeRequest::Swap(UnsubscribeRequest* other) {
   if (other != this) {
     std::swap(agent_id_, other->agent_id_);
     std::swap(object_id_, other->object_id_);
+    std::swap(forward_, other->forward_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -1096,96 +1361,103 @@ void UnsubscribeRequest::Swap(UnsubscribeRequest* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int GenericFriendRequest::kAgentIdFieldNumber;
-const int GenericFriendRequest::kTargetIdFieldNumber;
+const int SendInvitationRequest::kAgentIdentityFieldNumber;
+const int SendInvitationRequest::kTargetIdFieldNumber;
+const int SendInvitationRequest::kParamsFieldNumber;
 #endif  // !_MSC_VER
 
-GenericFriendRequest::GenericFriendRequest()
+SendInvitationRequest::SendInvitationRequest()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.GenericFriendRequest)
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.SendInvitationRequest)
 }
 
-void GenericFriendRequest::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+void SendInvitationRequest::InitAsDefaultInstance() {
+  agent_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
   target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  params_ = const_cast< ::bgs::protocol::InvitationParams*>(&::bgs::protocol::InvitationParams::default_instance());
 }
 
-GenericFriendRequest::GenericFriendRequest(const GenericFriendRequest& from)
+SendInvitationRequest::SendInvitationRequest(const SendInvitationRequest& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.GenericFriendRequest)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.SendInvitationRequest)
 }
 
-void GenericFriendRequest::SharedCtor() {
+void SendInvitationRequest::SharedCtor() {
   _cached_size_ = 0;
-  agent_id_ = NULL;
+  agent_identity_ = NULL;
   target_id_ = NULL;
+  params_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-GenericFriendRequest::~GenericFriendRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.GenericFriendRequest)
+SendInvitationRequest::~SendInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.SendInvitationRequest)
   SharedDtor();
 }
 
-void GenericFriendRequest::SharedDtor() {
+void SendInvitationRequest::SharedDtor() {
   if (this != default_instance_) {
-    delete agent_id_;
+    delete agent_identity_;
     delete target_id_;
+    delete params_;
   }
 }
 
-void GenericFriendRequest::SetCachedSize(int size) const {
+void SendInvitationRequest::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* GenericFriendRequest::descriptor() {
+const ::google::protobuf::Descriptor* SendInvitationRequest::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return GenericFriendRequest_descriptor_;
+  return SendInvitationRequest_descriptor_;
 }
 
-const GenericFriendRequest& GenericFriendRequest::default_instance() {
+const SendInvitationRequest& SendInvitationRequest::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
   return *default_instance_;
 }
 
-GenericFriendRequest* GenericFriendRequest::default_instance_ = NULL;
+SendInvitationRequest* SendInvitationRequest::default_instance_ = NULL;
 
-GenericFriendRequest* GenericFriendRequest::New() const {
-  return new GenericFriendRequest;
+SendInvitationRequest* SendInvitationRequest::New() const {
+  return new SendInvitationRequest;
 }
 
-void GenericFriendRequest::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+void SendInvitationRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_identity()) {
+      if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
     }
     if (has_target_id()) {
       if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
     }
+    if (has_params()) {
+      if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool GenericFriendRequest::MergePartialFromCodedStream(
+bool SendInvitationRequest::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.GenericFriendRequest)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.SendInvitationRequest)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
+      // optional .bgs.protocol.Identity agent_identity = 1;
       case 1: {
         if (tag == 10) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
+               input, mutable_agent_identity()));
         } else {
           goto handle_unusual;
         }
@@ -1202,6 +1474,19 @@ bool GenericFriendRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(26)) goto parse_params;
+        break;
+      }
+
+      // required .bgs.protocol.InvitationParams params = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_params:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_params()));
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -1220,21 +1505,21 @@ bool GenericFriendRequest::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.GenericFriendRequest)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.SendInvitationRequest)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.GenericFriendRequest)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.SendInvitationRequest)
   return false;
 #undef DO_
 }
 
-void GenericFriendRequest::SerializeWithCachedSizes(
+void SendInvitationRequest::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.GenericFriendRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.SendInvitationRequest)
+  // optional .bgs.protocol.Identity agent_identity = 1;
+  if (has_agent_identity()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
+      1, this->agent_identity(), output);
   }
 
   // required .bgs.protocol.EntityId target_id = 2;
@@ -1243,21 +1528,27 @@ void GenericFriendRequest::SerializeWithCachedSizes(
       2, this->target_id(), output);
   }
 
+  // required .bgs.protocol.InvitationParams params = 3;
+  if (has_params()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->params(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.GenericFriendRequest)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.SendInvitationRequest)
 }
 
-::google::protobuf::uint8* GenericFriendRequest::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* SendInvitationRequest::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.GenericFriendRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.SendInvitationRequest)
+  // optional .bgs.protocol.Identity agent_identity = 1;
+  if (has_agent_identity()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
+        1, this->agent_identity(), target);
   }
 
   // required .bgs.protocol.EntityId target_id = 2;
@@ -1267,23 +1558,30 @@ void GenericFriendRequest::SerializeWithCachedSizes(
         2, this->target_id(), target);
   }
 
+  // required .bgs.protocol.InvitationParams params = 3;
+  if (has_params()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->params(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.GenericFriendRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.SendInvitationRequest)
   return target;
 }
 
-int GenericFriendRequest::ByteSize() const {
+int SendInvitationRequest::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
+    // optional .bgs.protocol.Identity agent_identity = 1;
+    if (has_agent_identity()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
+          this->agent_identity());
     }
 
     // required .bgs.protocol.EntityId target_id = 2;
@@ -1293,6 +1591,13 @@ int GenericFriendRequest::ByteSize() const {
           this->target_id());
     }
 
+    // required .bgs.protocol.InvitationParams params = 3;
+    if (has_params()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->params());
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -1305,10 +1610,10 @@ int GenericFriendRequest::ByteSize() const {
   return total_size;
 }
 
-void GenericFriendRequest::MergeFrom(const ::google::protobuf::Message& from) {
+void SendInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const GenericFriendRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GenericFriendRequest*>(
+  const SendInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendInvitationRequest*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -1317,58 +1622,918 @@ void GenericFriendRequest::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void GenericFriendRequest::MergeFrom(const GenericFriendRequest& from) {
+void SendInvitationRequest::MergeFrom(const SendInvitationRequest& from) {
   GOOGLE_CHECK_NE(&from, this);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    if (from.has_agent_identity()) {
+      mutable_agent_identity()->::bgs::protocol::Identity::MergeFrom(from.agent_identity());
     }
     if (from.has_target_id()) {
       mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
     }
+    if (from.has_params()) {
+      mutable_params()->::bgs::protocol::InvitationParams::MergeFrom(from.params());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendInvitationRequest::CopyFrom(const SendInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendInvitationRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
+
+  if (has_agent_identity()) {
+    if (!this->agent_identity().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  if (has_params()) {
+    if (!this->params().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendInvitationRequest::Swap(SendInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_identity_, other->agent_identity_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(params_, other->params_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendInvitationRequest_descriptor_;
+  metadata.reflection = SendInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RevokeInvitationRequest::kAgentIdFieldNumber;
+const int RevokeInvitationRequest::kInvitationIdFieldNumber;
+#endif  // !_MSC_VER
+
+RevokeInvitationRequest::RevokeInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.RevokeInvitationRequest)
+}
+
+void RevokeInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+RevokeInvitationRequest::RevokeInvitationRequest(const RevokeInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.RevokeInvitationRequest)
+}
+
+void RevokeInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RevokeInvitationRequest::~RevokeInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.RevokeInvitationRequest)
+  SharedDtor();
+}
+
+void RevokeInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void RevokeInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RevokeInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RevokeInvitationRequest_descriptor_;
+}
+
+const RevokeInvitationRequest& RevokeInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+RevokeInvitationRequest* RevokeInvitationRequest::default_instance_ = NULL;
+
+RevokeInvitationRequest* RevokeInvitationRequest::New() const {
+  return new RevokeInvitationRequest;
+}
+
+void RevokeInvitationRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    invitation_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RevokeInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.RevokeInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(17)) goto parse_invitation_id;
+        break;
+      }
+
+      // optional fixed64 invitation_id = 2;
+      case 2: {
+        if (tag == 17) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.RevokeInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.RevokeInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void RevokeInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.RevokeInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional fixed64 invitation_id = 2;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->invitation_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.RevokeInvitationRequest)
+}
+
+::google::protobuf::uint8* RevokeInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.RevokeInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional fixed64 invitation_id = 2;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->invitation_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.RevokeInvitationRequest)
+  return target;
+}
+
+int RevokeInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional fixed64 invitation_id = 2;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RevokeInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RevokeInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RevokeInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RevokeInvitationRequest::MergeFrom(const RevokeInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RevokeInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RevokeInvitationRequest::CopyFrom(const RevokeInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RevokeInvitationRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RevokeInvitationRequest::Swap(RevokeInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RevokeInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RevokeInvitationRequest_descriptor_;
+  metadata.reflection = RevokeInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AcceptInvitationRequest::kAgentIdFieldNumber;
+const int AcceptInvitationRequest::kInvitationIdFieldNumber;
+const int AcceptInvitationRequest::kOptionsFieldNumber;
+#endif  // !_MSC_VER
+
+AcceptInvitationRequest::AcceptInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.AcceptInvitationRequest)
+}
+
+void AcceptInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  options_ = const_cast< ::bgs::protocol::friends::v1::AcceptInvitationOptions*>(&::bgs::protocol::friends::v1::AcceptInvitationOptions::default_instance());
+}
+
+AcceptInvitationRequest::AcceptInvitationRequest(const AcceptInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.AcceptInvitationRequest)
+}
+
+void AcceptInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  options_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AcceptInvitationRequest::~AcceptInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.AcceptInvitationRequest)
+  SharedDtor();
+}
+
+void AcceptInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete options_;
+  }
+}
+
+void AcceptInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AcceptInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AcceptInvitationRequest_descriptor_;
+}
+
+const AcceptInvitationRequest& AcceptInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AcceptInvitationRequest* AcceptInvitationRequest::default_instance_ = NULL;
+
+AcceptInvitationRequest* AcceptInvitationRequest::New() const {
+  return new AcceptInvitationRequest;
+}
+
+void AcceptInvitationRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    invitation_id_ = GOOGLE_ULONGLONG(0);
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::friends::v1::AcceptInvitationOptions::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AcceptInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.AcceptInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_invitation_id;
+        break;
+      }
+
+      // required fixed64 invitation_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.friends.v1.AcceptInvitationOptions options = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.AcceptInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.AcceptInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void AcceptInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.AcceptInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
+  }
+
+  // optional .bgs.protocol.friends.v1.AcceptInvitationOptions options = 4;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->options(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.AcceptInvitationRequest)
+}
+
+::google::protobuf::uint8* AcceptInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.AcceptInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
+  }
+
+  // optional .bgs.protocol.friends.v1.AcceptInvitationOptions options = 4;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->options(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.AcceptInvitationRequest)
+  return target;
+}
+
+int AcceptInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required fixed64 invitation_id = 3;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+    // optional .bgs.protocol.friends.v1.AcceptInvitationOptions options = 4;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AcceptInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AcceptInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AcceptInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AcceptInvitationRequest::MergeFrom(const AcceptInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::friends::v1::AcceptInvitationOptions::MergeFrom(from.options());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void GenericFriendRequest::CopyFrom(const ::google::protobuf::Message& from) {
+void AcceptInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void GenericFriendRequest::CopyFrom(const GenericFriendRequest& from) {
+void AcceptInvitationRequest::CopyFrom(const AcceptInvitationRequest& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool GenericFriendRequest::IsInitialized() const {
+bool AcceptInvitationRequest::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
 
   if (has_agent_id()) {
     if (!this->agent_id().IsInitialized()) return false;
   }
-  if (has_target_id()) {
-    if (!this->target_id().IsInitialized()) return false;
+  return true;
+}
+
+void AcceptInvitationRequest::Swap(AcceptInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(options_, other->options_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AcceptInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AcceptInvitationRequest_descriptor_;
+  metadata.reflection = AcceptInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DeclineInvitationRequest::kAgentIdFieldNumber;
+const int DeclineInvitationRequest::kInvitationIdFieldNumber;
+#endif  // !_MSC_VER
+
+DeclineInvitationRequest::DeclineInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.DeclineInvitationRequest)
+}
+
+void DeclineInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+DeclineInvitationRequest::DeclineInvitationRequest(const DeclineInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.DeclineInvitationRequest)
+}
+
+void DeclineInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DeclineInvitationRequest::~DeclineInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.DeclineInvitationRequest)
+  SharedDtor();
+}
+
+void DeclineInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void DeclineInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DeclineInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DeclineInvitationRequest_descriptor_;
+}
+
+const DeclineInvitationRequest& DeclineInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+DeclineInvitationRequest* DeclineInvitationRequest::default_instance_ = NULL;
+
+DeclineInvitationRequest* DeclineInvitationRequest::New() const {
+  return new DeclineInvitationRequest;
+}
+
+void DeclineInvitationRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    invitation_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DeclineInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.DeclineInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_invitation_id;
+        break;
+      }
+
+      // required fixed64 invitation_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.DeclineInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.DeclineInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void DeclineInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.DeclineInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.DeclineInvitationRequest)
+}
+
+::google::protobuf::uint8* DeclineInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.DeclineInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.DeclineInvitationRequest)
+  return target;
+}
+
+int DeclineInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required fixed64 invitation_id = 3;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DeclineInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DeclineInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DeclineInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DeclineInvitationRequest::MergeFrom(const DeclineInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DeclineInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DeclineInvitationRequest::CopyFrom(const DeclineInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DeclineInvitationRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
   }
   return true;
 }
 
-void GenericFriendRequest::Swap(GenericFriendRequest* other) {
+void DeclineInvitationRequest::Swap(DeclineInvitationRequest* other) {
   if (other != this) {
     std::swap(agent_id_, other->agent_id_);
-    std::swap(target_id_, other->target_id_);
+    std::swap(invitation_id_, other->invitation_id_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata GenericFriendRequest::GetMetadata() const {
+::google::protobuf::Metadata DeclineInvitationRequest::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GenericFriendRequest_descriptor_;
-  metadata.reflection = GenericFriendRequest_reflection_;
+  metadata.descriptor = DeclineInvitationRequest_descriptor_;
+  metadata.reflection = DeclineInvitationRequest_reflection_;
   return metadata;
 }
 
@@ -1376,87 +2541,138 @@ void GenericFriendRequest::Swap(GenericFriendRequest* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int GenericFriendResponse::kTargetFriendFieldNumber;
+const int IgnoreInvitationRequest::kAgentIdFieldNumber;
+const int IgnoreInvitationRequest::kInvitationIdFieldNumber;
+const int IgnoreInvitationRequest::kProgramFieldNumber;
 #endif  // !_MSC_VER
 
-GenericFriendResponse::GenericFriendResponse()
+IgnoreInvitationRequest::IgnoreInvitationRequest()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.GenericFriendResponse)
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.IgnoreInvitationRequest)
 }
 
-void GenericFriendResponse::InitAsDefaultInstance() {
-  target_friend_ = const_cast< ::bgs::protocol::friends::v1::Friend*>(&::bgs::protocol::friends::v1::Friend::default_instance());
+void IgnoreInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
 }
 
-GenericFriendResponse::GenericFriendResponse(const GenericFriendResponse& from)
+IgnoreInvitationRequest::IgnoreInvitationRequest(const IgnoreInvitationRequest& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.GenericFriendResponse)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.IgnoreInvitationRequest)
 }
 
-void GenericFriendResponse::SharedCtor() {
+void IgnoreInvitationRequest::SharedCtor() {
   _cached_size_ = 0;
-  target_friend_ = NULL;
+  agent_id_ = NULL;
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  program_ = 0u;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-GenericFriendResponse::~GenericFriendResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.GenericFriendResponse)
+IgnoreInvitationRequest::~IgnoreInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.IgnoreInvitationRequest)
   SharedDtor();
 }
 
-void GenericFriendResponse::SharedDtor() {
+void IgnoreInvitationRequest::SharedDtor() {
   if (this != default_instance_) {
-    delete target_friend_;
+    delete agent_id_;
   }
 }
 
-void GenericFriendResponse::SetCachedSize(int size) const {
+void IgnoreInvitationRequest::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* GenericFriendResponse::descriptor() {
+const ::google::protobuf::Descriptor* IgnoreInvitationRequest::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return GenericFriendResponse_descriptor_;
+  return IgnoreInvitationRequest_descriptor_;
 }
 
-const GenericFriendResponse& GenericFriendResponse::default_instance() {
+const IgnoreInvitationRequest& IgnoreInvitationRequest::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
   return *default_instance_;
 }
 
-GenericFriendResponse* GenericFriendResponse::default_instance_ = NULL;
+IgnoreInvitationRequest* IgnoreInvitationRequest::default_instance_ = NULL;
 
-GenericFriendResponse* GenericFriendResponse::New() const {
-  return new GenericFriendResponse;
+IgnoreInvitationRequest* IgnoreInvitationRequest::New() const {
+  return new IgnoreInvitationRequest;
 }
 
-void GenericFriendResponse::Clear() {
-  if (has_target_friend()) {
-    if (target_friend_ != NULL) target_friend_->::bgs::protocol::friends::v1::Friend::Clear();
+void IgnoreInvitationRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<IgnoreInvitationRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(invitation_id_, program_);
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
   }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool GenericFriendResponse::MergePartialFromCodedStream(
+bool IgnoreInvitationRequest::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.GenericFriendResponse)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.IgnoreInvitationRequest)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.friends.v1.Friend target_friend = 1;
+      // optional .bgs.protocol.EntityId agent_id = 1;
       case 1: {
         if (tag == 10) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_target_friend()));
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_invitation_id;
+        break;
+      }
+
+      // required fixed64 invitation_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(37)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 4;
+      case 4: {
+        if (tag == 37) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
         } else {
           goto handle_unusual;
         }
@@ -1478,57 +2694,87 @@ bool GenericFriendResponse::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.GenericFriendResponse)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.IgnoreInvitationRequest)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.GenericFriendResponse)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.IgnoreInvitationRequest)
   return false;
 #undef DO_
 }
 
-void GenericFriendResponse::SerializeWithCachedSizes(
+void IgnoreInvitationRequest::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.GenericFriendResponse)
-  // optional .bgs.protocol.friends.v1.Friend target_friend = 1;
-  if (has_target_friend()) {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.IgnoreInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->target_friend(), output);
+      1, this->agent_id(), output);
+  }
+
+  // required fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
+  }
+
+  // optional fixed32 program = 4;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->program(), output);
   }
 
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.GenericFriendResponse)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.IgnoreInvitationRequest)
 }
 
-::google::protobuf::uint8* GenericFriendResponse::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* IgnoreInvitationRequest::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.GenericFriendResponse)
-  // optional .bgs.protocol.friends.v1.Friend target_friend = 1;
-  if (has_target_friend()) {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.IgnoreInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        1, this->target_friend(), target);
+        1, this->agent_id(), target);
+  }
+
+  // required fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
+  }
+
+  // optional fixed32 program = 4;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->program(), target);
   }
 
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.GenericFriendResponse)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.IgnoreInvitationRequest)
   return target;
 }
 
-int GenericFriendResponse::ByteSize() const {
+int IgnoreInvitationRequest::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.friends.v1.Friend target_friend = 1;
-    if (has_target_friend()) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->target_friend());
+          this->agent_id());
+    }
+
+    // required fixed64 invitation_id = 3;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+    // optional fixed32 program = 4;
+    if (has_program()) {
+      total_size += 1 + 4;
     }
 
   }
@@ -1543,10 +2789,10 @@ int GenericFriendResponse::ByteSize() const {
   return total_size;
 }
 
-void GenericFriendResponse::MergeFrom(const ::google::protobuf::Message& from) {
+void IgnoreInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const GenericFriendResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GenericFriendResponse*>(
+  const IgnoreInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const IgnoreInvitationRequest*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -1555,50 +2801,59 @@ void GenericFriendResponse::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void GenericFriendResponse::MergeFrom(const GenericFriendResponse& from) {
+void IgnoreInvitationRequest::MergeFrom(const IgnoreInvitationRequest& from) {
   GOOGLE_CHECK_NE(&from, this);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_target_friend()) {
-      mutable_target_friend()->::bgs::protocol::friends::v1::Friend::MergeFrom(from.target_friend());
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void GenericFriendResponse::CopyFrom(const ::google::protobuf::Message& from) {
+void IgnoreInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void GenericFriendResponse::CopyFrom(const GenericFriendResponse& from) {
+void IgnoreInvitationRequest::CopyFrom(const IgnoreInvitationRequest& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool GenericFriendResponse::IsInitialized() const {
+bool IgnoreInvitationRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
 
-  if (has_target_friend()) {
-    if (!this->target_friend().IsInitialized()) return false;
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
   }
   return true;
 }
 
-void GenericFriendResponse::Swap(GenericFriendResponse* other) {
+void IgnoreInvitationRequest::Swap(IgnoreInvitationRequest* other) {
   if (other != this) {
-    std::swap(target_friend_, other->target_friend_);
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(program_, other->program_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata GenericFriendResponse::GetMetadata() const {
+::google::protobuf::Metadata IgnoreInvitationRequest::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GenericFriendResponse_descriptor_;
-  metadata.reflection = GenericFriendResponse_reflection_;
+  metadata.descriptor = IgnoreInvitationRequest_descriptor_;
+  metadata.reflection = IgnoreInvitationRequest_reflection_;
   return metadata;
 }
 
@@ -1606,70 +2861,69 @@ void GenericFriendResponse::Swap(GenericFriendResponse* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int AssignRoleRequest::kAgentIdFieldNumber;
-const int AssignRoleRequest::kTargetIdFieldNumber;
-const int AssignRoleRequest::kRoleFieldNumber;
+const int RemoveFriendRequest::kAgentIdFieldNumber;
+const int RemoveFriendRequest::kTargetIdFieldNumber;
 #endif  // !_MSC_VER
 
-AssignRoleRequest::AssignRoleRequest()
+RemoveFriendRequest::RemoveFriendRequest()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.RemoveFriendRequest)
 }
 
-void AssignRoleRequest::InitAsDefaultInstance() {
+void RemoveFriendRequest::InitAsDefaultInstance() {
   agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
   target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
 }
 
-AssignRoleRequest::AssignRoleRequest(const AssignRoleRequest& from)
+RemoveFriendRequest::RemoveFriendRequest(const RemoveFriendRequest& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.RemoveFriendRequest)
 }
 
-void AssignRoleRequest::SharedCtor() {
+void RemoveFriendRequest::SharedCtor() {
   _cached_size_ = 0;
   agent_id_ = NULL;
   target_id_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-AssignRoleRequest::~AssignRoleRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.AssignRoleRequest)
+RemoveFriendRequest::~RemoveFriendRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.RemoveFriendRequest)
   SharedDtor();
 }
 
-void AssignRoleRequest::SharedDtor() {
+void RemoveFriendRequest::SharedDtor() {
   if (this != default_instance_) {
     delete agent_id_;
     delete target_id_;
   }
 }
 
-void AssignRoleRequest::SetCachedSize(int size) const {
+void RemoveFriendRequest::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* AssignRoleRequest::descriptor() {
+const ::google::protobuf::Descriptor* RemoveFriendRequest::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return AssignRoleRequest_descriptor_;
+  return RemoveFriendRequest_descriptor_;
 }
 
-const AssignRoleRequest& AssignRoleRequest::default_instance() {
+const RemoveFriendRequest& RemoveFriendRequest::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
   return *default_instance_;
 }
 
-AssignRoleRequest* AssignRoleRequest::default_instance_ = NULL;
+RemoveFriendRequest* RemoveFriendRequest::default_instance_ = NULL;
 
-AssignRoleRequest* AssignRoleRequest::New() const {
-  return new AssignRoleRequest;
+RemoveFriendRequest* RemoveFriendRequest::New() const {
+  return new RemoveFriendRequest;
 }
 
-void AssignRoleRequest::Clear() {
+void RemoveFriendRequest::Clear() {
   if (_has_bits_[0 / 32] & 3) {
     if (has_agent_id()) {
       if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
@@ -1678,16 +2932,15 @@ void AssignRoleRequest::Clear() {
       if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
     }
   }
-  role_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool AssignRoleRequest::MergePartialFromCodedStream(
+bool RemoveFriendRequest::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.RemoveFriendRequest)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
@@ -1714,25 +2967,6 @@ bool AssignRoleRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(24)) goto parse_role;
-        break;
-      }
-
-      // repeated int32 role = 3;
-      case 3: {
-        if (tag == 24) {
-         parse_role:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 1, 24, input, this->mutable_role())));
-        } else if (tag == 26) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
-                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
-                 input, this->mutable_role())));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(24)) goto parse_role;
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -1751,17 +2985,17 @@ bool AssignRoleRequest::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.RemoveFriendRequest)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.RemoveFriendRequest)
   return false;
 #undef DO_
 }
 
-void AssignRoleRequest::SerializeWithCachedSizes(
+void RemoveFriendRequest::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.RemoveFriendRequest)
   // optional .bgs.protocol.EntityId agent_id = 1;
   if (has_agent_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
@@ -1774,22 +3008,16 @@ void AssignRoleRequest::SerializeWithCachedSizes(
       2, this->target_id(), output);
   }
 
-  // repeated int32 role = 3;
-  for (int i = 0; i < this->role_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteInt32(
-      3, this->role(i), output);
-  }
-
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.RemoveFriendRequest)
 }
 
-::google::protobuf::uint8* AssignRoleRequest::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* RemoveFriendRequest::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.RemoveFriendRequest)
   // optional .bgs.protocol.EntityId agent_id = 1;
   if (has_agent_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
@@ -1804,21 +3032,15 @@ void AssignRoleRequest::SerializeWithCachedSizes(
         2, this->target_id(), target);
   }
 
-  // repeated int32 role = 3;
-  for (int i = 0; i < this->role_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteInt32ToArray(3, this->role(i), target);
-  }
-
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.RemoveFriendRequest)
   return target;
 }
 
-int AssignRoleRequest::ByteSize() const {
+int RemoveFriendRequest::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
@@ -1837,16 +3059,6 @@ int AssignRoleRequest::ByteSize() const {
     }
 
   }
-  // repeated int32 role = 3;
-  {
-    int data_size = 0;
-    for (int i = 0; i < this->role_size(); i++) {
-      data_size += ::google::protobuf::internal::WireFormatLite::
-        Int32Size(this->role(i));
-    }
-    total_size += 1 * this->role_size() + data_size;
-  }
-
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -1858,10 +3070,10 @@ int AssignRoleRequest::ByteSize() const {
   return total_size;
 }
 
-void AssignRoleRequest::MergeFrom(const ::google::protobuf::Message& from) {
+void RemoveFriendRequest::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const AssignRoleRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AssignRoleRequest*>(
+  const RemoveFriendRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RemoveFriendRequest*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -1870,9 +3082,8 @@ void AssignRoleRequest::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void AssignRoleRequest::MergeFrom(const AssignRoleRequest& from) {
+void RemoveFriendRequest::MergeFrom(const RemoveFriendRequest& from) {
   GOOGLE_CHECK_NE(&from, this);
-  role_.MergeFrom(from.role_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     if (from.has_agent_id()) {
       mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
@@ -1884,19 +3095,19 @@ void AssignRoleRequest::MergeFrom(const AssignRoleRequest& from) {
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void AssignRoleRequest::CopyFrom(const ::google::protobuf::Message& from) {
+void RemoveFriendRequest::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void AssignRoleRequest::CopyFrom(const AssignRoleRequest& from) {
+void RemoveFriendRequest::CopyFrom(const RemoveFriendRequest& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool AssignRoleRequest::IsInitialized() const {
+bool RemoveFriendRequest::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
 
   if (has_agent_id()) {
@@ -1908,22 +3119,251 @@ bool AssignRoleRequest::IsInitialized() const {
   return true;
 }
 
-void AssignRoleRequest::Swap(AssignRoleRequest* other) {
+void RemoveFriendRequest::Swap(RemoveFriendRequest* other) {
   if (other != this) {
     std::swap(agent_id_, other->agent_id_);
     std::swap(target_id_, other->target_id_);
-    role_.Swap(&other->role_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata AssignRoleRequest::GetMetadata() const {
+::google::protobuf::Metadata RemoveFriendRequest::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AssignRoleRequest_descriptor_;
-  metadata.reflection = AssignRoleRequest_reflection_;
+  metadata.descriptor = RemoveFriendRequest_descriptor_;
+  metadata.reflection = RemoveFriendRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RevokeAllInvitationsRequest::kAgentIdFieldNumber;
+#endif  // !_MSC_VER
+
+RevokeAllInvitationsRequest::RevokeAllInvitationsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+}
+
+void RevokeAllInvitationsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+RevokeAllInvitationsRequest::RevokeAllInvitationsRequest(const RevokeAllInvitationsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+}
+
+void RevokeAllInvitationsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RevokeAllInvitationsRequest::~RevokeAllInvitationsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+  SharedDtor();
+}
+
+void RevokeAllInvitationsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void RevokeAllInvitationsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RevokeAllInvitationsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RevokeAllInvitationsRequest_descriptor_;
+}
+
+const RevokeAllInvitationsRequest& RevokeAllInvitationsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+RevokeAllInvitationsRequest* RevokeAllInvitationsRequest::default_instance_ = NULL;
+
+RevokeAllInvitationsRequest* RevokeAllInvitationsRequest::New() const {
+  return new RevokeAllInvitationsRequest;
+}
+
+void RevokeAllInvitationsRequest::Clear() {
+  if (has_agent_id()) {
+    if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RevokeAllInvitationsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 2;
+      case 2: {
+        if (tag == 18) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+  return false;
+#undef DO_
+}
+
+void RevokeAllInvitationsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+  // optional .bgs.protocol.EntityId agent_id = 2;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->agent_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+}
+
+::google::protobuf::uint8* RevokeAllInvitationsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+  // optional .bgs.protocol.EntityId agent_id = 2;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->agent_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+  return target;
+}
+
+int RevokeAllInvitationsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 2;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RevokeAllInvitationsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RevokeAllInvitationsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RevokeAllInvitationsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RevokeAllInvitationsRequest::MergeFrom(const RevokeAllInvitationsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RevokeAllInvitationsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RevokeAllInvitationsRequest::CopyFrom(const RevokeAllInvitationsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RevokeAllInvitationsRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RevokeAllInvitationsRequest::Swap(RevokeAllInvitationsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RevokeAllInvitationsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RevokeAllInvitationsRequest_descriptor_;
+  metadata.reflection = RevokeAllInvitationsRequest_reflection_;
   return metadata;
 }
 
@@ -1933,7 +3373,6 @@ void AssignRoleRequest::Swap(AssignRoleRequest* other) {
 #ifndef _MSC_VER
 const int ViewFriendsRequest::kAgentIdFieldNumber;
 const int ViewFriendsRequest::kTargetIdFieldNumber;
-const int ViewFriendsRequest::kRoleFieldNumber;
 #endif  // !_MSC_VER
 
 ViewFriendsRequest::ViewFriendsRequest()
@@ -1958,7 +3397,6 @@ void ViewFriendsRequest::SharedCtor() {
   _cached_size_ = 0;
   agent_id_ = NULL;
   target_id_ = NULL;
-  _role_cached_byte_size_ = 0;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -2004,7 +3442,6 @@ void ViewFriendsRequest::Clear() {
       if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
     }
   }
-  role_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
@@ -2040,24 +3477,6 @@ bool ViewFriendsRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(26)) goto parse_role;
-        break;
-      }
-
-      // repeated uint32 role = 3 [packed = true];
-      case 3: {
-        if (tag == 26) {
-         parse_role:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, this->mutable_role())));
-        } else if (tag == 24) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 1, 26, input, this->mutable_role())));
-        } else {
-          goto handle_unusual;
-        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -2099,16 +3518,6 @@ void ViewFriendsRequest::SerializeWithCachedSizes(
       2, this->target_id(), output);
   }
 
-  // repeated uint32 role = 3 [packed = true];
-  if (this->role_size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
-    output->WriteVarint32(_role_cached_byte_size_);
-  }
-  for (int i = 0; i < this->role_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
-      this->role(i), output);
-  }
-
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -2133,20 +3542,6 @@ void ViewFriendsRequest::SerializeWithCachedSizes(
         2, this->target_id(), target);
   }
 
-  // repeated uint32 role = 3 [packed = true];
-  if (this->role_size() > 0) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
-      3,
-      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
-      target);
-    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
-      _role_cached_byte_size_, target);
-  }
-  for (int i = 0; i < this->role_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteUInt32NoTagToArray(this->role(i), target);
-  }
-
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -2174,23 +3569,6 @@ int ViewFriendsRequest::ByteSize() const {
     }
 
   }
-  // repeated uint32 role = 3 [packed = true];
-  {
-    int data_size = 0;
-    for (int i = 0; i < this->role_size(); i++) {
-      data_size += ::google::protobuf::internal::WireFormatLite::
-        UInt32Size(this->role(i));
-    }
-    if (data_size > 0) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
-    }
-    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-    _role_cached_byte_size_ = data_size;
-    GOOGLE_SAFE_CONCURRENT_WRITES_END();
-    total_size += data_size;
-  }
-
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -2216,7 +3594,6 @@ void ViewFriendsRequest::MergeFrom(const ::google::protobuf::Message& from) {
 
 void ViewFriendsRequest::MergeFrom(const ViewFriendsRequest& from) {
   GOOGLE_CHECK_NE(&from, this);
-  role_.MergeFrom(from.role_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     if (from.has_agent_id()) {
       mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
@@ -2256,7 +3633,6 @@ void ViewFriendsRequest::Swap(ViewFriendsRequest* other) {
   if (other != this) {
     std::swap(agent_id_, other->agent_id_);
     std::swap(target_id_, other->target_id_);
-    role_.Swap(&other->role_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -2498,7 +3874,6 @@ void ViewFriendsResponse::Swap(ViewFriendsResponse* other) {
 const int UpdateFriendStateRequest::kAgentIdFieldNumber;
 const int UpdateFriendStateRequest::kTargetIdFieldNumber;
 const int UpdateFriendStateRequest::kAttributeFieldNumber;
-const int UpdateFriendStateRequest::kAttributesEpochFieldNumber;
 #endif  // !_MSC_VER
 
 UpdateFriendStateRequest::UpdateFriendStateRequest()
@@ -2523,7 +3898,6 @@ void UpdateFriendStateRequest::SharedCtor() {
   _cached_size_ = 0;
   agent_id_ = NULL;
   target_id_ = NULL;
-  attributes_epoch_ = GOOGLE_ULONGLONG(0);
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -2561,14 +3935,13 @@ UpdateFriendStateRequest* UpdateFriendStateRequest::New() const {
 }
 
 void UpdateFriendStateRequest::Clear() {
-  if (_has_bits_[0 / 32] & 11) {
+  if (_has_bits_[0 / 32] & 3) {
     if (has_agent_id()) {
       if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
     }
     if (has_target_id()) {
       if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
     }
-    attributes_epoch_ = GOOGLE_ULONGLONG(0);
   }
   attribute_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
@@ -2620,21 +3993,6 @@ bool UpdateFriendStateRequest::MergePartialFromCodedStream(
           goto handle_unusual;
         }
         if (input->ExpectTag(26)) goto parse_attribute;
-        if (input->ExpectTag(32)) goto parse_attributes_epoch;
-        break;
-      }
-
-      // optional uint64 attributes_epoch = 4;
-      case 4: {
-        if (tag == 32) {
-         parse_attributes_epoch:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &attributes_epoch_)));
-          set_has_attributes_epoch();
-        } else {
-          goto handle_unusual;
-        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -2682,11 +4040,6 @@ void UpdateFriendStateRequest::SerializeWithCachedSizes(
       3, this->attribute(i), output);
   }
 
-  // optional uint64 attributes_epoch = 4;
-  if (has_attributes_epoch()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->attributes_epoch(), output);
-  }
-
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -2718,11 +4071,6 @@ void UpdateFriendStateRequest::SerializeWithCachedSizes(
         3, this->attribute(i), target);
   }
 
-  // optional uint64 attributes_epoch = 4;
-  if (has_attributes_epoch()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->attributes_epoch(), target);
-  }
-
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -2749,13 +4097,6 @@ int UpdateFriendStateRequest::ByteSize() const {
           this->target_id());
     }
 
-    // optional uint64 attributes_epoch = 4;
-    if (has_attributes_epoch()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->attributes_epoch());
-    }
-
   }
   // repeated .bgs.protocol.Attribute attribute = 3;
   total_size += 1 * this->attribute_size();
@@ -2798,9 +4139,6 @@ void UpdateFriendStateRequest::MergeFrom(const UpdateFriendStateRequest& from) {
     if (from.has_target_id()) {
       mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
     }
-    if (from.has_attributes_epoch()) {
-      set_attributes_epoch(from.attributes_epoch());
-    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -2835,7 +4173,6 @@ void UpdateFriendStateRequest::Swap(UpdateFriendStateRequest* other) {
     std::swap(agent_id_, other->agent_id_);
     std::swap(target_id_, other->target_id_);
     attribute_.Swap(&other->attribute_);
-    std::swap(attributes_epoch_, other->attributes_epoch_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -2855,7 +4192,6 @@ void UpdateFriendStateRequest::Swap(UpdateFriendStateRequest* other) {
 
 #ifndef _MSC_VER
 const int GetFriendListRequest::kAgentIdFieldNumber;
-const int GetFriendListRequest::kTargetIdFieldNumber;
 #endif  // !_MSC_VER
 
 GetFriendListRequest::GetFriendListRequest()
@@ -2866,7 +4202,6 @@ GetFriendListRequest::GetFriendListRequest()
 
 void GetFriendListRequest::InitAsDefaultInstance() {
   agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
 }
 
 GetFriendListRequest::GetFriendListRequest(const GetFriendListRequest& from)
@@ -2879,7 +4214,6 @@ GetFriendListRequest::GetFriendListRequest(const GetFriendListRequest& from)
 void GetFriendListRequest::SharedCtor() {
   _cached_size_ = 0;
   agent_id_ = NULL;
-  target_id_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -2891,7 +4225,6 @@ GetFriendListRequest::~GetFriendListRequest() {
 void GetFriendListRequest::SharedDtor() {
   if (this != default_instance_) {
     delete agent_id_;
-    delete target_id_;
   }
 }
 
@@ -2917,13 +4250,8 @@ GetFriendListRequest* GetFriendListRequest::New() const {
 }
 
 void GetFriendListRequest::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_target_id()) {
-      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
-    }
+  if (has_agent_id()) {
+    if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -2939,24 +4267,11 @@ bool GetFriendListRequest::MergePartialFromCodedStream(
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_target_id;
-        break;
-      }
-
-      // optional .bgs.protocol.EntityId target_id = 2;
+      // optional .bgs.protocol.EntityId agent_id = 2;
       case 2: {
         if (tag == 18) {
-         parse_target_id:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_target_id()));
+               input, mutable_agent_id()));
         } else {
           goto handle_unusual;
         }
@@ -2989,16 +4304,10 @@ failure:
 void GetFriendListRequest::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.GetFriendListRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
+  // optional .bgs.protocol.EntityId agent_id = 2;
   if (has_agent_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // optional .bgs.protocol.EntityId target_id = 2;
-  if (has_target_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->target_id(), output);
+      2, this->agent_id(), output);
   }
 
   if (!unknown_fields().empty()) {
@@ -3011,18 +4320,11 @@ void GetFriendListRequest::SerializeWithCachedSizes(
 ::google::protobuf::uint8* GetFriendListRequest::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
   // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.GetFriendListRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
+  // optional .bgs.protocol.EntityId agent_id = 2;
   if (has_agent_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // optional .bgs.protocol.EntityId target_id = 2;
-  if (has_target_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->target_id(), target);
+        2, this->agent_id(), target);
   }
 
   if (!unknown_fields().empty()) {
@@ -3037,20 +4339,13 @@ int GetFriendListRequest::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
+    // optional .bgs.protocol.EntityId agent_id = 2;
     if (has_agent_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->agent_id());
     }
 
-    // optional .bgs.protocol.EntityId target_id = 2;
-    if (has_target_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->target_id());
-    }
-
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -3081,9 +4376,6 @@ void GetFriendListRequest::MergeFrom(const GetFriendListRequest& from) {
     if (from.has_agent_id()) {
       mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
     }
-    if (from.has_target_id()) {
-      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
-    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -3105,16 +4397,12 @@ bool GetFriendListRequest::IsInitialized() const {
   if (has_agent_id()) {
     if (!this->agent_id().IsInitialized()) return false;
   }
-  if (has_target_id()) {
-    if (!this->target_id().IsInitialized()) return false;
-  }
   return true;
 }
 
 void GetFriendListRequest::Swap(GetFriendListRequest* other) {
   if (other != this) {
     std::swap(agent_id_, other->agent_id_);
-    std::swap(target_id_, other->target_id_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -3353,8 +4641,8 @@ void GetFriendListResponse::Swap(GetFriendListResponse* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int CreateFriendshipRequest::kInviterIdFieldNumber;
-const int CreateFriendshipRequest::kInviteeIdFieldNumber;
+const int CreateFriendshipRequest::kAgentIdFieldNumber;
+const int CreateFriendshipRequest::kTargetIdFieldNumber;
 const int CreateFriendshipRequest::kRoleFieldNumber;
 #endif  // !_MSC_VER
 
@@ -3365,8 +4653,8 @@ CreateFriendshipRequest::CreateFriendshipRequest()
 }
 
 void CreateFriendshipRequest::InitAsDefaultInstance() {
-  inviter_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  invitee_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
 }
 
 CreateFriendshipRequest::CreateFriendshipRequest(const CreateFriendshipRequest& from)
@@ -3378,8 +4666,8 @@ CreateFriendshipRequest::CreateFriendshipRequest(const CreateFriendshipRequest&
 
 void CreateFriendshipRequest::SharedCtor() {
   _cached_size_ = 0;
-  inviter_id_ = NULL;
-  invitee_id_ = NULL;
+  agent_id_ = NULL;
+  target_id_ = NULL;
   _role_cached_byte_size_ = 0;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
@@ -3391,8 +4679,8 @@ CreateFriendshipRequest::~CreateFriendshipRequest() {
 
 void CreateFriendshipRequest::SharedDtor() {
   if (this != default_instance_) {
-    delete inviter_id_;
-    delete invitee_id_;
+    delete agent_id_;
+    delete target_id_;
   }
 }
 
@@ -3419,11 +4707,11 @@ CreateFriendshipRequest* CreateFriendshipRequest::New() const {
 
 void CreateFriendshipRequest::Clear() {
   if (_has_bits_[0 / 32] & 3) {
-    if (has_inviter_id()) {
-      if (inviter_id_ != NULL) inviter_id_->::bgs::protocol::EntityId::Clear();
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
     }
-    if (has_invitee_id()) {
-      if (invitee_id_ != NULL) invitee_id_->::bgs::protocol::EntityId::Clear();
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
     }
   }
   role_.Clear();
@@ -3441,24 +4729,24 @@ bool CreateFriendshipRequest::MergePartialFromCodedStream(
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId inviter_id = 1;
+      // optional .bgs.protocol.EntityId agent_id = 1;
       case 1: {
         if (tag == 10) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_inviter_id()));
+               input, mutable_agent_id()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(18)) goto parse_invitee_id;
+        if (input->ExpectTag(18)) goto parse_target_id;
         break;
       }
 
-      // optional .bgs.protocol.EntityId invitee_id = 2;
+      // optional .bgs.protocol.EntityId target_id = 2;
       case 2: {
         if (tag == 18) {
-         parse_invitee_id:
+         parse_target_id:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_invitee_id()));
+               input, mutable_target_id()));
         } else {
           goto handle_unusual;
         }
@@ -3509,16 +4797,16 @@ failure:
 void CreateFriendshipRequest::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.CreateFriendshipRequest)
-  // optional .bgs.protocol.EntityId inviter_id = 1;
-  if (has_inviter_id()) {
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->inviter_id(), output);
+      1, this->agent_id(), output);
   }
 
-  // optional .bgs.protocol.EntityId invitee_id = 2;
-  if (has_invitee_id()) {
+  // optional .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->invitee_id(), output);
+      2, this->target_id(), output);
   }
 
   // repeated uint32 role = 3 [packed = true];
@@ -3541,18 +4829,18 @@ void CreateFriendshipRequest::SerializeWithCachedSizes(
 ::google::protobuf::uint8* CreateFriendshipRequest::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
   // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.CreateFriendshipRequest)
-  // optional .bgs.protocol.EntityId inviter_id = 1;
-  if (has_inviter_id()) {
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        1, this->inviter_id(), target);
+        1, this->agent_id(), target);
   }
 
-  // optional .bgs.protocol.EntityId invitee_id = 2;
-  if (has_invitee_id()) {
+  // optional .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        2, this->invitee_id(), target);
+        2, this->target_id(), target);
   }
 
   // repeated uint32 role = 3 [packed = true];
@@ -3581,18 +4869,18 @@ int CreateFriendshipRequest::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId inviter_id = 1;
-    if (has_inviter_id()) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->inviter_id());
+          this->agent_id());
     }
 
-    // optional .bgs.protocol.EntityId invitee_id = 2;
-    if (has_invitee_id()) {
+    // optional .bgs.protocol.EntityId target_id = 2;
+    if (has_target_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->invitee_id());
+          this->target_id());
     }
 
   }
@@ -3640,11 +4928,11 @@ void CreateFriendshipRequest::MergeFrom(const CreateFriendshipRequest& from) {
   GOOGLE_CHECK_NE(&from, this);
   role_.MergeFrom(from.role_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_inviter_id()) {
-      mutable_inviter_id()->::bgs::protocol::EntityId::MergeFrom(from.inviter_id());
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
     }
-    if (from.has_invitee_id()) {
-      mutable_invitee_id()->::bgs::protocol::EntityId::MergeFrom(from.invitee_id());
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
@@ -3664,19 +4952,19 @@ void CreateFriendshipRequest::CopyFrom(const CreateFriendshipRequest& from) {
 
 bool CreateFriendshipRequest::IsInitialized() const {
 
-  if (has_inviter_id()) {
-    if (!this->inviter_id().IsInitialized()) return false;
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
   }
-  if (has_invitee_id()) {
-    if (!this->invitee_id().IsInitialized()) return false;
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
   }
   return true;
 }
 
 void CreateFriendshipRequest::Swap(CreateFriendshipRequest* other) {
   if (other != this) {
-    std::swap(inviter_id_, other->inviter_id_);
-    std::swap(invitee_id_, other->invitee_id_);
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(target_id_, other->target_id_);
     role_.Swap(&other->role_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
@@ -3697,9 +4985,8 @@ void CreateFriendshipRequest::Swap(CreateFriendshipRequest* other) {
 
 #ifndef _MSC_VER
 const int FriendNotification::kTargetFieldNumber;
-const int FriendNotification::kGameAccountIdFieldNumber;
-const int FriendNotification::kPeerFieldNumber;
 const int FriendNotification::kAccountIdFieldNumber;
+const int FriendNotification::kForwardFieldNumber;
 #endif  // !_MSC_VER
 
 FriendNotification::FriendNotification()
@@ -3710,9 +4997,8 @@ FriendNotification::FriendNotification()
 
 void FriendNotification::InitAsDefaultInstance() {
   target_ = const_cast< ::bgs::protocol::friends::v1::Friend*>(&::bgs::protocol::friends::v1::Friend::default_instance());
-  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
   account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  forward_ = const_cast< ::bgs::protocol::ObjectAddress*>(&::bgs::protocol::ObjectAddress::default_instance());
 }
 
 FriendNotification::FriendNotification(const FriendNotification& from)
@@ -3725,9 +5011,8 @@ FriendNotification::FriendNotification(const FriendNotification& from)
 void FriendNotification::SharedCtor() {
   _cached_size_ = 0;
   target_ = NULL;
-  game_account_id_ = NULL;
-  peer_ = NULL;
   account_id_ = NULL;
+  forward_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -3739,9 +5024,8 @@ FriendNotification::~FriendNotification() {
 void FriendNotification::SharedDtor() {
   if (this != default_instance_) {
     delete target_;
-    delete game_account_id_;
-    delete peer_;
     delete account_id_;
+    delete forward_;
   }
 }
 
@@ -3767,19 +5051,16 @@ FriendNotification* FriendNotification::New() const {
 }
 
 void FriendNotification::Clear() {
-  if (_has_bits_[0 / 32] & 15) {
+  if (_has_bits_[0 / 32] & 7) {
     if (has_target()) {
       if (target_ != NULL) target_->::bgs::protocol::friends::v1::Friend::Clear();
     }
-    if (has_game_account_id()) {
-      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_peer()) {
-      if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
-    }
     if (has_account_id()) {
       if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
     }
+    if (has_forward()) {
+      if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -3803,42 +5084,29 @@ bool FriendNotification::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(18)) goto parse_game_account_id;
+        if (input->ExpectTag(42)) goto parse_account_id;
         break;
       }
 
-      // optional .bgs.protocol.EntityId game_account_id = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_game_account_id:
+      // optional .bgs.protocol.EntityId account_id = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_account_id:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account_id()));
+               input, mutable_account_id()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(34)) goto parse_peer;
+        if (input->ExpectTag(50)) goto parse_forward;
         break;
       }
 
-      // optional .bgs.protocol.ProcessId peer = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_peer:
+      // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+      case 6: {
+        if (tag == 50) {
+         parse_forward:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_peer()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_account_id;
-        break;
-      }
-
-      // optional .bgs.protocol.EntityId account_id = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_account_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_account_id()));
+               input, mutable_forward()));
         } else {
           goto handle_unusual;
         }
@@ -3877,24 +5145,18 @@ void FriendNotification::SerializeWithCachedSizes(
       1, this->target(), output);
   }
 
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  if (has_game_account_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->game_account_id(), output);
-  }
-
-  // optional .bgs.protocol.ProcessId peer = 4;
-  if (has_peer()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, this->peer(), output);
-  }
-
   // optional .bgs.protocol.EntityId account_id = 5;
   if (has_account_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       5, this->account_id(), output);
   }
 
+  // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+  if (has_forward()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->forward(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -3912,25 +5174,18 @@ void FriendNotification::SerializeWithCachedSizes(
         1, this->target(), target);
   }
 
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  if (has_game_account_id()) {
+  // optional .bgs.protocol.EntityId account_id = 5;
+  if (has_account_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        2, this->game_account_id(), target);
+        5, this->account_id(), target);
   }
 
-  // optional .bgs.protocol.ProcessId peer = 4;
-  if (has_peer()) {
+  // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+  if (has_forward()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        4, this->peer(), target);
-  }
-
-  // optional .bgs.protocol.EntityId account_id = 5;
-  if (has_account_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->account_id(), target);
+        6, this->forward(), target);
   }
 
   if (!unknown_fields().empty()) {
@@ -3952,25 +5207,18 @@ int FriendNotification::ByteSize() const {
           this->target());
     }
 
-    // optional .bgs.protocol.EntityId game_account_id = 2;
-    if (has_game_account_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account_id());
-    }
-
-    // optional .bgs.protocol.ProcessId peer = 4;
-    if (has_peer()) {
+    // optional .bgs.protocol.EntityId account_id = 5;
+    if (has_account_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->peer());
+          this->account_id());
     }
 
-    // optional .bgs.protocol.EntityId account_id = 5;
-    if (has_account_id()) {
+    // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+    if (has_forward()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->account_id());
+          this->forward());
     }
 
   }
@@ -4003,15 +5251,12 @@ void FriendNotification::MergeFrom(const FriendNotification& from) {
     if (from.has_target()) {
       mutable_target()->::bgs::protocol::friends::v1::Friend::MergeFrom(from.target());
     }
-    if (from.has_game_account_id()) {
-      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
-    }
-    if (from.has_peer()) {
-      mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer());
-    }
     if (from.has_account_id()) {
       mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
     }
+    if (from.has_forward()) {
+      mutable_forward()->::bgs::protocol::ObjectAddress::MergeFrom(from.forward());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -4034,24 +5279,20 @@ bool FriendNotification::IsInitialized() const {
   if (has_target()) {
     if (!this->target().IsInitialized()) return false;
   }
-  if (has_game_account_id()) {
-    if (!this->game_account_id().IsInitialized()) return false;
-  }
-  if (has_peer()) {
-    if (!this->peer().IsInitialized()) return false;
-  }
   if (has_account_id()) {
     if (!this->account_id().IsInitialized()) return false;
   }
+  if (has_forward()) {
+    if (!this->forward().IsInitialized()) return false;
+  }
   return true;
 }
 
 void FriendNotification::Swap(FriendNotification* other) {
   if (other != this) {
     std::swap(target_, other->target_);
-    std::swap(game_account_id_, other->game_account_id_);
-    std::swap(peer_, other->peer_);
     std::swap(account_id_, other->account_id_);
+    std::swap(forward_, other->forward_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -4071,9 +5312,8 @@ void FriendNotification::Swap(FriendNotification* other) {
 
 #ifndef _MSC_VER
 const int UpdateFriendStateNotification::kChangedFriendFieldNumber;
-const int UpdateFriendStateNotification::kGameAccountIdFieldNumber;
-const int UpdateFriendStateNotification::kPeerFieldNumber;
 const int UpdateFriendStateNotification::kAccountIdFieldNumber;
+const int UpdateFriendStateNotification::kForwardFieldNumber;
 #endif  // !_MSC_VER
 
 UpdateFriendStateNotification::UpdateFriendStateNotification()
@@ -4084,9 +5324,8 @@ UpdateFriendStateNotification::UpdateFriendStateNotification()
 
 void UpdateFriendStateNotification::InitAsDefaultInstance() {
   changed_friend_ = const_cast< ::bgs::protocol::friends::v1::Friend*>(&::bgs::protocol::friends::v1::Friend::default_instance());
-  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
   account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  forward_ = const_cast< ::bgs::protocol::ObjectAddress*>(&::bgs::protocol::ObjectAddress::default_instance());
 }
 
 UpdateFriendStateNotification::UpdateFriendStateNotification(const UpdateFriendStateNotification& from)
@@ -4099,9 +5338,8 @@ UpdateFriendStateNotification::UpdateFriendStateNotification(const UpdateFriendS
 void UpdateFriendStateNotification::SharedCtor() {
   _cached_size_ = 0;
   changed_friend_ = NULL;
-  game_account_id_ = NULL;
-  peer_ = NULL;
   account_id_ = NULL;
+  forward_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -4113,9 +5351,8 @@ UpdateFriendStateNotification::~UpdateFriendStateNotification() {
 void UpdateFriendStateNotification::SharedDtor() {
   if (this != default_instance_) {
     delete changed_friend_;
-    delete game_account_id_;
-    delete peer_;
     delete account_id_;
+    delete forward_;
   }
 }
 
@@ -4141,19 +5378,16 @@ UpdateFriendStateNotification* UpdateFriendStateNotification::New() const {
 }
 
 void UpdateFriendStateNotification::Clear() {
-  if (_has_bits_[0 / 32] & 15) {
+  if (_has_bits_[0 / 32] & 7) {
     if (has_changed_friend()) {
       if (changed_friend_ != NULL) changed_friend_->::bgs::protocol::friends::v1::Friend::Clear();
     }
-    if (has_game_account_id()) {
-      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_peer()) {
-      if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
-    }
     if (has_account_id()) {
       if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
     }
+    if (has_forward()) {
+      if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -4177,42 +5411,29 @@ bool UpdateFriendStateNotification::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(18)) goto parse_game_account_id;
-        break;
-      }
-
-      // optional .bgs.protocol.EntityId game_account_id = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_game_account_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_peer;
+        if (input->ExpectTag(42)) goto parse_account_id;
         break;
       }
 
-      // optional .bgs.protocol.ProcessId peer = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_peer:
+      // optional .bgs.protocol.EntityId account_id = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_account_id:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_peer()));
+               input, mutable_account_id()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(42)) goto parse_account_id;
+        if (input->ExpectTag(50)) goto parse_forward;
         break;
       }
 
-      // optional .bgs.protocol.EntityId account_id = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_account_id:
+      // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+      case 6: {
+        if (tag == 50) {
+         parse_forward:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_account_id()));
+               input, mutable_forward()));
         } else {
           goto handle_unusual;
         }
@@ -4251,24 +5472,18 @@ void UpdateFriendStateNotification::SerializeWithCachedSizes(
       1, this->changed_friend(), output);
   }
 
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  if (has_game_account_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->game_account_id(), output);
-  }
-
-  // optional .bgs.protocol.ProcessId peer = 4;
-  if (has_peer()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, this->peer(), output);
-  }
-
   // optional .bgs.protocol.EntityId account_id = 5;
   if (has_account_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       5, this->account_id(), output);
   }
 
+  // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+  if (has_forward()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->forward(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -4286,25 +5501,18 @@ void UpdateFriendStateNotification::SerializeWithCachedSizes(
         1, this->changed_friend(), target);
   }
 
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  if (has_game_account_id()) {
+  // optional .bgs.protocol.EntityId account_id = 5;
+  if (has_account_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        2, this->game_account_id(), target);
+        5, this->account_id(), target);
   }
 
-  // optional .bgs.protocol.ProcessId peer = 4;
-  if (has_peer()) {
+  // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+  if (has_forward()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        4, this->peer(), target);
-  }
-
-  // optional .bgs.protocol.EntityId account_id = 5;
-  if (has_account_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->account_id(), target);
+        6, this->forward(), target);
   }
 
   if (!unknown_fields().empty()) {
@@ -4326,25 +5534,18 @@ int UpdateFriendStateNotification::ByteSize() const {
           this->changed_friend());
     }
 
-    // optional .bgs.protocol.EntityId game_account_id = 2;
-    if (has_game_account_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account_id());
-    }
-
-    // optional .bgs.protocol.ProcessId peer = 4;
-    if (has_peer()) {
+    // optional .bgs.protocol.EntityId account_id = 5;
+    if (has_account_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->peer());
+          this->account_id());
     }
 
-    // optional .bgs.protocol.EntityId account_id = 5;
-    if (has_account_id()) {
+    // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+    if (has_forward()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->account_id());
+          this->forward());
     }
 
   }
@@ -4377,15 +5578,12 @@ void UpdateFriendStateNotification::MergeFrom(const UpdateFriendStateNotificatio
     if (from.has_changed_friend()) {
       mutable_changed_friend()->::bgs::protocol::friends::v1::Friend::MergeFrom(from.changed_friend());
     }
-    if (from.has_game_account_id()) {
-      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
-    }
-    if (from.has_peer()) {
-      mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer());
-    }
     if (from.has_account_id()) {
       mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
     }
+    if (from.has_forward()) {
+      mutable_forward()->::bgs::protocol::ObjectAddress::MergeFrom(from.forward());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -4408,24 +5606,20 @@ bool UpdateFriendStateNotification::IsInitialized() const {
   if (has_changed_friend()) {
     if (!this->changed_friend().IsInitialized()) return false;
   }
-  if (has_game_account_id()) {
-    if (!this->game_account_id().IsInitialized()) return false;
-  }
-  if (has_peer()) {
-    if (!this->peer().IsInitialized()) return false;
-  }
   if (has_account_id()) {
     if (!this->account_id().IsInitialized()) return false;
   }
+  if (has_forward()) {
+    if (!this->forward().IsInitialized()) return false;
+  }
   return true;
 }
 
 void UpdateFriendStateNotification::Swap(UpdateFriendStateNotification* other) {
   if (other != this) {
     std::swap(changed_friend_, other->changed_friend_);
-    std::swap(game_account_id_, other->game_account_id_);
-    std::swap(peer_, other->peer_);
     std::swap(account_id_, other->account_id_);
+    std::swap(forward_, other->forward_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -4445,10 +5639,9 @@ void UpdateFriendStateNotification::Swap(UpdateFriendStateNotification* other) {
 
 #ifndef _MSC_VER
 const int InvitationNotification::kInvitationFieldNumber;
-const int InvitationNotification::kGameAccountIdFieldNumber;
 const int InvitationNotification::kReasonFieldNumber;
-const int InvitationNotification::kPeerFieldNumber;
 const int InvitationNotification::kAccountIdFieldNumber;
+const int InvitationNotification::kForwardFieldNumber;
 #endif  // !_MSC_VER
 
 InvitationNotification::InvitationNotification()
@@ -4458,10 +5651,9 @@ InvitationNotification::InvitationNotification()
 }
 
 void InvitationNotification::InitAsDefaultInstance() {
-  invitation_ = const_cast< ::bgs::protocol::Invitation*>(&::bgs::protocol::Invitation::default_instance());
-  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  invitation_ = const_cast< ::bgs::protocol::friends::v1::ReceivedInvitation*>(&::bgs::protocol::friends::v1::ReceivedInvitation::default_instance());
   account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  forward_ = const_cast< ::bgs::protocol::ObjectAddress*>(&::bgs::protocol::ObjectAddress::default_instance());
 }
 
 InvitationNotification::InvitationNotification(const InvitationNotification& from)
@@ -4474,10 +5666,9 @@ InvitationNotification::InvitationNotification(const InvitationNotification& fro
 void InvitationNotification::SharedCtor() {
   _cached_size_ = 0;
   invitation_ = NULL;
-  game_account_id_ = NULL;
   reason_ = 0u;
-  peer_ = NULL;
   account_id_ = NULL;
+  forward_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -4489,9 +5680,8 @@ InvitationNotification::~InvitationNotification() {
 void InvitationNotification::SharedDtor() {
   if (this != default_instance_) {
     delete invitation_;
-    delete game_account_id_;
-    delete peer_;
     delete account_id_;
+    delete forward_;
   }
 }
 
@@ -4517,20 +5707,17 @@ InvitationNotification* InvitationNotification::New() const {
 }
 
 void InvitationNotification::Clear() {
-  if (_has_bits_[0 / 32] & 31) {
+  if (_has_bits_[0 / 32] & 15) {
     if (has_invitation()) {
-      if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear();
-    }
-    if (has_game_account_id()) {
-      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+      if (invitation_ != NULL) invitation_->::bgs::protocol::friends::v1::ReceivedInvitation::Clear();
     }
     reason_ = 0u;
-    if (has_peer()) {
-      if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
-    }
     if (has_account_id()) {
       if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
     }
+    if (has_forward()) {
+      if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+    }
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -4546,7 +5733,7 @@ bool InvitationNotification::MergePartialFromCodedStream(
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required .bgs.protocol.Invitation invitation = 1;
+      // required .bgs.protocol.friends.v1.ReceivedInvitation invitation = 1;
       case 1: {
         if (tag == 10) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
@@ -4554,19 +5741,6 @@ bool InvitationNotification::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(18)) goto parse_game_account_id;
-        break;
-      }
-
-      // optional .bgs.protocol.EntityId game_account_id = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_game_account_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_game_account_id()));
-        } else {
-          goto handle_unusual;
-        }
         if (input->ExpectTag(24)) goto parse_reason;
         break;
       }
@@ -4582,29 +5756,29 @@ bool InvitationNotification::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(34)) goto parse_peer;
+        if (input->ExpectTag(42)) goto parse_account_id;
         break;
       }
 
-      // optional .bgs.protocol.ProcessId peer = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_peer:
+      // optional .bgs.protocol.EntityId account_id = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_account_id:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_peer()));
+               input, mutable_account_id()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(42)) goto parse_account_id;
+        if (input->ExpectTag(50)) goto parse_forward;
         break;
       }
 
-      // optional .bgs.protocol.EntityId account_id = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_account_id:
+      // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+      case 6: {
+        if (tag == 50) {
+         parse_forward:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_account_id()));
+               input, mutable_forward()));
         } else {
           goto handle_unusual;
         }
@@ -4637,35 +5811,29 @@ failure:
 void InvitationNotification::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.InvitationNotification)
-  // required .bgs.protocol.Invitation invitation = 1;
+  // required .bgs.protocol.friends.v1.ReceivedInvitation invitation = 1;
   if (has_invitation()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       1, this->invitation(), output);
   }
 
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  if (has_game_account_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->game_account_id(), output);
-  }
-
   // optional uint32 reason = 3 [default = 0];
   if (has_reason()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output);
   }
 
-  // optional .bgs.protocol.ProcessId peer = 4;
-  if (has_peer()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, this->peer(), output);
-  }
-
   // optional .bgs.protocol.EntityId account_id = 5;
   if (has_account_id()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       5, this->account_id(), output);
   }
 
+  // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+  if (has_forward()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->forward(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -4676,37 +5844,30 @@ void InvitationNotification::SerializeWithCachedSizes(
 ::google::protobuf::uint8* InvitationNotification::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
   // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.InvitationNotification)
-  // required .bgs.protocol.Invitation invitation = 1;
+  // required .bgs.protocol.friends.v1.ReceivedInvitation invitation = 1;
   if (has_invitation()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
         1, this->invitation(), target);
   }
 
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  if (has_game_account_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->game_account_id(), target);
-  }
-
   // optional uint32 reason = 3 [default = 0];
   if (has_reason()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target);
   }
 
-  // optional .bgs.protocol.ProcessId peer = 4;
-  if (has_peer()) {
+  // optional .bgs.protocol.EntityId account_id = 5;
+  if (has_account_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        4, this->peer(), target);
+        5, this->account_id(), target);
   }
 
-  // optional .bgs.protocol.EntityId account_id = 5;
-  if (has_account_id()) {
+  // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+  if (has_forward()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        5, this->account_id(), target);
+        6, this->forward(), target);
   }
 
   if (!unknown_fields().empty()) {
@@ -4721,20 +5882,13 @@ int InvitationNotification::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required .bgs.protocol.Invitation invitation = 1;
+    // required .bgs.protocol.friends.v1.ReceivedInvitation invitation = 1;
     if (has_invitation()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
           this->invitation());
     }
 
-    // optional .bgs.protocol.EntityId game_account_id = 2;
-    if (has_game_account_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->game_account_id());
-    }
-
     // optional uint32 reason = 3 [default = 0];
     if (has_reason()) {
       total_size += 1 +
@@ -4742,18 +5896,18 @@ int InvitationNotification::ByteSize() const {
           this->reason());
     }
 
-    // optional .bgs.protocol.ProcessId peer = 4;
-    if (has_peer()) {
+    // optional .bgs.protocol.EntityId account_id = 5;
+    if (has_account_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->peer());
+          this->account_id());
     }
 
-    // optional .bgs.protocol.EntityId account_id = 5;
-    if (has_account_id()) {
+    // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+    if (has_forward()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->account_id());
+          this->forward());
     }
 
   }
@@ -4784,20 +5938,17 @@ void InvitationNotification::MergeFrom(const InvitationNotification& from) {
   GOOGLE_CHECK_NE(&from, this);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     if (from.has_invitation()) {
-      mutable_invitation()->::bgs::protocol::Invitation::MergeFrom(from.invitation());
-    }
-    if (from.has_game_account_id()) {
-      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+      mutable_invitation()->::bgs::protocol::friends::v1::ReceivedInvitation::MergeFrom(from.invitation());
     }
     if (from.has_reason()) {
       set_reason(from.reason());
     }
-    if (from.has_peer()) {
-      mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer());
-    }
     if (from.has_account_id()) {
       mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
     }
+    if (from.has_forward()) {
+      mutable_forward()->::bgs::protocol::ObjectAddress::MergeFrom(from.forward());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -4820,25 +5971,21 @@ bool InvitationNotification::IsInitialized() const {
   if (has_invitation()) {
     if (!this->invitation().IsInitialized()) return false;
   }
-  if (has_game_account_id()) {
-    if (!this->game_account_id().IsInitialized()) return false;
-  }
-  if (has_peer()) {
-    if (!this->peer().IsInitialized()) return false;
-  }
   if (has_account_id()) {
     if (!this->account_id().IsInitialized()) return false;
   }
+  if (has_forward()) {
+    if (!this->forward().IsInitialized()) return false;
+  }
   return true;
 }
 
 void InvitationNotification::Swap(InvitationNotification* other) {
   if (other != this) {
     std::swap(invitation_, other->invitation_);
-    std::swap(game_account_id_, other->game_account_id_);
     std::swap(reason_, other->reason_);
-    std::swap(peer_, other->peer_);
     std::swap(account_id_, other->account_id_);
+    std::swap(forward_, other->forward_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -4856,6 +6003,687 @@ void InvitationNotification::Swap(InvitationNotification* other) {
 
 // ===================================================================
 
+#ifndef _MSC_VER
+const int SentInvitationAddedNotification::kAccountIdFieldNumber;
+const int SentInvitationAddedNotification::kInvitationFieldNumber;
+const int SentInvitationAddedNotification::kForwardFieldNumber;
+#endif  // !_MSC_VER
+
+SentInvitationAddedNotification::SentInvitationAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+}
+
+void SentInvitationAddedNotification::InitAsDefaultInstance() {
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  invitation_ = const_cast< ::bgs::protocol::friends::v1::SentInvitation*>(&::bgs::protocol::friends::v1::SentInvitation::default_instance());
+  forward_ = const_cast< ::bgs::protocol::ObjectAddress*>(&::bgs::protocol::ObjectAddress::default_instance());
+}
+
+SentInvitationAddedNotification::SentInvitationAddedNotification(const SentInvitationAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+}
+
+void SentInvitationAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  account_id_ = NULL;
+  invitation_ = NULL;
+  forward_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SentInvitationAddedNotification::~SentInvitationAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+  SharedDtor();
+}
+
+void SentInvitationAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_id_;
+    delete invitation_;
+    delete forward_;
+  }
+}
+
+void SentInvitationAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SentInvitationAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SentInvitationAddedNotification_descriptor_;
+}
+
+const SentInvitationAddedNotification& SentInvitationAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SentInvitationAddedNotification* SentInvitationAddedNotification::default_instance_ = NULL;
+
+SentInvitationAddedNotification* SentInvitationAddedNotification::New() const {
+  return new SentInvitationAddedNotification;
+}
+
+void SentInvitationAddedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_invitation()) {
+      if (invitation_ != NULL) invitation_->::bgs::protocol::friends::v1::SentInvitation::Clear();
+    }
+    if (has_forward()) {
+      if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SentInvitationAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_invitation;
+        break;
+      }
+
+      // optional .bgs.protocol.friends.v1.SentInvitation invitation = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_invitation:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_invitation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_forward;
+        break;
+      }
+
+      // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+      case 3: {
+        if (tag == 26) {
+         parse_forward:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_forward()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+  return false;
+#undef DO_
+}
+
+void SentInvitationAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+  // optional .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_id(), output);
+  }
+
+  // optional .bgs.protocol.friends.v1.SentInvitation invitation = 2;
+  if (has_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->invitation(), output);
+  }
+
+  // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+  if (has_forward()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->forward(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+}
+
+::google::protobuf::uint8* SentInvitationAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+  // optional .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_id(), target);
+  }
+
+  // optional .bgs.protocol.friends.v1.SentInvitation invitation = 2;
+  if (has_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->invitation(), target);
+  }
+
+  // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+  if (has_forward()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->forward(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+  return target;
+}
+
+int SentInvitationAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId account_id = 1;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional .bgs.protocol.friends.v1.SentInvitation invitation = 2;
+    if (has_invitation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->invitation());
+    }
+
+    // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+    if (has_forward()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->forward());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SentInvitationAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SentInvitationAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SentInvitationAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SentInvitationAddedNotification::MergeFrom(const SentInvitationAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+    if (from.has_invitation()) {
+      mutable_invitation()->::bgs::protocol::friends::v1::SentInvitation::MergeFrom(from.invitation());
+    }
+    if (from.has_forward()) {
+      mutable_forward()->::bgs::protocol::ObjectAddress::MergeFrom(from.forward());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SentInvitationAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SentInvitationAddedNotification::CopyFrom(const SentInvitationAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SentInvitationAddedNotification::IsInitialized() const {
+
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  if (has_invitation()) {
+    if (!this->invitation().IsInitialized()) return false;
+  }
+  if (has_forward()) {
+    if (!this->forward().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SentInvitationAddedNotification::Swap(SentInvitationAddedNotification* other) {
+  if (other != this) {
+    std::swap(account_id_, other->account_id_);
+    std::swap(invitation_, other->invitation_);
+    std::swap(forward_, other->forward_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SentInvitationAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SentInvitationAddedNotification_descriptor_;
+  metadata.reflection = SentInvitationAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SentInvitationRemovedNotification::kAccountIdFieldNumber;
+const int SentInvitationRemovedNotification::kInvitationIdFieldNumber;
+const int SentInvitationRemovedNotification::kReasonFieldNumber;
+const int SentInvitationRemovedNotification::kForwardFieldNumber;
+#endif  // !_MSC_VER
+
+SentInvitationRemovedNotification::SentInvitationRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+}
+
+void SentInvitationRemovedNotification::InitAsDefaultInstance() {
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  forward_ = const_cast< ::bgs::protocol::ObjectAddress*>(&::bgs::protocol::ObjectAddress::default_instance());
+}
+
+SentInvitationRemovedNotification::SentInvitationRemovedNotification(const SentInvitationRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+}
+
+void SentInvitationRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  account_id_ = NULL;
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  reason_ = 0u;
+  forward_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SentInvitationRemovedNotification::~SentInvitationRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+  SharedDtor();
+}
+
+void SentInvitationRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_id_;
+    delete forward_;
+  }
+}
+
+void SentInvitationRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SentInvitationRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SentInvitationRemovedNotification_descriptor_;
+}
+
+const SentInvitationRemovedNotification& SentInvitationRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SentInvitationRemovedNotification* SentInvitationRemovedNotification::default_instance_ = NULL;
+
+SentInvitationRemovedNotification* SentInvitationRemovedNotification::New() const {
+  return new SentInvitationRemovedNotification;
+}
+
+void SentInvitationRemovedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    invitation_id_ = GOOGLE_ULONGLONG(0);
+    reason_ = 0u;
+    if (has_forward()) {
+      if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SentInvitationRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(17)) goto parse_invitation_id;
+        break;
+      }
+
+      // optional fixed64 invitation_id = 2;
+      case 2: {
+        if (tag == 17) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_reason;
+        break;
+      }
+
+      // optional uint32 reason = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_reason:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &reason_)));
+          set_has_reason();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_forward;
+        break;
+      }
+
+      // optional .bgs.protocol.ObjectAddress forward = 4 [deprecated = true];
+      case 4: {
+        if (tag == 34) {
+         parse_forward:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_forward()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void SentInvitationRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+  // optional .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_id(), output);
+  }
+
+  // optional fixed64 invitation_id = 2;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->invitation_id(), output);
+  }
+
+  // optional uint32 reason = 3;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output);
+  }
+
+  // optional .bgs.protocol.ObjectAddress forward = 4 [deprecated = true];
+  if (has_forward()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->forward(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+}
+
+::google::protobuf::uint8* SentInvitationRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+  // optional .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_id(), target);
+  }
+
+  // optional fixed64 invitation_id = 2;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->invitation_id(), target);
+  }
+
+  // optional uint32 reason = 3;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target);
+  }
+
+  // optional .bgs.protocol.ObjectAddress forward = 4 [deprecated = true];
+  if (has_forward()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->forward(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+  return target;
+}
+
+int SentInvitationRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId account_id = 1;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional fixed64 invitation_id = 2;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+    // optional uint32 reason = 3;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->reason());
+    }
+
+    // optional .bgs.protocol.ObjectAddress forward = 4 [deprecated = true];
+    if (has_forward()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->forward());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SentInvitationRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SentInvitationRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SentInvitationRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SentInvitationRemovedNotification::MergeFrom(const SentInvitationRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+    if (from.has_forward()) {
+      mutable_forward()->::bgs::protocol::ObjectAddress::MergeFrom(from.forward());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SentInvitationRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SentInvitationRemovedNotification::CopyFrom(const SentInvitationRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SentInvitationRemovedNotification::IsInitialized() const {
+
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  if (has_forward()) {
+    if (!this->forward().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SentInvitationRemovedNotification::Swap(SentInvitationRemovedNotification* other) {
+  if (other != this) {
+    std::swap(account_id_, other->account_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(reason_, other->reason_);
+    std::swap(forward_, other->forward_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SentInvitationRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SentInvitationRemovedNotification_descriptor_;
+  metadata.reflection = SentInvitationRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
 FriendsService::FriendsService(bool use_original_hash) : service_hash_(use_original_hash ? OriginalHash::value : NameHash::value) {
 }
 
@@ -4878,8 +6706,8 @@ void FriendsService::Subscribe(::bgs::protocol::friends::v1::SubscribeRequest co
   SendRequest(service_hash_, 1, request, std::move(callback));
 }
 
-void FriendsService::SendInvitation(::bgs::protocol::SendInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.SendInvitation(bgs.protocol.SendInvitationRequest{ %s })",
+void FriendsService::SendInvitation(::bgs::protocol::friends::v1::SendInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.SendInvitation(bgs.protocol.friends.v1.SendInvitationRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
     ::bgs::protocol::NoData response;
@@ -4889,8 +6717,8 @@ void FriendsService::SendInvitation(::bgs::protocol::SendInvitationRequest const
   SendRequest(service_hash_, 2, request, std::move(callback));
 }
 
-void FriendsService::AcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.AcceptInvitation(bgs.protocol.GenericInvitationRequest{ %s })",
+void FriendsService::AcceptInvitation(::bgs::protocol::friends::v1::AcceptInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.AcceptInvitation(bgs.protocol.friends.v1.AcceptInvitationRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
     ::bgs::protocol::NoData response;
@@ -4900,8 +6728,8 @@ void FriendsService::AcceptInvitation(::bgs::protocol::GenericInvitationRequest
   SendRequest(service_hash_, 3, request, std::move(callback));
 }
 
-void FriendsService::RevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RevokeInvitation(bgs.protocol.GenericInvitationRequest{ %s })",
+void FriendsService::RevokeInvitation(::bgs::protocol::friends::v1::RevokeInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RevokeInvitation(bgs.protocol.friends.v1.RevokeInvitationRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
     ::bgs::protocol::NoData response;
@@ -4911,8 +6739,8 @@ void FriendsService::RevokeInvitation(::bgs::protocol::GenericInvitationRequest
   SendRequest(service_hash_, 4, request, std::move(callback));
 }
 
-void FriendsService::DeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.DeclineInvitation(bgs.protocol.GenericInvitationRequest{ %s })",
+void FriendsService::DeclineInvitation(::bgs::protocol::friends::v1::DeclineInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.DeclineInvitation(bgs.protocol.friends.v1.DeclineInvitationRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
     ::bgs::protocol::NoData response;
@@ -4922,8 +6750,8 @@ void FriendsService::DeclineInvitation(::bgs::protocol::GenericInvitationRequest
   SendRequest(service_hash_, 5, request, std::move(callback));
 }
 
-void FriendsService::IgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.IgnoreInvitation(bgs.protocol.GenericInvitationRequest{ %s })",
+void FriendsService::IgnoreInvitation(::bgs::protocol::friends::v1::IgnoreInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.IgnoreInvitation(bgs.protocol.friends.v1.IgnoreInvitationRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
     ::bgs::protocol::NoData response;
@@ -4933,25 +6761,14 @@ void FriendsService::IgnoreInvitation(::bgs::protocol::GenericInvitationRequest
   SendRequest(service_hash_, 6, request, std::move(callback));
 }
 
-void FriendsService::AssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.AssignRole(bgs.protocol.friends.v1.AssignRoleRequest{ %s })",
+void FriendsService::RemoveFriend(::bgs::protocol::friends::v1::RemoveFriendRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RemoveFriend(bgs.protocol.friends.v1.RemoveFriendRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
     ::bgs::protocol::NoData response;
     if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
       responseCallback(&response);
   };
-  SendRequest(service_hash_, 7, request, std::move(callback));
-}
-
-void FriendsService::RemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function<void(::bgs::protocol::friends::v1::GenericFriendResponse const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RemoveFriend(bgs.protocol.friends.v1.GenericFriendRequest{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::friends::v1::GenericFriendResponse response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
   SendRequest(service_hash_, 8, request, std::move(callback));
 }
 
@@ -4988,8 +6805,8 @@ void FriendsService::Unsubscribe(::bgs::protocol::friends::v1::UnsubscribeReques
   SendRequest(service_hash_, 11, request, std::move(callback));
 }
 
-void FriendsService::RevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RevokeAllInvitations(bgs.protocol.friends.v1.GenericFriendRequest{ %s })",
+void FriendsService::RevokeAllInvitations(::bgs::protocol::friends::v1::RevokeAllInvitationsRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RevokeAllInvitations(bgs.protocol.friends.v1.RevokeAllInvitationsRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
     ::bgs::protocol::NoData response;
@@ -5050,13 +6867,13 @@ void FriendsService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
       break;
     }
     case 2: {
-      ::bgs::protocol::SendInvitationRequest request;
+      ::bgs::protocol::friends::v1::SendInvitationRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
         TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.SendInvitation server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.SendInvitation(bgs.protocol.SendInvitationRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.SendInvitation(bgs.protocol.friends.v1.SendInvitationRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
@@ -5076,13 +6893,13 @@ void FriendsService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
       break;
     }
     case 3: {
-      ::bgs::protocol::GenericInvitationRequest request;
+      ::bgs::protocol::friends::v1::AcceptInvitationRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
         TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.AcceptInvitation server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.AcceptInvitation(bgs.protocol.GenericInvitationRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.AcceptInvitation(bgs.protocol.friends.v1.AcceptInvitationRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
@@ -5102,13 +6919,13 @@ void FriendsService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
       break;
     }
     case 4: {
-      ::bgs::protocol::GenericInvitationRequest request;
+      ::bgs::protocol::friends::v1::RevokeInvitationRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
         TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.RevokeInvitation server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RevokeInvitation(bgs.protocol.GenericInvitationRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RevokeInvitation(bgs.protocol.friends.v1.RevokeInvitationRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
@@ -5128,13 +6945,13 @@ void FriendsService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
       break;
     }
     case 5: {
-      ::bgs::protocol::GenericInvitationRequest request;
+      ::bgs::protocol::friends::v1::DeclineInvitationRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
         TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.DeclineInvitation server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.DeclineInvitation(bgs.protocol.GenericInvitationRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.DeclineInvitation(bgs.protocol.friends.v1.DeclineInvitationRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
@@ -5154,13 +6971,13 @@ void FriendsService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
       break;
     }
     case 6: {
-      ::bgs::protocol::GenericInvitationRequest request;
+      ::bgs::protocol::friends::v1::IgnoreInvitationRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
         TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.IgnoreInvitation server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.IgnoreInvitation(bgs.protocol.GenericInvitationRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.IgnoreInvitation(bgs.protocol.friends.v1.IgnoreInvitationRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
@@ -5179,53 +6996,27 @@ void FriendsService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
         continuation(this, status, &response);
       break;
     }
-    case 7: {
-      ::bgs::protocol::friends::v1::AssignRoleRequest request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.AssignRole server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.AssignRole(bgs.protocol.friends.v1.AssignRoleRequest{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        FriendsService* self = static_cast<FriendsService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.AssignRole() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 7, token, response);
-        else
-          self->SendResponse(self->service_hash_, 7, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleAssignRole(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
     case 8: {
-      ::bgs::protocol::friends::v1::GenericFriendRequest request;
+      ::bgs::protocol::friends::v1::RemoveFriendRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
         TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.RemoveFriend server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RemoveFriend(bgs.protocol.friends.v1.GenericFriendRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RemoveFriend(bgs.protocol.friends.v1.RemoveFriendRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::friends::v1::GenericFriendResponse::descriptor());
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
         FriendsService* self = static_cast<FriendsService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RemoveFriend() returned bgs.protocol.friends.v1.GenericFriendResponse{ %s } status %u.",
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RemoveFriend() returned bgs.protocol.NoData{ %s } status %u.",
           self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
         if (!status)
           self->SendResponse(self->service_hash_, 8, token, response);
         else
           self->SendResponse(self->service_hash_, 8, token, status);
       };
-      ::bgs::protocol::friends::v1::GenericFriendResponse response;
+      ::bgs::protocol::NoData response;
       uint32 status = HandleRemoveFriend(&request, &response, continuation);
       if (continuation)
         continuation(this, status, &response);
@@ -5310,13 +7101,13 @@ void FriendsService::CallServerMethod(uint32 token, uint32 methodId, MessageBuff
       break;
     }
     case 12: {
-      ::bgs::protocol::friends::v1::GenericFriendRequest request;
+      ::bgs::protocol::friends::v1::RevokeAllInvitationsRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
         TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.RevokeAllInvitations server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RevokeAllInvitations(bgs.protocol.friends.v1.GenericFriendRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RevokeAllInvitations(bgs.protocol.friends.v1.RevokeAllInvitationsRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
@@ -5400,43 +7191,37 @@ uint32 FriendsService::HandleSubscribe(::bgs::protocol::friends::v1::SubscribeRe
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 FriendsService::HandleSendInvitation(::bgs::protocol::SendInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+uint32 FriendsService::HandleSendInvitation(::bgs::protocol::friends::v1::SendInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.SendInvitation({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 FriendsService::HandleAcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+uint32 FriendsService::HandleAcceptInvitation(::bgs::protocol::friends::v1::AcceptInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.AcceptInvitation({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 FriendsService::HandleRevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+uint32 FriendsService::HandleRevokeInvitation(::bgs::protocol::friends::v1::RevokeInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.RevokeInvitation({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 FriendsService::HandleDeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+uint32 FriendsService::HandleDeclineInvitation(::bgs::protocol::friends::v1::DeclineInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.DeclineInvitation({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 FriendsService::HandleIgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+uint32 FriendsService::HandleIgnoreInvitation(::bgs::protocol::friends::v1::IgnoreInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.IgnoreInvitation({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 FriendsService::HandleAssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.AssignRole({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
-uint32 FriendsService::HandleRemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::friends::v1::GenericFriendResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+uint32 FriendsService::HandleRemoveFriend(::bgs::protocol::friends::v1::RemoveFriendRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.RemoveFriend({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
@@ -5460,7 +7245,7 @@ uint32 FriendsService::HandleUnsubscribe(::bgs::protocol::friends::v1::Unsubscri
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 FriendsService::HandleRevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+uint32 FriendsService::HandleRevokeAllInvitations(::bgs::protocol::friends::v1::RevokeAllInvitationsRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.RevokeAllInvitations({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
@@ -5515,14 +7300,14 @@ void FriendsListener::OnReceivedInvitationRemoved(::bgs::protocol::friends::v1::
   SendRequest(service_hash_, 4, request);
 }
 
-void FriendsListener::OnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnSentInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s })",
+void FriendsListener::OnSentInvitationAdded(::bgs::protocol::friends::v1::SentInvitationAddedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnSentInvitationAdded(bgs.protocol.friends.v1.SentInvitationAddedNotification{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   SendRequest(service_hash_, 5, request);
 }
 
-void FriendsListener::OnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnSentInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s })",
+void FriendsListener::OnSentInvitationRemoved(::bgs::protocol::friends::v1::SentInvitationRemovedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnSentInvitationRemoved(bgs.protocol.friends.v1.SentInvitationRemovedNotification{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   SendRequest(service_hash_, 6, request);
 }
@@ -5592,28 +7377,28 @@ void FriendsListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuf
       break;
     }
     case 5: {
-      ::bgs::protocol::friends::v1::InvitationNotification request;
+      ::bgs::protocol::friends::v1::SentInvitationAddedNotification request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
         TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnSentInvitationAdded server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
       uint32 status = HandleOnSentInvitationAdded(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnSentInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnSentInvitationAdded(bgs.protocol.friends.v1.SentInvitationAddedNotification{ %s }) status %u.",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
       if (status)
         SendResponse(service_hash_, 5, token, status);
       break;
     }
     case 6: {
-      ::bgs::protocol::friends::v1::InvitationNotification request;
+      ::bgs::protocol::friends::v1::SentInvitationRemovedNotification request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
         TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnSentInvitationRemoved server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
       uint32 status = HandleOnSentInvitationRemoved(&request);
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnSentInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnSentInvitationRemoved(bgs.protocol.friends.v1.SentInvitationRemovedNotification{ %s }) status %u.",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
       if (status)
         SendResponse(service_hash_, 6, token, status);
@@ -5664,13 +7449,13 @@ uint32 FriendsListener::HandleOnReceivedInvitationRemoved(::bgs::protocol::frien
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 FriendsListener::HandleOnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) {
+uint32 FriendsListener::HandleOnSentInvitationAdded(::bgs::protocol::friends::v1::SentInvitationAddedNotification const* request) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnSentInvitationAdded({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 FriendsListener::HandleOnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) {
+uint32 FriendsListener::HandleOnSentInvitationRemoved(::bgs::protocol::friends::v1::SentInvitationRemovedNotification const* request) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnSentInvitationRemoved({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
diff --git a/src/server/proto/Client/friends_service.pb.h b/src/server/proto/Client/friends_service.pb.h
index 4092d79d28d..e009f190ffa 100644
--- a/src/server/proto/Client/friends_service.pb.h
+++ b/src/server/proto/Client/friends_service.pb.h
@@ -47,9 +47,13 @@ void protobuf_ShutdownFile_friends_5fservice_2eproto();
 
 class SubscribeRequest;
 class UnsubscribeRequest;
-class GenericFriendRequest;
-class GenericFriendResponse;
-class AssignRoleRequest;
+class SendInvitationRequest;
+class RevokeInvitationRequest;
+class AcceptInvitationRequest;
+class DeclineInvitationRequest;
+class IgnoreInvitationRequest;
+class RemoveFriendRequest;
+class RevokeAllInvitationsRequest;
 class ViewFriendsRequest;
 class ViewFriendsResponse;
 class UpdateFriendStateRequest;
@@ -59,6 +63,8 @@ class CreateFriendshipRequest;
 class FriendNotification;
 class UpdateFriendStateNotification;
 class InvitationNotification;
+class SentInvitationAddedNotification;
+class SentInvitationRemovedNotification;
 
 // ===================================================================
 
@@ -131,12 +137,23 @@ class TC_PROTO_API SubscribeRequest : public ::google::protobuf::Message {
   inline ::google::protobuf::uint64 object_id() const;
   inline void set_object_id(::google::protobuf::uint64 value);
 
+  // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+  inline bool has_forward() const PROTOBUF_DEPRECATED;
+  inline void clear_forward() PROTOBUF_DEPRECATED;
+  static const int kForwardFieldNumber = 3;
+  inline const ::bgs::protocol::ObjectAddress& forward() const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* mutable_forward() PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* release_forward() PROTOBUF_DEPRECATED;
+  inline void set_allocated_forward(::bgs::protocol::ObjectAddress* forward) PROTOBUF_DEPRECATED;
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SubscribeRequest)
  private:
   inline void set_has_agent_id();
   inline void clear_has_agent_id();
   inline void set_has_object_id();
   inline void clear_has_object_id();
+  inline void set_has_forward();
+  inline void clear_has_forward();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -144,6 +161,7 @@ class TC_PROTO_API SubscribeRequest : public ::google::protobuf::Message {
   mutable int _cached_size_;
   ::bgs::protocol::EntityId* agent_id_;
   ::google::protobuf::uint64 object_id_;
+  ::bgs::protocol::ObjectAddress* forward_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
@@ -222,12 +240,23 @@ class TC_PROTO_API UnsubscribeRequest : public ::google::protobuf::Message {
   inline ::google::protobuf::uint64 object_id() const;
   inline void set_object_id(::google::protobuf::uint64 value);
 
+  // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+  inline bool has_forward() const PROTOBUF_DEPRECATED;
+  inline void clear_forward() PROTOBUF_DEPRECATED;
+  static const int kForwardFieldNumber = 3;
+  inline const ::bgs::protocol::ObjectAddress& forward() const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* mutable_forward() PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* release_forward() PROTOBUF_DEPRECATED;
+  inline void set_allocated_forward(::bgs::protocol::ObjectAddress* forward) PROTOBUF_DEPRECATED;
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.UnsubscribeRequest)
  private:
   inline void set_has_agent_id();
   inline void clear_has_agent_id();
   inline void set_has_object_id();
   inline void clear_has_object_id();
+  inline void set_has_forward();
+  inline void clear_has_forward();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -235,6 +264,7 @@ class TC_PROTO_API UnsubscribeRequest : public ::google::protobuf::Message {
   mutable int _cached_size_;
   ::bgs::protocol::EntityId* agent_id_;
   ::google::protobuf::uint64 object_id_;
+  ::bgs::protocol::ObjectAddress* forward_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
@@ -244,14 +274,14 @@ class TC_PROTO_API UnsubscribeRequest : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API GenericFriendRequest : public ::google::protobuf::Message {
+class TC_PROTO_API SendInvitationRequest : public ::google::protobuf::Message {
  public:
-  GenericFriendRequest();
-  virtual ~GenericFriendRequest();
+  SendInvitationRequest();
+  virtual ~SendInvitationRequest();
 
-  GenericFriendRequest(const GenericFriendRequest& from);
+  SendInvitationRequest(const SendInvitationRequest& from);
 
-  inline GenericFriendRequest& operator=(const GenericFriendRequest& from) {
+  inline SendInvitationRequest& operator=(const SendInvitationRequest& from) {
     CopyFrom(from);
     return *this;
   }
@@ -265,17 +295,17 @@ class TC_PROTO_API GenericFriendRequest : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const GenericFriendRequest& default_instance();
+  static const SendInvitationRequest& default_instance();
 
-  void Swap(GenericFriendRequest* other);
+  void Swap(SendInvitationRequest* other);
 
   // implements Message ----------------------------------------------
 
-  GenericFriendRequest* New() const;
+  SendInvitationRequest* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GenericFriendRequest& from);
-  void MergeFrom(const GenericFriendRequest& from);
+  void CopyFrom(const SendInvitationRequest& from);
+  void MergeFrom(const SendInvitationRequest& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -297,14 +327,14 @@ class TC_PROTO_API GenericFriendRequest : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+  // optional .bgs.protocol.Identity agent_identity = 1;
+  inline bool has_agent_identity() const;
+  inline void clear_agent_identity();
+  static const int kAgentIdentityFieldNumber = 1;
+  inline const ::bgs::protocol::Identity& agent_identity() const;
+  inline ::bgs::protocol::Identity* mutable_agent_identity();
+  inline ::bgs::protocol::Identity* release_agent_identity();
+  inline void set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity);
 
   // required .bgs.protocol.EntityId target_id = 2;
   inline bool has_target_id() const;
@@ -315,36 +345,333 @@ class TC_PROTO_API GenericFriendRequest : public ::google::protobuf::Message {
   inline ::bgs::protocol::EntityId* release_target_id();
   inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
 
-  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.GenericFriendRequest)
+  // required .bgs.protocol.InvitationParams params = 3;
+  inline bool has_params() const;
+  inline void clear_params();
+  static const int kParamsFieldNumber = 3;
+  inline const ::bgs::protocol::InvitationParams& params() const;
+  inline ::bgs::protocol::InvitationParams* mutable_params();
+  inline ::bgs::protocol::InvitationParams* release_params();
+  inline void set_allocated_params(::bgs::protocol::InvitationParams* params);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SendInvitationRequest)
  private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
+  inline void set_has_agent_identity();
+  inline void clear_has_agent_identity();
   inline void set_has_target_id();
   inline void clear_has_target_id();
+  inline void set_has_params();
+  inline void clear_has_params();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::Identity* agent_identity_;
   ::bgs::protocol::EntityId* target_id_;
+  ::bgs::protocol::InvitationParams* params_;
+  friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RevokeInvitationRequest : public ::google::protobuf::Message {
+ public:
+  RevokeInvitationRequest();
+  virtual ~RevokeInvitationRequest();
+
+  RevokeInvitationRequest(const RevokeInvitationRequest& from);
+
+  inline RevokeInvitationRequest& operator=(const RevokeInvitationRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RevokeInvitationRequest& default_instance();
+
+  void Swap(RevokeInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  RevokeInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RevokeInvitationRequest& from);
+  void MergeFrom(const RevokeInvitationRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // optional fixed64 invitation_id = 2;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.RevokeInvitationRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static RevokeInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AcceptInvitationRequest : public ::google::protobuf::Message {
+ public:
+  AcceptInvitationRequest();
+  virtual ~AcceptInvitationRequest();
+
+  AcceptInvitationRequest(const AcceptInvitationRequest& from);
+
+  inline AcceptInvitationRequest& operator=(const AcceptInvitationRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AcceptInvitationRequest& default_instance();
+
+  void Swap(AcceptInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AcceptInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AcceptInvitationRequest& from);
+  void MergeFrom(const AcceptInvitationRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required fixed64 invitation_id = 3;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.friends.v1.AcceptInvitationOptions options = 4;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 4;
+  inline const ::bgs::protocol::friends::v1::AcceptInvitationOptions& options() const;
+  inline ::bgs::protocol::friends::v1::AcceptInvitationOptions* mutable_options();
+  inline ::bgs::protocol::friends::v1::AcceptInvitationOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::friends::v1::AcceptInvitationOptions* options);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.AcceptInvitationRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  ::bgs::protocol::friends::v1::AcceptInvitationOptions* options_;
+  friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AcceptInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API DeclineInvitationRequest : public ::google::protobuf::Message {
+ public:
+  DeclineInvitationRequest();
+  virtual ~DeclineInvitationRequest();
+
+  DeclineInvitationRequest(const DeclineInvitationRequest& from);
+
+  inline DeclineInvitationRequest& operator=(const DeclineInvitationRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DeclineInvitationRequest& default_instance();
+
+  void Swap(DeclineInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  DeclineInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DeclineInvitationRequest& from);
+  void MergeFrom(const DeclineInvitationRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required fixed64 invitation_id = 3;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.DeclineInvitationRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint64 invitation_id_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static GenericFriendRequest* default_instance_;
+  static DeclineInvitationRequest* default_instance_;
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API GenericFriendResponse : public ::google::protobuf::Message {
+class TC_PROTO_API IgnoreInvitationRequest : public ::google::protobuf::Message {
  public:
-  GenericFriendResponse();
-  virtual ~GenericFriendResponse();
+  IgnoreInvitationRequest();
+  virtual ~IgnoreInvitationRequest();
 
-  GenericFriendResponse(const GenericFriendResponse& from);
+  IgnoreInvitationRequest(const IgnoreInvitationRequest& from);
 
-  inline GenericFriendResponse& operator=(const GenericFriendResponse& from) {
+  inline IgnoreInvitationRequest& operator=(const IgnoreInvitationRequest& from) {
     CopyFrom(from);
     return *this;
   }
@@ -358,17 +685,17 @@ class TC_PROTO_API GenericFriendResponse : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const GenericFriendResponse& default_instance();
+  static const IgnoreInvitationRequest& default_instance();
 
-  void Swap(GenericFriendResponse* other);
+  void Swap(IgnoreInvitationRequest* other);
 
   // implements Message ----------------------------------------------
 
-  GenericFriendResponse* New() const;
+  IgnoreInvitationRequest* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GenericFriendResponse& from);
-  void MergeFrom(const GenericFriendResponse& from);
+  void CopyFrom(const IgnoreInvitationRequest& from);
+  void MergeFrom(const IgnoreInvitationRequest& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -390,42 +717,62 @@ class TC_PROTO_API GenericFriendResponse : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional .bgs.protocol.friends.v1.Friend target_friend = 1;
-  inline bool has_target_friend() const;
-  inline void clear_target_friend();
-  static const int kTargetFriendFieldNumber = 1;
-  inline const ::bgs::protocol::friends::v1::Friend& target_friend() const;
-  inline ::bgs::protocol::friends::v1::Friend* mutable_target_friend();
-  inline ::bgs::protocol::friends::v1::Friend* release_target_friend();
-  inline void set_allocated_target_friend(::bgs::protocol::friends::v1::Friend* target_friend);
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
 
-  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.GenericFriendResponse)
+  // required fixed64 invitation_id = 3;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // optional fixed32 program = 4;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 4;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.IgnoreInvitationRequest)
  private:
-  inline void set_has_target_friend();
-  inline void clear_has_target_friend();
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+  inline void set_has_program();
+  inline void clear_has_program();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::bgs::protocol::friends::v1::Friend* target_friend_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  ::google::protobuf::uint32 program_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static GenericFriendResponse* default_instance_;
+  static IgnoreInvitationRequest* default_instance_;
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API AssignRoleRequest : public ::google::protobuf::Message {
+class TC_PROTO_API RemoveFriendRequest : public ::google::protobuf::Message {
  public:
-  AssignRoleRequest();
-  virtual ~AssignRoleRequest();
+  RemoveFriendRequest();
+  virtual ~RemoveFriendRequest();
 
-  AssignRoleRequest(const AssignRoleRequest& from);
+  RemoveFriendRequest(const RemoveFriendRequest& from);
 
-  inline AssignRoleRequest& operator=(const AssignRoleRequest& from) {
+  inline RemoveFriendRequest& operator=(const RemoveFriendRequest& from) {
     CopyFrom(from);
     return *this;
   }
@@ -439,17 +786,17 @@ class TC_PROTO_API AssignRoleRequest : public ::google::protobuf::Message {
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const AssignRoleRequest& default_instance();
+  static const RemoveFriendRequest& default_instance();
 
-  void Swap(AssignRoleRequest* other);
+  void Swap(RemoveFriendRequest* other);
 
   // implements Message ----------------------------------------------
 
-  AssignRoleRequest* New() const;
+  RemoveFriendRequest* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AssignRoleRequest& from);
-  void MergeFrom(const AssignRoleRequest& from);
+  void CopyFrom(const RemoveFriendRequest& from);
+  void MergeFrom(const RemoveFriendRequest& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -489,19 +836,7 @@ class TC_PROTO_API AssignRoleRequest : public ::google::protobuf::Message {
   inline ::bgs::protocol::EntityId* release_target_id();
   inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
 
-  // repeated int32 role = 3;
-  inline int role_size() const;
-  inline void clear_role();
-  static const int kRoleFieldNumber = 3;
-  inline ::google::protobuf::int32 role(int index) const;
-  inline void set_role(int index, ::google::protobuf::int32 value);
-  inline void add_role(::google::protobuf::int32 value);
-  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
-      role() const;
-  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
-      mutable_role();
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.AssignRoleRequest)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.RemoveFriendRequest)
  private:
   inline void set_has_agent_id();
   inline void clear_has_agent_id();
@@ -514,13 +849,93 @@ class TC_PROTO_API AssignRoleRequest : public ::google::protobuf::Message {
   mutable int _cached_size_;
   ::bgs::protocol::EntityId* agent_id_;
   ::bgs::protocol::EntityId* target_id_;
-  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > role_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static AssignRoleRequest* default_instance_;
+  static RemoveFriendRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RevokeAllInvitationsRequest : public ::google::protobuf::Message {
+ public:
+  RevokeAllInvitationsRequest();
+  virtual ~RevokeAllInvitationsRequest();
+
+  RevokeAllInvitationsRequest(const RevokeAllInvitationsRequest& from);
+
+  inline RevokeAllInvitationsRequest& operator=(const RevokeAllInvitationsRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RevokeAllInvitationsRequest& default_instance();
+
+  void Swap(RevokeAllInvitationsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  RevokeAllInvitationsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RevokeAllInvitationsRequest& from);
+  void MergeFrom(const RevokeAllInvitationsRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.EntityId agent_id = 2;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.RevokeAllInvitationsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static RevokeAllInvitationsRequest* default_instance_;
 };
 // -------------------------------------------------------------------
 
@@ -595,18 +1010,6 @@ class TC_PROTO_API ViewFriendsRequest : public ::google::protobuf::Message {
   inline ::bgs::protocol::EntityId* release_target_id();
   inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
 
-  // repeated uint32 role = 3 [packed = true];
-  inline int role_size() const;
-  inline void clear_role();
-  static const int kRoleFieldNumber = 3;
-  inline ::google::protobuf::uint32 role(int index) const;
-  inline void set_role(int index, ::google::protobuf::uint32 value);
-  inline void add_role(::google::protobuf::uint32 value);
-  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-      role() const;
-  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-      mutable_role();
-
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.ViewFriendsRequest)
  private:
   inline void set_has_agent_id();
@@ -620,8 +1023,6 @@ class TC_PROTO_API ViewFriendsRequest : public ::google::protobuf::Message {
   mutable int _cached_size_;
   ::bgs::protocol::EntityId* agent_id_;
   ::bgs::protocol::EntityId* target_id_;
-  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
-  mutable int _role_cached_byte_size_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
@@ -796,21 +1197,12 @@ class TC_PROTO_API UpdateFriendStateRequest : public ::google::protobuf::Message
   inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
       mutable_attribute();
 
-  // optional uint64 attributes_epoch = 4;
-  inline bool has_attributes_epoch() const;
-  inline void clear_attributes_epoch();
-  static const int kAttributesEpochFieldNumber = 4;
-  inline ::google::protobuf::uint64 attributes_epoch() const;
-  inline void set_attributes_epoch(::google::protobuf::uint64 value);
-
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.UpdateFriendStateRequest)
  private:
   inline void set_has_agent_id();
   inline void clear_has_agent_id();
   inline void set_has_target_id();
   inline void clear_has_target_id();
-  inline void set_has_attributes_epoch();
-  inline void clear_has_attributes_epoch();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -819,7 +1211,6 @@ class TC_PROTO_API UpdateFriendStateRequest : public ::google::protobuf::Message
   ::bgs::protocol::EntityId* agent_id_;
   ::bgs::protocol::EntityId* target_id_;
   ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
-  ::google::protobuf::uint64 attributes_epoch_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
@@ -882,37 +1273,25 @@ class TC_PROTO_API GetFriendListRequest : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional .bgs.protocol.EntityId agent_id = 1;
+  // optional .bgs.protocol.EntityId agent_id = 2;
   inline bool has_agent_id() const;
   inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
+  static const int kAgentIdFieldNumber = 2;
   inline const ::bgs::protocol::EntityId& agent_id() const;
   inline ::bgs::protocol::EntityId* mutable_agent_id();
   inline ::bgs::protocol::EntityId* release_agent_id();
   inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
 
-  // optional .bgs.protocol.EntityId target_id = 2;
-  inline bool has_target_id() const;
-  inline void clear_target_id();
-  static const int kTargetIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& target_id() const;
-  inline ::bgs::protocol::EntityId* mutable_target_id();
-  inline ::bgs::protocol::EntityId* release_target_id();
-  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
-
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.GetFriendListRequest)
  private:
   inline void set_has_agent_id();
   inline void clear_has_agent_id();
-  inline void set_has_target_id();
-  inline void clear_has_target_id();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
   ::bgs::protocol::EntityId* agent_id_;
-  ::bgs::protocol::EntityId* target_id_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
@@ -1057,23 +1436,23 @@ class TC_PROTO_API CreateFriendshipRequest : public ::google::protobuf::Message
 
   // accessors -------------------------------------------------------
 
-  // optional .bgs.protocol.EntityId inviter_id = 1;
-  inline bool has_inviter_id() const;
-  inline void clear_inviter_id();
-  static const int kInviterIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& inviter_id() const;
-  inline ::bgs::protocol::EntityId* mutable_inviter_id();
-  inline ::bgs::protocol::EntityId* release_inviter_id();
-  inline void set_allocated_inviter_id(::bgs::protocol::EntityId* inviter_id);
-
-  // optional .bgs.protocol.EntityId invitee_id = 2;
-  inline bool has_invitee_id() const;
-  inline void clear_invitee_id();
-  static const int kInviteeIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& invitee_id() const;
-  inline ::bgs::protocol::EntityId* mutable_invitee_id();
-  inline ::bgs::protocol::EntityId* release_invitee_id();
-  inline void set_allocated_invitee_id(::bgs::protocol::EntityId* invitee_id);
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // optional .bgs.protocol.EntityId target_id = 2;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
 
   // repeated uint32 role = 3 [packed = true];
   inline int role_size() const;
@@ -1089,17 +1468,17 @@ class TC_PROTO_API CreateFriendshipRequest : public ::google::protobuf::Message
 
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.CreateFriendshipRequest)
  private:
-  inline void set_has_inviter_id();
-  inline void clear_has_inviter_id();
-  inline void set_has_invitee_id();
-  inline void clear_has_invitee_id();
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::bgs::protocol::EntityId* inviter_id_;
-  ::bgs::protocol::EntityId* invitee_id_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* target_id_;
   ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
   mutable int _role_cached_byte_size_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
@@ -1173,24 +1552,6 @@ class TC_PROTO_API FriendNotification : public ::google::protobuf::Message {
   inline ::bgs::protocol::friends::v1::Friend* release_target();
   inline void set_allocated_target(::bgs::protocol::friends::v1::Friend* target);
 
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  inline bool has_game_account_id() const;
-  inline void clear_game_account_id();
-  static const int kGameAccountIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& game_account_id() const;
-  inline ::bgs::protocol::EntityId* mutable_game_account_id();
-  inline ::bgs::protocol::EntityId* release_game_account_id();
-  inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id);
-
-  // optional .bgs.protocol.ProcessId peer = 4;
-  inline bool has_peer() const;
-  inline void clear_peer();
-  static const int kPeerFieldNumber = 4;
-  inline const ::bgs::protocol::ProcessId& peer() const;
-  inline ::bgs::protocol::ProcessId* mutable_peer();
-  inline ::bgs::protocol::ProcessId* release_peer();
-  inline void set_allocated_peer(::bgs::protocol::ProcessId* peer);
-
   // optional .bgs.protocol.EntityId account_id = 5;
   inline bool has_account_id() const;
   inline void clear_account_id();
@@ -1200,25 +1561,31 @@ class TC_PROTO_API FriendNotification : public ::google::protobuf::Message {
   inline ::bgs::protocol::EntityId* release_account_id();
   inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
 
+  // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+  inline bool has_forward() const PROTOBUF_DEPRECATED;
+  inline void clear_forward() PROTOBUF_DEPRECATED;
+  static const int kForwardFieldNumber = 6;
+  inline const ::bgs::protocol::ObjectAddress& forward() const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* mutable_forward() PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* release_forward() PROTOBUF_DEPRECATED;
+  inline void set_allocated_forward(::bgs::protocol::ObjectAddress* forward) PROTOBUF_DEPRECATED;
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.FriendNotification)
  private:
   inline void set_has_target();
   inline void clear_has_target();
-  inline void set_has_game_account_id();
-  inline void clear_has_game_account_id();
-  inline void set_has_peer();
-  inline void clear_has_peer();
   inline void set_has_account_id();
   inline void clear_has_account_id();
+  inline void set_has_forward();
+  inline void clear_has_forward();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
   ::bgs::protocol::friends::v1::Friend* target_;
-  ::bgs::protocol::EntityId* game_account_id_;
-  ::bgs::protocol::ProcessId* peer_;
   ::bgs::protocol::EntityId* account_id_;
+  ::bgs::protocol::ObjectAddress* forward_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
@@ -1290,24 +1657,6 @@ class TC_PROTO_API UpdateFriendStateNotification : public ::google::protobuf::Me
   inline ::bgs::protocol::friends::v1::Friend* release_changed_friend();
   inline void set_allocated_changed_friend(::bgs::protocol::friends::v1::Friend* changed_friend);
 
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  inline bool has_game_account_id() const;
-  inline void clear_game_account_id();
-  static const int kGameAccountIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& game_account_id() const;
-  inline ::bgs::protocol::EntityId* mutable_game_account_id();
-  inline ::bgs::protocol::EntityId* release_game_account_id();
-  inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id);
-
-  // optional .bgs.protocol.ProcessId peer = 4;
-  inline bool has_peer() const;
-  inline void clear_peer();
-  static const int kPeerFieldNumber = 4;
-  inline const ::bgs::protocol::ProcessId& peer() const;
-  inline ::bgs::protocol::ProcessId* mutable_peer();
-  inline ::bgs::protocol::ProcessId* release_peer();
-  inline void set_allocated_peer(::bgs::protocol::ProcessId* peer);
-
   // optional .bgs.protocol.EntityId account_id = 5;
   inline bool has_account_id() const;
   inline void clear_account_id();
@@ -1317,25 +1666,31 @@ class TC_PROTO_API UpdateFriendStateNotification : public ::google::protobuf::Me
   inline ::bgs::protocol::EntityId* release_account_id();
   inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
 
+  // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+  inline bool has_forward() const PROTOBUF_DEPRECATED;
+  inline void clear_forward() PROTOBUF_DEPRECATED;
+  static const int kForwardFieldNumber = 6;
+  inline const ::bgs::protocol::ObjectAddress& forward() const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* mutable_forward() PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* release_forward() PROTOBUF_DEPRECATED;
+  inline void set_allocated_forward(::bgs::protocol::ObjectAddress* forward) PROTOBUF_DEPRECATED;
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.UpdateFriendStateNotification)
  private:
   inline void set_has_changed_friend();
   inline void clear_has_changed_friend();
-  inline void set_has_game_account_id();
-  inline void clear_has_game_account_id();
-  inline void set_has_peer();
-  inline void clear_has_peer();
   inline void set_has_account_id();
   inline void clear_has_account_id();
+  inline void set_has_forward();
+  inline void clear_has_forward();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
   ::bgs::protocol::friends::v1::Friend* changed_friend_;
-  ::bgs::protocol::EntityId* game_account_id_;
-  ::bgs::protocol::ProcessId* peer_;
   ::bgs::protocol::EntityId* account_id_;
+  ::bgs::protocol::ObjectAddress* forward_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
   friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
@@ -1398,23 +1753,14 @@ class TC_PROTO_API InvitationNotification : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // required .bgs.protocol.Invitation invitation = 1;
+  // required .bgs.protocol.friends.v1.ReceivedInvitation invitation = 1;
   inline bool has_invitation() const;
   inline void clear_invitation();
   static const int kInvitationFieldNumber = 1;
-  inline const ::bgs::protocol::Invitation& invitation() const;
-  inline ::bgs::protocol::Invitation* mutable_invitation();
-  inline ::bgs::protocol::Invitation* release_invitation();
-  inline void set_allocated_invitation(::bgs::protocol::Invitation* invitation);
-
-  // optional .bgs.protocol.EntityId game_account_id = 2;
-  inline bool has_game_account_id() const;
-  inline void clear_game_account_id();
-  static const int kGameAccountIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& game_account_id() const;
-  inline ::bgs::protocol::EntityId* mutable_game_account_id();
-  inline ::bgs::protocol::EntityId* release_game_account_id();
-  inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id);
+  inline const ::bgs::protocol::friends::v1::ReceivedInvitation& invitation() const;
+  inline ::bgs::protocol::friends::v1::ReceivedInvitation* mutable_invitation();
+  inline ::bgs::protocol::friends::v1::ReceivedInvitation* release_invitation();
+  inline void set_allocated_invitation(::bgs::protocol::friends::v1::ReceivedInvitation* invitation);
 
   // optional uint32 reason = 3 [default = 0];
   inline bool has_reason() const;
@@ -1423,15 +1769,6 @@ class TC_PROTO_API InvitationNotification : public ::google::protobuf::Message {
   inline ::google::protobuf::uint32 reason() const;
   inline void set_reason(::google::protobuf::uint32 value);
 
-  // optional .bgs.protocol.ProcessId peer = 4;
-  inline bool has_peer() const;
-  inline void clear_peer();
-  static const int kPeerFieldNumber = 4;
-  inline const ::bgs::protocol::ProcessId& peer() const;
-  inline ::bgs::protocol::ProcessId* mutable_peer();
-  inline ::bgs::protocol::ProcessId* release_peer();
-  inline void set_allocated_peer(::bgs::protocol::ProcessId* peer);
-
   // optional .bgs.protocol.EntityId account_id = 5;
   inline bool has_account_id() const;
   inline void clear_account_id();
@@ -1441,27 +1778,33 @@ class TC_PROTO_API InvitationNotification : public ::google::protobuf::Message {
   inline ::bgs::protocol::EntityId* release_account_id();
   inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
 
+  // optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+  inline bool has_forward() const PROTOBUF_DEPRECATED;
+  inline void clear_forward() PROTOBUF_DEPRECATED;
+  static const int kForwardFieldNumber = 6;
+  inline const ::bgs::protocol::ObjectAddress& forward() const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* mutable_forward() PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* release_forward() PROTOBUF_DEPRECATED;
+  inline void set_allocated_forward(::bgs::protocol::ObjectAddress* forward) PROTOBUF_DEPRECATED;
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.InvitationNotification)
  private:
   inline void set_has_invitation();
   inline void clear_has_invitation();
-  inline void set_has_game_account_id();
-  inline void clear_has_game_account_id();
   inline void set_has_reason();
   inline void clear_has_reason();
-  inline void set_has_peer();
-  inline void clear_has_peer();
   inline void set_has_account_id();
   inline void clear_has_account_id();
+  inline void set_has_forward();
+  inline void clear_has_forward();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::bgs::protocol::Invitation* invitation_;
-  ::bgs::protocol::EntityId* game_account_id_;
-  ::bgs::protocol::ProcessId* peer_;
+  ::bgs::protocol::friends::v1::ReceivedInvitation* invitation_;
   ::bgs::protocol::EntityId* account_id_;
+  ::bgs::protocol::ObjectAddress* forward_;
   ::google::protobuf::uint32 reason_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
   friend void protobuf_AssignDesc_friends_5fservice_2eproto();
@@ -1470,6 +1813,224 @@ class TC_PROTO_API InvitationNotification : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static InvitationNotification* default_instance_;
 };
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SentInvitationAddedNotification : public ::google::protobuf::Message {
+ public:
+  SentInvitationAddedNotification();
+  virtual ~SentInvitationAddedNotification();
+
+  SentInvitationAddedNotification(const SentInvitationAddedNotification& from);
+
+  inline SentInvitationAddedNotification& operator=(const SentInvitationAddedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SentInvitationAddedNotification& default_instance();
+
+  void Swap(SentInvitationAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SentInvitationAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SentInvitationAddedNotification& from);
+  void MergeFrom(const SentInvitationAddedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.EntityId account_id = 1;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& account_id() const;
+  inline ::bgs::protocol::EntityId* mutable_account_id();
+  inline ::bgs::protocol::EntityId* release_account_id();
+  inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
+
+  // optional .bgs.protocol.friends.v1.SentInvitation invitation = 2;
+  inline bool has_invitation() const;
+  inline void clear_invitation();
+  static const int kInvitationFieldNumber = 2;
+  inline const ::bgs::protocol::friends::v1::SentInvitation& invitation() const;
+  inline ::bgs::protocol::friends::v1::SentInvitation* mutable_invitation();
+  inline ::bgs::protocol::friends::v1::SentInvitation* release_invitation();
+  inline void set_allocated_invitation(::bgs::protocol::friends::v1::SentInvitation* invitation);
+
+  // optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+  inline bool has_forward() const PROTOBUF_DEPRECATED;
+  inline void clear_forward() PROTOBUF_DEPRECATED;
+  static const int kForwardFieldNumber = 3;
+  inline const ::bgs::protocol::ObjectAddress& forward() const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* mutable_forward() PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* release_forward() PROTOBUF_DEPRECATED;
+  inline void set_allocated_forward(::bgs::protocol::ObjectAddress* forward) PROTOBUF_DEPRECATED;
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SentInvitationAddedNotification)
+ private:
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+  inline void set_has_invitation();
+  inline void clear_has_invitation();
+  inline void set_has_forward();
+  inline void clear_has_forward();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* account_id_;
+  ::bgs::protocol::friends::v1::SentInvitation* invitation_;
+  ::bgs::protocol::ObjectAddress* forward_;
+  friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SentInvitationAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SentInvitationRemovedNotification : public ::google::protobuf::Message {
+ public:
+  SentInvitationRemovedNotification();
+  virtual ~SentInvitationRemovedNotification();
+
+  SentInvitationRemovedNotification(const SentInvitationRemovedNotification& from);
+
+  inline SentInvitationRemovedNotification& operator=(const SentInvitationRemovedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SentInvitationRemovedNotification& default_instance();
+
+  void Swap(SentInvitationRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SentInvitationRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SentInvitationRemovedNotification& from);
+  void MergeFrom(const SentInvitationRemovedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.EntityId account_id = 1;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& account_id() const;
+  inline ::bgs::protocol::EntityId* mutable_account_id();
+  inline ::bgs::protocol::EntityId* release_account_id();
+  inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
+
+  // optional fixed64 invitation_id = 2;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // optional uint32 reason = 3;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 3;
+  inline ::google::protobuf::uint32 reason() const;
+  inline void set_reason(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.ObjectAddress forward = 4 [deprecated = true];
+  inline bool has_forward() const PROTOBUF_DEPRECATED;
+  inline void clear_forward() PROTOBUF_DEPRECATED;
+  static const int kForwardFieldNumber = 4;
+  inline const ::bgs::protocol::ObjectAddress& forward() const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* mutable_forward() PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::ObjectAddress* release_forward() PROTOBUF_DEPRECATED;
+  inline void set_allocated_forward(::bgs::protocol::ObjectAddress* forward) PROTOBUF_DEPRECATED;
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SentInvitationRemovedNotification)
+ private:
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+  inline void set_has_forward();
+  inline void clear_has_forward();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* account_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  ::bgs::protocol::ObjectAddress* forward_;
+  ::google::protobuf::uint32 reason_;
+  friend void TC_PROTO_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SentInvitationRemovedNotification* default_instance_;
+};
 // ===================================================================
 
 class TC_PROTO_API FriendsService : public ServiceBase
@@ -1487,17 +2048,16 @@ class TC_PROTO_API FriendsService : public ServiceBase
   // client methods --------------------------------------------------
 
   void Subscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, std::function<void(::bgs::protocol::friends::v1::SubscribeResponse const*)> responseCallback);
-  void SendInvitation(::bgs::protocol::SendInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void AcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void RevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void DeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void IgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void AssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void RemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function<void(::bgs::protocol::friends::v1::GenericFriendResponse const*)> responseCallback);
+  void SendInvitation(::bgs::protocol::friends::v1::SendInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void AcceptInvitation(::bgs::protocol::friends::v1::AcceptInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void RevokeInvitation(::bgs::protocol::friends::v1::RevokeInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void DeclineInvitation(::bgs::protocol::friends::v1::DeclineInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void IgnoreInvitation(::bgs::protocol::friends::v1::IgnoreInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void RemoveFriend(::bgs::protocol::friends::v1::RemoveFriendRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void ViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, std::function<void(::bgs::protocol::friends::v1::ViewFriendsResponse const*)> responseCallback);
   void UpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void Unsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void RevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void RevokeAllInvitations(::bgs::protocol::friends::v1::RevokeAllInvitationsRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void GetFriendList(::bgs::protocol::friends::v1::GetFriendListRequest const* request, std::function<void(::bgs::protocol::friends::v1::GetFriendListResponse const*)> responseCallback);
   void CreateFriendship(::bgs::protocol::friends::v1::CreateFriendshipRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   // server methods --------------------------------------------------
@@ -1506,17 +2066,16 @@ class TC_PROTO_API FriendsService : public ServiceBase
 
  protected:
   virtual uint32 HandleSubscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, ::bgs::protocol::friends::v1::SubscribeResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleSendInvitation(::bgs::protocol::SendInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleAcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleRevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleDeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleIgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleAssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleRemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::friends::v1::GenericFriendResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleSendInvitation(::bgs::protocol::friends::v1::SendInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleAcceptInvitation(::bgs::protocol::friends::v1::AcceptInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleRevokeInvitation(::bgs::protocol::friends::v1::RevokeInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleDeclineInvitation(::bgs::protocol::friends::v1::DeclineInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleIgnoreInvitation(::bgs::protocol::friends::v1::IgnoreInvitationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleRemoveFriend(::bgs::protocol::friends::v1::RemoveFriendRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, ::bgs::protocol::friends::v1::ViewFriendsResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleUnsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleRevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleRevokeAllInvitations(::bgs::protocol::friends::v1::RevokeAllInvitationsRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleGetFriendList(::bgs::protocol::friends::v1::GetFriendListRequest const* request, ::bgs::protocol::friends::v1::GetFriendListResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleCreateFriendship(::bgs::protocol::friends::v1::CreateFriendshipRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
 
@@ -1546,8 +2105,8 @@ class TC_PROTO_API FriendsListener : public ServiceBase
   void OnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request);
   void OnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request);
   void OnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request);
-  void OnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request);
-  void OnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  void OnSentInvitationAdded(::bgs::protocol::friends::v1::SentInvitationAddedNotification const* request);
+  void OnSentInvitationRemoved(::bgs::protocol::friends::v1::SentInvitationRemovedNotification const* request);
   void OnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request);
   // server methods --------------------------------------------------
 
@@ -1558,8 +2117,8 @@ class TC_PROTO_API FriendsListener : public ServiceBase
   virtual uint32 HandleOnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request);
   virtual uint32 HandleOnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request);
   virtual uint32 HandleOnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request);
-  virtual uint32 HandleOnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request);
-  virtual uint32 HandleOnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  virtual uint32 HandleOnSentInvitationAdded(::bgs::protocol::friends::v1::SentInvitationAddedNotification const* request);
+  virtual uint32 HandleOnSentInvitationRemoved(::bgs::protocol::friends::v1::SentInvitationRemovedNotification const* request);
   virtual uint32 HandleOnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request);
 
  private:
@@ -1640,6 +2199,47 @@ inline void SubscribeRequest::set_object_id(::google::protobuf::uint64 value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SubscribeRequest.object_id)
 }
 
+// optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+inline bool SubscribeRequest::has_forward() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SubscribeRequest::set_has_forward() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SubscribeRequest::clear_has_forward() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SubscribeRequest::clear_forward() {
+  if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+  clear_has_forward();
+}
+inline const ::bgs::protocol::ObjectAddress& SubscribeRequest::forward() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeRequest.forward)
+  return forward_ != NULL ? *forward_ : *default_instance_->forward_;
+}
+inline ::bgs::protocol::ObjectAddress* SubscribeRequest::mutable_forward() {
+  set_has_forward();
+  if (forward_ == NULL) forward_ = new ::bgs::protocol::ObjectAddress;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeRequest.forward)
+  return forward_;
+}
+inline ::bgs::protocol::ObjectAddress* SubscribeRequest::release_forward() {
+  clear_has_forward();
+  ::bgs::protocol::ObjectAddress* temp = forward_;
+  forward_ = NULL;
+  return temp;
+}
+inline void SubscribeRequest::set_allocated_forward(::bgs::protocol::ObjectAddress* forward) {
+  delete forward_;
+  forward_ = forward;
+  if (forward) {
+    set_has_forward();
+  } else {
+    clear_has_forward();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SubscribeRequest.forward)
+}
+
 // -------------------------------------------------------------------
 
 // UnsubscribeRequest
@@ -1709,82 +2309,123 @@ inline void UnsubscribeRequest::set_object_id(::google::protobuf::uint64 value)
   // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.UnsubscribeRequest.object_id)
 }
 
+// optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+inline bool UnsubscribeRequest::has_forward() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UnsubscribeRequest::set_has_forward() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UnsubscribeRequest::clear_has_forward() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UnsubscribeRequest::clear_forward() {
+  if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+  clear_has_forward();
+}
+inline const ::bgs::protocol::ObjectAddress& UnsubscribeRequest::forward() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UnsubscribeRequest.forward)
+  return forward_ != NULL ? *forward_ : *default_instance_->forward_;
+}
+inline ::bgs::protocol::ObjectAddress* UnsubscribeRequest::mutable_forward() {
+  set_has_forward();
+  if (forward_ == NULL) forward_ = new ::bgs::protocol::ObjectAddress;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UnsubscribeRequest.forward)
+  return forward_;
+}
+inline ::bgs::protocol::ObjectAddress* UnsubscribeRequest::release_forward() {
+  clear_has_forward();
+  ::bgs::protocol::ObjectAddress* temp = forward_;
+  forward_ = NULL;
+  return temp;
+}
+inline void UnsubscribeRequest::set_allocated_forward(::bgs::protocol::ObjectAddress* forward) {
+  delete forward_;
+  forward_ = forward;
+  if (forward) {
+    set_has_forward();
+  } else {
+    clear_has_forward();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UnsubscribeRequest.forward)
+}
+
 // -------------------------------------------------------------------
 
-// GenericFriendRequest
+// SendInvitationRequest
 
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool GenericFriendRequest::has_agent_id() const {
+// optional .bgs.protocol.Identity agent_identity = 1;
+inline bool SendInvitationRequest::has_agent_identity() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void GenericFriendRequest::set_has_agent_id() {
+inline void SendInvitationRequest::set_has_agent_identity() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void GenericFriendRequest::clear_has_agent_id() {
+inline void SendInvitationRequest::clear_has_agent_identity() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void GenericFriendRequest::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
+inline void SendInvitationRequest::clear_agent_identity() {
+  if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
+  clear_has_agent_identity();
 }
-inline const ::bgs::protocol::EntityId& GenericFriendRequest::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GenericFriendRequest.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+inline const ::bgs::protocol::Identity& SendInvitationRequest::agent_identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SendInvitationRequest.agent_identity)
+  return agent_identity_ != NULL ? *agent_identity_ : *default_instance_->agent_identity_;
 }
-inline ::bgs::protocol::EntityId* GenericFriendRequest::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GenericFriendRequest.agent_id)
-  return agent_id_;
+inline ::bgs::protocol::Identity* SendInvitationRequest::mutable_agent_identity() {
+  set_has_agent_identity();
+  if (agent_identity_ == NULL) agent_identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SendInvitationRequest.agent_identity)
+  return agent_identity_;
 }
-inline ::bgs::protocol::EntityId* GenericFriendRequest::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
+inline ::bgs::protocol::Identity* SendInvitationRequest::release_agent_identity() {
+  clear_has_agent_identity();
+  ::bgs::protocol::Identity* temp = agent_identity_;
+  agent_identity_ = NULL;
   return temp;
 }
-inline void GenericFriendRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
+inline void SendInvitationRequest::set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity) {
+  delete agent_identity_;
+  agent_identity_ = agent_identity;
+  if (agent_identity) {
+    set_has_agent_identity();
   } else {
-    clear_has_agent_id();
+    clear_has_agent_identity();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GenericFriendRequest.agent_id)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SendInvitationRequest.agent_identity)
 }
 
 // required .bgs.protocol.EntityId target_id = 2;
-inline bool GenericFriendRequest::has_target_id() const {
+inline bool SendInvitationRequest::has_target_id() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline void GenericFriendRequest::set_has_target_id() {
+inline void SendInvitationRequest::set_has_target_id() {
   _has_bits_[0] |= 0x00000002u;
 }
-inline void GenericFriendRequest::clear_has_target_id() {
+inline void SendInvitationRequest::clear_has_target_id() {
   _has_bits_[0] &= ~0x00000002u;
 }
-inline void GenericFriendRequest::clear_target_id() {
+inline void SendInvitationRequest::clear_target_id() {
   if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
   clear_has_target_id();
 }
-inline const ::bgs::protocol::EntityId& GenericFriendRequest::target_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GenericFriendRequest.target_id)
+inline const ::bgs::protocol::EntityId& SendInvitationRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SendInvitationRequest.target_id)
   return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
 }
-inline ::bgs::protocol::EntityId* GenericFriendRequest::mutable_target_id() {
+inline ::bgs::protocol::EntityId* SendInvitationRequest::mutable_target_id() {
   set_has_target_id();
   if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GenericFriendRequest.target_id)
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SendInvitationRequest.target_id)
   return target_id_;
 }
-inline ::bgs::protocol::EntityId* GenericFriendRequest::release_target_id() {
+inline ::bgs::protocol::EntityId* SendInvitationRequest::release_target_id() {
   clear_has_target_id();
   ::bgs::protocol::EntityId* temp = target_id_;
   target_id_ = NULL;
   return temp;
 }
-inline void GenericFriendRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+inline void SendInvitationRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
   delete target_id_;
   target_id_ = target_id;
   if (target_id) {
@@ -1792,89 +2433,426 @@ inline void GenericFriendRequest::set_allocated_target_id(::bgs::protocol::Entit
   } else {
     clear_has_target_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GenericFriendRequest.target_id)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SendInvitationRequest.target_id)
+}
+
+// required .bgs.protocol.InvitationParams params = 3;
+inline bool SendInvitationRequest::has_params() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SendInvitationRequest::set_has_params() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SendInvitationRequest::clear_has_params() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SendInvitationRequest::clear_params() {
+  if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
+  clear_has_params();
+}
+inline const ::bgs::protocol::InvitationParams& SendInvitationRequest::params() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SendInvitationRequest.params)
+  return params_ != NULL ? *params_ : *default_instance_->params_;
+}
+inline ::bgs::protocol::InvitationParams* SendInvitationRequest::mutable_params() {
+  set_has_params();
+  if (params_ == NULL) params_ = new ::bgs::protocol::InvitationParams;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SendInvitationRequest.params)
+  return params_;
+}
+inline ::bgs::protocol::InvitationParams* SendInvitationRequest::release_params() {
+  clear_has_params();
+  ::bgs::protocol::InvitationParams* temp = params_;
+  params_ = NULL;
+  return temp;
+}
+inline void SendInvitationRequest::set_allocated_params(::bgs::protocol::InvitationParams* params) {
+  delete params_;
+  params_ = params;
+  if (params) {
+    set_has_params();
+  } else {
+    clear_has_params();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SendInvitationRequest.params)
+}
+
+// -------------------------------------------------------------------
+
+// RevokeInvitationRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool RevokeInvitationRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RevokeInvitationRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RevokeInvitationRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RevokeInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& RevokeInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.RevokeInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* RevokeInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.RevokeInvitationRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* RevokeInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void RevokeInvitationRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.RevokeInvitationRequest.agent_id)
+}
+
+// optional fixed64 invitation_id = 2;
+inline bool RevokeInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RevokeInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RevokeInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RevokeInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 RevokeInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.RevokeInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void RevokeInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.RevokeInvitationRequest.invitation_id)
+}
+
+// -------------------------------------------------------------------
+
+// AcceptInvitationRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool AcceptInvitationRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AcceptInvitationRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AcceptInvitationRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AcceptInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& AcceptInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AcceptInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* AcceptInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.AcceptInvitationRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* AcceptInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AcceptInvitationRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.AcceptInvitationRequest.agent_id)
+}
+
+// required fixed64 invitation_id = 3;
+inline bool AcceptInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AcceptInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AcceptInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AcceptInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 AcceptInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AcceptInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void AcceptInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.AcceptInvitationRequest.invitation_id)
+}
+
+// optional .bgs.protocol.friends.v1.AcceptInvitationOptions options = 4;
+inline bool AcceptInvitationRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AcceptInvitationRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AcceptInvitationRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AcceptInvitationRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::friends::v1::AcceptInvitationOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::friends::v1::AcceptInvitationOptions& AcceptInvitationRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AcceptInvitationRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::friends::v1::AcceptInvitationOptions* AcceptInvitationRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::friends::v1::AcceptInvitationOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.AcceptInvitationRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::friends::v1::AcceptInvitationOptions* AcceptInvitationRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::friends::v1::AcceptInvitationOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void AcceptInvitationRequest::set_allocated_options(::bgs::protocol::friends::v1::AcceptInvitationOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.AcceptInvitationRequest.options)
 }
 
 // -------------------------------------------------------------------
 
-// GenericFriendResponse
+// DeclineInvitationRequest
 
-// optional .bgs.protocol.friends.v1.Friend target_friend = 1;
-inline bool GenericFriendResponse::has_target_friend() const {
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool DeclineInvitationRequest::has_agent_id() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void GenericFriendResponse::set_has_target_friend() {
+inline void DeclineInvitationRequest::set_has_agent_id() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void GenericFriendResponse::clear_has_target_friend() {
+inline void DeclineInvitationRequest::clear_has_agent_id() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void GenericFriendResponse::clear_target_friend() {
-  if (target_friend_ != NULL) target_friend_->::bgs::protocol::friends::v1::Friend::Clear();
-  clear_has_target_friend();
+inline void DeclineInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
 }
-inline const ::bgs::protocol::friends::v1::Friend& GenericFriendResponse::target_friend() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GenericFriendResponse.target_friend)
-  return target_friend_ != NULL ? *target_friend_ : *default_instance_->target_friend_;
+inline const ::bgs::protocol::EntityId& DeclineInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.DeclineInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
 }
-inline ::bgs::protocol::friends::v1::Friend* GenericFriendResponse::mutable_target_friend() {
-  set_has_target_friend();
-  if (target_friend_ == NULL) target_friend_ = new ::bgs::protocol::friends::v1::Friend;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GenericFriendResponse.target_friend)
-  return target_friend_;
+inline ::bgs::protocol::EntityId* DeclineInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.DeclineInvitationRequest.agent_id)
+  return agent_id_;
 }
-inline ::bgs::protocol::friends::v1::Friend* GenericFriendResponse::release_target_friend() {
-  clear_has_target_friend();
-  ::bgs::protocol::friends::v1::Friend* temp = target_friend_;
-  target_friend_ = NULL;
+inline ::bgs::protocol::EntityId* DeclineInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
   return temp;
 }
-inline void GenericFriendResponse::set_allocated_target_friend(::bgs::protocol::friends::v1::Friend* target_friend) {
-  delete target_friend_;
-  target_friend_ = target_friend;
-  if (target_friend) {
-    set_has_target_friend();
+inline void DeclineInvitationRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.DeclineInvitationRequest.agent_id)
+}
+
+// required fixed64 invitation_id = 3;
+inline bool DeclineInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DeclineInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DeclineInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DeclineInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 DeclineInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.DeclineInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void DeclineInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.DeclineInvitationRequest.invitation_id)
+}
+
+// -------------------------------------------------------------------
+
+// IgnoreInvitationRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool IgnoreInvitationRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void IgnoreInvitationRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void IgnoreInvitationRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void IgnoreInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& IgnoreInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.IgnoreInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* IgnoreInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.IgnoreInvitationRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* IgnoreInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void IgnoreInvitationRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
   } else {
-    clear_has_target_friend();
+    clear_has_agent_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GenericFriendResponse.target_friend)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.IgnoreInvitationRequest.agent_id)
+}
+
+// required fixed64 invitation_id = 3;
+inline bool IgnoreInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void IgnoreInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void IgnoreInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void IgnoreInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 IgnoreInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.IgnoreInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void IgnoreInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.IgnoreInvitationRequest.invitation_id)
+}
+
+// optional fixed32 program = 4;
+inline bool IgnoreInvitationRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void IgnoreInvitationRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void IgnoreInvitationRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void IgnoreInvitationRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 IgnoreInvitationRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.IgnoreInvitationRequest.program)
+  return program_;
+}
+inline void IgnoreInvitationRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.IgnoreInvitationRequest.program)
 }
 
 // -------------------------------------------------------------------
 
-// AssignRoleRequest
+// RemoveFriendRequest
 
 // optional .bgs.protocol.EntityId agent_id = 1;
-inline bool AssignRoleRequest::has_agent_id() const {
+inline bool RemoveFriendRequest::has_agent_id() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void AssignRoleRequest::set_has_agent_id() {
+inline void RemoveFriendRequest::set_has_agent_id() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void AssignRoleRequest::clear_has_agent_id() {
+inline void RemoveFriendRequest::clear_has_agent_id() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void AssignRoleRequest::clear_agent_id() {
+inline void RemoveFriendRequest::clear_agent_id() {
   if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
   clear_has_agent_id();
 }
-inline const ::bgs::protocol::EntityId& AssignRoleRequest::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AssignRoleRequest.agent_id)
+inline const ::bgs::protocol::EntityId& RemoveFriendRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.RemoveFriendRequest.agent_id)
   return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
 }
-inline ::bgs::protocol::EntityId* AssignRoleRequest::mutable_agent_id() {
+inline ::bgs::protocol::EntityId* RemoveFriendRequest::mutable_agent_id() {
   set_has_agent_id();
   if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.AssignRoleRequest.agent_id)
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.RemoveFriendRequest.agent_id)
   return agent_id_;
 }
-inline ::bgs::protocol::EntityId* AssignRoleRequest::release_agent_id() {
+inline ::bgs::protocol::EntityId* RemoveFriendRequest::release_agent_id() {
   clear_has_agent_id();
   ::bgs::protocol::EntityId* temp = agent_id_;
   agent_id_ = NULL;
   return temp;
 }
-inline void AssignRoleRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+inline void RemoveFriendRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
   delete agent_id_;
   agent_id_ = agent_id;
   if (agent_id) {
@@ -1882,40 +2860,40 @@ inline void AssignRoleRequest::set_allocated_agent_id(::bgs::protocol::EntityId*
   } else {
     clear_has_agent_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.AssignRoleRequest.agent_id)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.RemoveFriendRequest.agent_id)
 }
 
 // required .bgs.protocol.EntityId target_id = 2;
-inline bool AssignRoleRequest::has_target_id() const {
+inline bool RemoveFriendRequest::has_target_id() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline void AssignRoleRequest::set_has_target_id() {
+inline void RemoveFriendRequest::set_has_target_id() {
   _has_bits_[0] |= 0x00000002u;
 }
-inline void AssignRoleRequest::clear_has_target_id() {
+inline void RemoveFriendRequest::clear_has_target_id() {
   _has_bits_[0] &= ~0x00000002u;
 }
-inline void AssignRoleRequest::clear_target_id() {
+inline void RemoveFriendRequest::clear_target_id() {
   if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
   clear_has_target_id();
 }
-inline const ::bgs::protocol::EntityId& AssignRoleRequest::target_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AssignRoleRequest.target_id)
+inline const ::bgs::protocol::EntityId& RemoveFriendRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.RemoveFriendRequest.target_id)
   return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
 }
-inline ::bgs::protocol::EntityId* AssignRoleRequest::mutable_target_id() {
+inline ::bgs::protocol::EntityId* RemoveFriendRequest::mutable_target_id() {
   set_has_target_id();
   if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.AssignRoleRequest.target_id)
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.RemoveFriendRequest.target_id)
   return target_id_;
 }
-inline ::bgs::protocol::EntityId* AssignRoleRequest::release_target_id() {
+inline ::bgs::protocol::EntityId* RemoveFriendRequest::release_target_id() {
   clear_has_target_id();
   ::bgs::protocol::EntityId* temp = target_id_;
   target_id_ = NULL;
   return temp;
 }
-inline void AssignRoleRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+inline void RemoveFriendRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
   delete target_id_;
   target_id_ = target_id;
   if (target_id) {
@@ -1923,37 +2901,52 @@ inline void AssignRoleRequest::set_allocated_target_id(::bgs::protocol::EntityId
   } else {
     clear_has_target_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.AssignRoleRequest.target_id)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.RemoveFriendRequest.target_id)
 }
 
-// repeated int32 role = 3;
-inline int AssignRoleRequest::role_size() const {
-  return role_.size();
+// -------------------------------------------------------------------
+
+// RevokeAllInvitationsRequest
+
+// optional .bgs.protocol.EntityId agent_id = 2;
+inline bool RevokeAllInvitationsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void AssignRoleRequest::clear_role() {
-  role_.Clear();
+inline void RevokeAllInvitationsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
 }
-inline ::google::protobuf::int32 AssignRoleRequest::role(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AssignRoleRequest.role)
-  return role_.Get(index);
+inline void RevokeAllInvitationsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
 }
-inline void AssignRoleRequest::set_role(int index, ::google::protobuf::int32 value) {
-  role_.Set(index, value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.AssignRoleRequest.role)
+inline void RevokeAllInvitationsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
 }
-inline void AssignRoleRequest::add_role(::google::protobuf::int32 value) {
-  role_.Add(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.AssignRoleRequest.role)
+inline const ::bgs::protocol::EntityId& RevokeAllInvitationsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.RevokeAllInvitationsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
 }
-inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
-AssignRoleRequest::role() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.AssignRoleRequest.role)
-  return role_;
+inline ::bgs::protocol::EntityId* RevokeAllInvitationsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.RevokeAllInvitationsRequest.agent_id)
+  return agent_id_;
 }
-inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
-AssignRoleRequest::mutable_role() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.AssignRoleRequest.role)
-  return &role_;
+inline ::bgs::protocol::EntityId* RevokeAllInvitationsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void RevokeAllInvitationsRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.RevokeAllInvitationsRequest.agent_id)
 }
 
 // -------------------------------------------------------------------
@@ -2042,36 +3035,6 @@ inline void ViewFriendsRequest::set_allocated_target_id(::bgs::protocol::EntityI
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ViewFriendsRequest.target_id)
 }
 
-// repeated uint32 role = 3 [packed = true];
-inline int ViewFriendsRequest::role_size() const {
-  return role_.size();
-}
-inline void ViewFriendsRequest::clear_role() {
-  role_.Clear();
-}
-inline ::google::protobuf::uint32 ViewFriendsRequest::role(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ViewFriendsRequest.role)
-  return role_.Get(index);
-}
-inline void ViewFriendsRequest::set_role(int index, ::google::protobuf::uint32 value) {
-  role_.Set(index, value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ViewFriendsRequest.role)
-}
-inline void ViewFriendsRequest::add_role(::google::protobuf::uint32 value) {
-  role_.Add(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.ViewFriendsRequest.role)
-}
-inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-ViewFriendsRequest::role() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.ViewFriendsRequest.role)
-  return role_;
-}
-inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-ViewFriendsRequest::mutable_role() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.ViewFriendsRequest.role)
-  return &role_;
-}
-
 // -------------------------------------------------------------------
 
 // ViewFriendsResponse
@@ -2222,35 +3185,11 @@ UpdateFriendStateRequest::mutable_attribute() {
   return &attribute_;
 }
 
-// optional uint64 attributes_epoch = 4;
-inline bool UpdateFriendStateRequest::has_attributes_epoch() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void UpdateFriendStateRequest::set_has_attributes_epoch() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void UpdateFriendStateRequest::clear_has_attributes_epoch() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void UpdateFriendStateRequest::clear_attributes_epoch() {
-  attributes_epoch_ = GOOGLE_ULONGLONG(0);
-  clear_has_attributes_epoch();
-}
-inline ::google::protobuf::uint64 UpdateFriendStateRequest::attributes_epoch() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateRequest.attributes_epoch)
-  return attributes_epoch_;
-}
-inline void UpdateFriendStateRequest::set_attributes_epoch(::google::protobuf::uint64 value) {
-  set_has_attributes_epoch();
-  attributes_epoch_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.UpdateFriendStateRequest.attributes_epoch)
-}
-
 // -------------------------------------------------------------------
 
 // GetFriendListRequest
 
-// optional .bgs.protocol.EntityId agent_id = 1;
+// optional .bgs.protocol.EntityId agent_id = 2;
 inline bool GetFriendListRequest::has_agent_id() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
@@ -2291,47 +3230,6 @@ inline void GetFriendListRequest::set_allocated_agent_id(::bgs::protocol::Entity
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GetFriendListRequest.agent_id)
 }
 
-// optional .bgs.protocol.EntityId target_id = 2;
-inline bool GetFriendListRequest::has_target_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void GetFriendListRequest::set_has_target_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void GetFriendListRequest::clear_has_target_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void GetFriendListRequest::clear_target_id() {
-  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_target_id();
-}
-inline const ::bgs::protocol::EntityId& GetFriendListRequest::target_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GetFriendListRequest.target_id)
-  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
-}
-inline ::bgs::protocol::EntityId* GetFriendListRequest::mutable_target_id() {
-  set_has_target_id();
-  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GetFriendListRequest.target_id)
-  return target_id_;
-}
-inline ::bgs::protocol::EntityId* GetFriendListRequest::release_target_id() {
-  clear_has_target_id();
-  ::bgs::protocol::EntityId* temp = target_id_;
-  target_id_ = NULL;
-  return temp;
-}
-inline void GetFriendListRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
-  delete target_id_;
-  target_id_ = target_id;
-  if (target_id) {
-    set_has_target_id();
-  } else {
-    clear_has_target_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GetFriendListRequest.target_id)
-}
-
 // -------------------------------------------------------------------
 
 // GetFriendListResponse
@@ -2370,86 +3268,86 @@ GetFriendListResponse::mutable_friends() {
 
 // CreateFriendshipRequest
 
-// optional .bgs.protocol.EntityId inviter_id = 1;
-inline bool CreateFriendshipRequest::has_inviter_id() const {
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool CreateFriendshipRequest::has_agent_id() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void CreateFriendshipRequest::set_has_inviter_id() {
+inline void CreateFriendshipRequest::set_has_agent_id() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void CreateFriendshipRequest::clear_has_inviter_id() {
+inline void CreateFriendshipRequest::clear_has_agent_id() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void CreateFriendshipRequest::clear_inviter_id() {
-  if (inviter_id_ != NULL) inviter_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_inviter_id();
+inline void CreateFriendshipRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
 }
-inline const ::bgs::protocol::EntityId& CreateFriendshipRequest::inviter_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.CreateFriendshipRequest.inviter_id)
-  return inviter_id_ != NULL ? *inviter_id_ : *default_instance_->inviter_id_;
+inline const ::bgs::protocol::EntityId& CreateFriendshipRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.CreateFriendshipRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
 }
-inline ::bgs::protocol::EntityId* CreateFriendshipRequest::mutable_inviter_id() {
-  set_has_inviter_id();
-  if (inviter_id_ == NULL) inviter_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.CreateFriendshipRequest.inviter_id)
-  return inviter_id_;
+inline ::bgs::protocol::EntityId* CreateFriendshipRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.CreateFriendshipRequest.agent_id)
+  return agent_id_;
 }
-inline ::bgs::protocol::EntityId* CreateFriendshipRequest::release_inviter_id() {
-  clear_has_inviter_id();
-  ::bgs::protocol::EntityId* temp = inviter_id_;
-  inviter_id_ = NULL;
+inline ::bgs::protocol::EntityId* CreateFriendshipRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
   return temp;
 }
-inline void CreateFriendshipRequest::set_allocated_inviter_id(::bgs::protocol::EntityId* inviter_id) {
-  delete inviter_id_;
-  inviter_id_ = inviter_id;
-  if (inviter_id) {
-    set_has_inviter_id();
+inline void CreateFriendshipRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
   } else {
-    clear_has_inviter_id();
+    clear_has_agent_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.CreateFriendshipRequest.inviter_id)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.CreateFriendshipRequest.agent_id)
 }
 
-// optional .bgs.protocol.EntityId invitee_id = 2;
-inline bool CreateFriendshipRequest::has_invitee_id() const {
+// optional .bgs.protocol.EntityId target_id = 2;
+inline bool CreateFriendshipRequest::has_target_id() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline void CreateFriendshipRequest::set_has_invitee_id() {
+inline void CreateFriendshipRequest::set_has_target_id() {
   _has_bits_[0] |= 0x00000002u;
 }
-inline void CreateFriendshipRequest::clear_has_invitee_id() {
+inline void CreateFriendshipRequest::clear_has_target_id() {
   _has_bits_[0] &= ~0x00000002u;
 }
-inline void CreateFriendshipRequest::clear_invitee_id() {
-  if (invitee_id_ != NULL) invitee_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_invitee_id();
+inline void CreateFriendshipRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
 }
-inline const ::bgs::protocol::EntityId& CreateFriendshipRequest::invitee_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.CreateFriendshipRequest.invitee_id)
-  return invitee_id_ != NULL ? *invitee_id_ : *default_instance_->invitee_id_;
+inline const ::bgs::protocol::EntityId& CreateFriendshipRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.CreateFriendshipRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
 }
-inline ::bgs::protocol::EntityId* CreateFriendshipRequest::mutable_invitee_id() {
-  set_has_invitee_id();
-  if (invitee_id_ == NULL) invitee_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.CreateFriendshipRequest.invitee_id)
-  return invitee_id_;
+inline ::bgs::protocol::EntityId* CreateFriendshipRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.CreateFriendshipRequest.target_id)
+  return target_id_;
 }
-inline ::bgs::protocol::EntityId* CreateFriendshipRequest::release_invitee_id() {
-  clear_has_invitee_id();
-  ::bgs::protocol::EntityId* temp = invitee_id_;
-  invitee_id_ = NULL;
+inline ::bgs::protocol::EntityId* CreateFriendshipRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
   return temp;
 }
-inline void CreateFriendshipRequest::set_allocated_invitee_id(::bgs::protocol::EntityId* invitee_id) {
-  delete invitee_id_;
-  invitee_id_ = invitee_id;
-  if (invitee_id) {
-    set_has_invitee_id();
+inline void CreateFriendshipRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
   } else {
-    clear_has_invitee_id();
+    clear_has_target_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.CreateFriendshipRequest.invitee_id)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.CreateFriendshipRequest.target_id)
 }
 
 // repeated uint32 role = 3 [packed = true];
@@ -2527,97 +3425,15 @@ inline void FriendNotification::set_allocated_target(::bgs::protocol::friends::v
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.target)
 }
 
-// optional .bgs.protocol.EntityId game_account_id = 2;
-inline bool FriendNotification::has_game_account_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void FriendNotification::set_has_game_account_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void FriendNotification::clear_has_game_account_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void FriendNotification::clear_game_account_id() {
-  if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_game_account_id();
-}
-inline const ::bgs::protocol::EntityId& FriendNotification::game_account_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.game_account_id)
-  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
-}
-inline ::bgs::protocol::EntityId* FriendNotification::mutable_game_account_id() {
-  set_has_game_account_id();
-  if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.game_account_id)
-  return game_account_id_;
-}
-inline ::bgs::protocol::EntityId* FriendNotification::release_game_account_id() {
-  clear_has_game_account_id();
-  ::bgs::protocol::EntityId* temp = game_account_id_;
-  game_account_id_ = NULL;
-  return temp;
-}
-inline void FriendNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) {
-  delete game_account_id_;
-  game_account_id_ = game_account_id;
-  if (game_account_id) {
-    set_has_game_account_id();
-  } else {
-    clear_has_game_account_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.game_account_id)
-}
-
-// optional .bgs.protocol.ProcessId peer = 4;
-inline bool FriendNotification::has_peer() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void FriendNotification::set_has_peer() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void FriendNotification::clear_has_peer() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void FriendNotification::clear_peer() {
-  if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
-  clear_has_peer();
-}
-inline const ::bgs::protocol::ProcessId& FriendNotification::peer() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.peer)
-  return peer_ != NULL ? *peer_ : *default_instance_->peer_;
-}
-inline ::bgs::protocol::ProcessId* FriendNotification::mutable_peer() {
-  set_has_peer();
-  if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.peer)
-  return peer_;
-}
-inline ::bgs::protocol::ProcessId* FriendNotification::release_peer() {
-  clear_has_peer();
-  ::bgs::protocol::ProcessId* temp = peer_;
-  peer_ = NULL;
-  return temp;
-}
-inline void FriendNotification::set_allocated_peer(::bgs::protocol::ProcessId* peer) {
-  delete peer_;
-  peer_ = peer;
-  if (peer) {
-    set_has_peer();
-  } else {
-    clear_has_peer();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.peer)
-}
-
 // optional .bgs.protocol.EntityId account_id = 5;
 inline bool FriendNotification::has_account_id() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
+  return (_has_bits_[0] & 0x00000002u) != 0;
 }
 inline void FriendNotification::set_has_account_id() {
-  _has_bits_[0] |= 0x00000008u;
+  _has_bits_[0] |= 0x00000002u;
 }
 inline void FriendNotification::clear_has_account_id() {
-  _has_bits_[0] &= ~0x00000008u;
+  _has_bits_[0] &= ~0x00000002u;
 }
 inline void FriendNotification::clear_account_id() {
   if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
@@ -2650,6 +3466,47 @@ inline void FriendNotification::set_allocated_account_id(::bgs::protocol::Entity
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.account_id)
 }
 
+// optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+inline bool FriendNotification::has_forward() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FriendNotification::set_has_forward() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FriendNotification::clear_has_forward() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FriendNotification::clear_forward() {
+  if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+  clear_has_forward();
+}
+inline const ::bgs::protocol::ObjectAddress& FriendNotification::forward() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.forward)
+  return forward_ != NULL ? *forward_ : *default_instance_->forward_;
+}
+inline ::bgs::protocol::ObjectAddress* FriendNotification::mutable_forward() {
+  set_has_forward();
+  if (forward_ == NULL) forward_ = new ::bgs::protocol::ObjectAddress;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.forward)
+  return forward_;
+}
+inline ::bgs::protocol::ObjectAddress* FriendNotification::release_forward() {
+  clear_has_forward();
+  ::bgs::protocol::ObjectAddress* temp = forward_;
+  forward_ = NULL;
+  return temp;
+}
+inline void FriendNotification::set_allocated_forward(::bgs::protocol::ObjectAddress* forward) {
+  delete forward_;
+  forward_ = forward;
+  if (forward) {
+    set_has_forward();
+  } else {
+    clear_has_forward();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.forward)
+}
+
 // -------------------------------------------------------------------
 
 // UpdateFriendStateNotification
@@ -2695,97 +3552,15 @@ inline void UpdateFriendStateNotification::set_allocated_changed_friend(::bgs::p
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.changed_friend)
 }
 
-// optional .bgs.protocol.EntityId game_account_id = 2;
-inline bool UpdateFriendStateNotification::has_game_account_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void UpdateFriendStateNotification::set_has_game_account_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void UpdateFriendStateNotification::clear_has_game_account_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void UpdateFriendStateNotification::clear_game_account_id() {
-  if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_game_account_id();
-}
-inline const ::bgs::protocol::EntityId& UpdateFriendStateNotification::game_account_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.game_account_id)
-  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::mutable_game_account_id() {
-  set_has_game_account_id();
-  if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.game_account_id)
-  return game_account_id_;
-}
-inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::release_game_account_id() {
-  clear_has_game_account_id();
-  ::bgs::protocol::EntityId* temp = game_account_id_;
-  game_account_id_ = NULL;
-  return temp;
-}
-inline void UpdateFriendStateNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) {
-  delete game_account_id_;
-  game_account_id_ = game_account_id;
-  if (game_account_id) {
-    set_has_game_account_id();
-  } else {
-    clear_has_game_account_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.game_account_id)
-}
-
-// optional .bgs.protocol.ProcessId peer = 4;
-inline bool UpdateFriendStateNotification::has_peer() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void UpdateFriendStateNotification::set_has_peer() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void UpdateFriendStateNotification::clear_has_peer() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void UpdateFriendStateNotification::clear_peer() {
-  if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
-  clear_has_peer();
-}
-inline const ::bgs::protocol::ProcessId& UpdateFriendStateNotification::peer() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.peer)
-  return peer_ != NULL ? *peer_ : *default_instance_->peer_;
-}
-inline ::bgs::protocol::ProcessId* UpdateFriendStateNotification::mutable_peer() {
-  set_has_peer();
-  if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.peer)
-  return peer_;
-}
-inline ::bgs::protocol::ProcessId* UpdateFriendStateNotification::release_peer() {
-  clear_has_peer();
-  ::bgs::protocol::ProcessId* temp = peer_;
-  peer_ = NULL;
-  return temp;
-}
-inline void UpdateFriendStateNotification::set_allocated_peer(::bgs::protocol::ProcessId* peer) {
-  delete peer_;
-  peer_ = peer;
-  if (peer) {
-    set_has_peer();
-  } else {
-    clear_has_peer();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.peer)
-}
-
 // optional .bgs.protocol.EntityId account_id = 5;
 inline bool UpdateFriendStateNotification::has_account_id() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
+  return (_has_bits_[0] & 0x00000002u) != 0;
 }
 inline void UpdateFriendStateNotification::set_has_account_id() {
-  _has_bits_[0] |= 0x00000008u;
+  _has_bits_[0] |= 0x00000002u;
 }
 inline void UpdateFriendStateNotification::clear_has_account_id() {
-  _has_bits_[0] &= ~0x00000008u;
+  _has_bits_[0] &= ~0x00000002u;
 }
 inline void UpdateFriendStateNotification::clear_account_id() {
   if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
@@ -2818,11 +3593,52 @@ inline void UpdateFriendStateNotification::set_allocated_account_id(::bgs::proto
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.account_id)
 }
 
+// optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+inline bool UpdateFriendStateNotification::has_forward() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateFriendStateNotification::set_has_forward() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateFriendStateNotification::clear_has_forward() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateFriendStateNotification::clear_forward() {
+  if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+  clear_has_forward();
+}
+inline const ::bgs::protocol::ObjectAddress& UpdateFriendStateNotification::forward() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.forward)
+  return forward_ != NULL ? *forward_ : *default_instance_->forward_;
+}
+inline ::bgs::protocol::ObjectAddress* UpdateFriendStateNotification::mutable_forward() {
+  set_has_forward();
+  if (forward_ == NULL) forward_ = new ::bgs::protocol::ObjectAddress;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.forward)
+  return forward_;
+}
+inline ::bgs::protocol::ObjectAddress* UpdateFriendStateNotification::release_forward() {
+  clear_has_forward();
+  ::bgs::protocol::ObjectAddress* temp = forward_;
+  forward_ = NULL;
+  return temp;
+}
+inline void UpdateFriendStateNotification::set_allocated_forward(::bgs::protocol::ObjectAddress* forward) {
+  delete forward_;
+  forward_ = forward;
+  if (forward) {
+    set_has_forward();
+  } else {
+    clear_has_forward();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.forward)
+}
+
 // -------------------------------------------------------------------
 
 // InvitationNotification
 
-// required .bgs.protocol.Invitation invitation = 1;
+// required .bgs.protocol.friends.v1.ReceivedInvitation invitation = 1;
 inline bool InvitationNotification::has_invitation() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
@@ -2833,26 +3649,26 @@ inline void InvitationNotification::clear_has_invitation() {
   _has_bits_[0] &= ~0x00000001u;
 }
 inline void InvitationNotification::clear_invitation() {
-  if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear();
+  if (invitation_ != NULL) invitation_->::bgs::protocol::friends::v1::ReceivedInvitation::Clear();
   clear_has_invitation();
 }
-inline const ::bgs::protocol::Invitation& InvitationNotification::invitation() const {
+inline const ::bgs::protocol::friends::v1::ReceivedInvitation& InvitationNotification::invitation() const {
   // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.invitation)
   return invitation_ != NULL ? *invitation_ : *default_instance_->invitation_;
 }
-inline ::bgs::protocol::Invitation* InvitationNotification::mutable_invitation() {
+inline ::bgs::protocol::friends::v1::ReceivedInvitation* InvitationNotification::mutable_invitation() {
   set_has_invitation();
-  if (invitation_ == NULL) invitation_ = new ::bgs::protocol::Invitation;
+  if (invitation_ == NULL) invitation_ = new ::bgs::protocol::friends::v1::ReceivedInvitation;
   // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.invitation)
   return invitation_;
 }
-inline ::bgs::protocol::Invitation* InvitationNotification::release_invitation() {
+inline ::bgs::protocol::friends::v1::ReceivedInvitation* InvitationNotification::release_invitation() {
   clear_has_invitation();
-  ::bgs::protocol::Invitation* temp = invitation_;
+  ::bgs::protocol::friends::v1::ReceivedInvitation* temp = invitation_;
   invitation_ = NULL;
   return temp;
 }
-inline void InvitationNotification::set_allocated_invitation(::bgs::protocol::Invitation* invitation) {
+inline void InvitationNotification::set_allocated_invitation(::bgs::protocol::friends::v1::ReceivedInvitation* invitation) {
   delete invitation_;
   invitation_ = invitation;
   if (invitation) {
@@ -2863,56 +3679,15 @@ inline void InvitationNotification::set_allocated_invitation(::bgs::protocol::In
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.invitation)
 }
 
-// optional .bgs.protocol.EntityId game_account_id = 2;
-inline bool InvitationNotification::has_game_account_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void InvitationNotification::set_has_game_account_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void InvitationNotification::clear_has_game_account_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void InvitationNotification::clear_game_account_id() {
-  if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_game_account_id();
-}
-inline const ::bgs::protocol::EntityId& InvitationNotification::game_account_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.game_account_id)
-  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
-}
-inline ::bgs::protocol::EntityId* InvitationNotification::mutable_game_account_id() {
-  set_has_game_account_id();
-  if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.game_account_id)
-  return game_account_id_;
-}
-inline ::bgs::protocol::EntityId* InvitationNotification::release_game_account_id() {
-  clear_has_game_account_id();
-  ::bgs::protocol::EntityId* temp = game_account_id_;
-  game_account_id_ = NULL;
-  return temp;
-}
-inline void InvitationNotification::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) {
-  delete game_account_id_;
-  game_account_id_ = game_account_id;
-  if (game_account_id) {
-    set_has_game_account_id();
-  } else {
-    clear_has_game_account_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.game_account_id)
-}
-
 // optional uint32 reason = 3 [default = 0];
 inline bool InvitationNotification::has_reason() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
+  return (_has_bits_[0] & 0x00000002u) != 0;
 }
 inline void InvitationNotification::set_has_reason() {
-  _has_bits_[0] |= 0x00000004u;
+  _has_bits_[0] |= 0x00000002u;
 }
 inline void InvitationNotification::clear_has_reason() {
-  _has_bits_[0] &= ~0x00000004u;
+  _has_bits_[0] &= ~0x00000002u;
 }
 inline void InvitationNotification::clear_reason() {
   reason_ = 0u;
@@ -2928,78 +3703,123 @@ inline void InvitationNotification::set_reason(::google::protobuf::uint32 value)
   // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.InvitationNotification.reason)
 }
 
-// optional .bgs.protocol.ProcessId peer = 4;
-inline bool InvitationNotification::has_peer() const {
+// optional .bgs.protocol.EntityId account_id = 5;
+inline bool InvitationNotification::has_account_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void InvitationNotification::set_has_account_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void InvitationNotification::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void InvitationNotification::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& InvitationNotification::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationNotification::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationNotification::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void InvitationNotification::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
+  delete account_id_;
+  account_id_ = account_id;
+  if (account_id) {
+    set_has_account_id();
+  } else {
+    clear_has_account_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.account_id)
+}
+
+// optional .bgs.protocol.ObjectAddress forward = 6 [deprecated = true];
+inline bool InvitationNotification::has_forward() const {
   return (_has_bits_[0] & 0x00000008u) != 0;
 }
-inline void InvitationNotification::set_has_peer() {
+inline void InvitationNotification::set_has_forward() {
   _has_bits_[0] |= 0x00000008u;
 }
-inline void InvitationNotification::clear_has_peer() {
+inline void InvitationNotification::clear_has_forward() {
   _has_bits_[0] &= ~0x00000008u;
 }
-inline void InvitationNotification::clear_peer() {
-  if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
-  clear_has_peer();
+inline void InvitationNotification::clear_forward() {
+  if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+  clear_has_forward();
 }
-inline const ::bgs::protocol::ProcessId& InvitationNotification::peer() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.peer)
-  return peer_ != NULL ? *peer_ : *default_instance_->peer_;
+inline const ::bgs::protocol::ObjectAddress& InvitationNotification::forward() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.forward)
+  return forward_ != NULL ? *forward_ : *default_instance_->forward_;
 }
-inline ::bgs::protocol::ProcessId* InvitationNotification::mutable_peer() {
-  set_has_peer();
-  if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.peer)
-  return peer_;
+inline ::bgs::protocol::ObjectAddress* InvitationNotification::mutable_forward() {
+  set_has_forward();
+  if (forward_ == NULL) forward_ = new ::bgs::protocol::ObjectAddress;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.forward)
+  return forward_;
 }
-inline ::bgs::protocol::ProcessId* InvitationNotification::release_peer() {
-  clear_has_peer();
-  ::bgs::protocol::ProcessId* temp = peer_;
-  peer_ = NULL;
+inline ::bgs::protocol::ObjectAddress* InvitationNotification::release_forward() {
+  clear_has_forward();
+  ::bgs::protocol::ObjectAddress* temp = forward_;
+  forward_ = NULL;
   return temp;
 }
-inline void InvitationNotification::set_allocated_peer(::bgs::protocol::ProcessId* peer) {
-  delete peer_;
-  peer_ = peer;
-  if (peer) {
-    set_has_peer();
+inline void InvitationNotification::set_allocated_forward(::bgs::protocol::ObjectAddress* forward) {
+  delete forward_;
+  forward_ = forward;
+  if (forward) {
+    set_has_forward();
   } else {
-    clear_has_peer();
+    clear_has_forward();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.peer)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.forward)
 }
 
-// optional .bgs.protocol.EntityId account_id = 5;
-inline bool InvitationNotification::has_account_id() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
+// -------------------------------------------------------------------
+
+// SentInvitationAddedNotification
+
+// optional .bgs.protocol.EntityId account_id = 1;
+inline bool SentInvitationAddedNotification::has_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void InvitationNotification::set_has_account_id() {
-  _has_bits_[0] |= 0x00000010u;
+inline void SentInvitationAddedNotification::set_has_account_id() {
+  _has_bits_[0] |= 0x00000001u;
 }
-inline void InvitationNotification::clear_has_account_id() {
-  _has_bits_[0] &= ~0x00000010u;
+inline void SentInvitationAddedNotification::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
 }
-inline void InvitationNotification::clear_account_id() {
+inline void SentInvitationAddedNotification::clear_account_id() {
   if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
   clear_has_account_id();
 }
-inline const ::bgs::protocol::EntityId& InvitationNotification::account_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.account_id)
+inline const ::bgs::protocol::EntityId& SentInvitationAddedNotification::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitationAddedNotification.account_id)
   return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
 }
-inline ::bgs::protocol::EntityId* InvitationNotification::mutable_account_id() {
+inline ::bgs::protocol::EntityId* SentInvitationAddedNotification::mutable_account_id() {
   set_has_account_id();
   if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.account_id)
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SentInvitationAddedNotification.account_id)
   return account_id_;
 }
-inline ::bgs::protocol::EntityId* InvitationNotification::release_account_id() {
+inline ::bgs::protocol::EntityId* SentInvitationAddedNotification::release_account_id() {
   clear_has_account_id();
   ::bgs::protocol::EntityId* temp = account_id_;
   account_id_ = NULL;
   return temp;
 }
-inline void InvitationNotification::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
+inline void SentInvitationAddedNotification::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
   delete account_id_;
   account_id_ = account_id;
   if (account_id) {
@@ -3007,7 +3827,223 @@ inline void InvitationNotification::set_allocated_account_id(::bgs::protocol::En
   } else {
     clear_has_account_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.account_id)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SentInvitationAddedNotification.account_id)
+}
+
+// optional .bgs.protocol.friends.v1.SentInvitation invitation = 2;
+inline bool SentInvitationAddedNotification::has_invitation() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SentInvitationAddedNotification::set_has_invitation() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SentInvitationAddedNotification::clear_has_invitation() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SentInvitationAddedNotification::clear_invitation() {
+  if (invitation_ != NULL) invitation_->::bgs::protocol::friends::v1::SentInvitation::Clear();
+  clear_has_invitation();
+}
+inline const ::bgs::protocol::friends::v1::SentInvitation& SentInvitationAddedNotification::invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitationAddedNotification.invitation)
+  return invitation_ != NULL ? *invitation_ : *default_instance_->invitation_;
+}
+inline ::bgs::protocol::friends::v1::SentInvitation* SentInvitationAddedNotification::mutable_invitation() {
+  set_has_invitation();
+  if (invitation_ == NULL) invitation_ = new ::bgs::protocol::friends::v1::SentInvitation;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SentInvitationAddedNotification.invitation)
+  return invitation_;
+}
+inline ::bgs::protocol::friends::v1::SentInvitation* SentInvitationAddedNotification::release_invitation() {
+  clear_has_invitation();
+  ::bgs::protocol::friends::v1::SentInvitation* temp = invitation_;
+  invitation_ = NULL;
+  return temp;
+}
+inline void SentInvitationAddedNotification::set_allocated_invitation(::bgs::protocol::friends::v1::SentInvitation* invitation) {
+  delete invitation_;
+  invitation_ = invitation;
+  if (invitation) {
+    set_has_invitation();
+  } else {
+    clear_has_invitation();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SentInvitationAddedNotification.invitation)
+}
+
+// optional .bgs.protocol.ObjectAddress forward = 3 [deprecated = true];
+inline bool SentInvitationAddedNotification::has_forward() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SentInvitationAddedNotification::set_has_forward() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SentInvitationAddedNotification::clear_has_forward() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SentInvitationAddedNotification::clear_forward() {
+  if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+  clear_has_forward();
+}
+inline const ::bgs::protocol::ObjectAddress& SentInvitationAddedNotification::forward() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitationAddedNotification.forward)
+  return forward_ != NULL ? *forward_ : *default_instance_->forward_;
+}
+inline ::bgs::protocol::ObjectAddress* SentInvitationAddedNotification::mutable_forward() {
+  set_has_forward();
+  if (forward_ == NULL) forward_ = new ::bgs::protocol::ObjectAddress;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SentInvitationAddedNotification.forward)
+  return forward_;
+}
+inline ::bgs::protocol::ObjectAddress* SentInvitationAddedNotification::release_forward() {
+  clear_has_forward();
+  ::bgs::protocol::ObjectAddress* temp = forward_;
+  forward_ = NULL;
+  return temp;
+}
+inline void SentInvitationAddedNotification::set_allocated_forward(::bgs::protocol::ObjectAddress* forward) {
+  delete forward_;
+  forward_ = forward;
+  if (forward) {
+    set_has_forward();
+  } else {
+    clear_has_forward();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SentInvitationAddedNotification.forward)
+}
+
+// -------------------------------------------------------------------
+
+// SentInvitationRemovedNotification
+
+// optional .bgs.protocol.EntityId account_id = 1;
+inline bool SentInvitationRemovedNotification::has_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SentInvitationRemovedNotification::set_has_account_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SentInvitationRemovedNotification::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SentInvitationRemovedNotification::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& SentInvitationRemovedNotification::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitationRemovedNotification.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* SentInvitationRemovedNotification::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SentInvitationRemovedNotification.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* SentInvitationRemovedNotification::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void SentInvitationRemovedNotification::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
+  delete account_id_;
+  account_id_ = account_id;
+  if (account_id) {
+    set_has_account_id();
+  } else {
+    clear_has_account_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SentInvitationRemovedNotification.account_id)
+}
+
+// optional fixed64 invitation_id = 2;
+inline bool SentInvitationRemovedNotification::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SentInvitationRemovedNotification::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SentInvitationRemovedNotification::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SentInvitationRemovedNotification::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 SentInvitationRemovedNotification::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitationRemovedNotification.invitation_id)
+  return invitation_id_;
+}
+inline void SentInvitationRemovedNotification::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SentInvitationRemovedNotification.invitation_id)
+}
+
+// optional uint32 reason = 3;
+inline bool SentInvitationRemovedNotification::has_reason() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SentInvitationRemovedNotification::set_has_reason() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SentInvitationRemovedNotification::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SentInvitationRemovedNotification::clear_reason() {
+  reason_ = 0u;
+  clear_has_reason();
+}
+inline ::google::protobuf::uint32 SentInvitationRemovedNotification::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitationRemovedNotification.reason)
+  return reason_;
+}
+inline void SentInvitationRemovedNotification::set_reason(::google::protobuf::uint32 value) {
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SentInvitationRemovedNotification.reason)
+}
+
+// optional .bgs.protocol.ObjectAddress forward = 4 [deprecated = true];
+inline bool SentInvitationRemovedNotification::has_forward() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SentInvitationRemovedNotification::set_has_forward() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SentInvitationRemovedNotification::clear_has_forward() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SentInvitationRemovedNotification::clear_forward() {
+  if (forward_ != NULL) forward_->::bgs::protocol::ObjectAddress::Clear();
+  clear_has_forward();
+}
+inline const ::bgs::protocol::ObjectAddress& SentInvitationRemovedNotification::forward() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitationRemovedNotification.forward)
+  return forward_ != NULL ? *forward_ : *default_instance_->forward_;
+}
+inline ::bgs::protocol::ObjectAddress* SentInvitationRemovedNotification::mutable_forward() {
+  set_has_forward();
+  if (forward_ == NULL) forward_ = new ::bgs::protocol::ObjectAddress;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SentInvitationRemovedNotification.forward)
+  return forward_;
+}
+inline ::bgs::protocol::ObjectAddress* SentInvitationRemovedNotification::release_forward() {
+  clear_has_forward();
+  ::bgs::protocol::ObjectAddress* temp = forward_;
+  forward_ = NULL;
+  return temp;
+}
+inline void SentInvitationRemovedNotification::set_allocated_forward(::bgs::protocol::ObjectAddress* forward) {
+  delete forward_;
+  forward_ = forward;
+  if (forward) {
+    set_has_forward();
+  } else {
+    clear_has_forward();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SentInvitationRemovedNotification.forward)
 }
 
 
diff --git a/src/server/proto/Client/friends_types.pb.cc b/src/server/proto/Client/friends_types.pb.cc
index 7c262f7cc3c..e47c3369e00 100644
--- a/src/server/proto/Client/friends_types.pb.cc
+++ b/src/server/proto/Client/friends_types.pb.cc
@@ -31,15 +31,24 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* FriendOfFriend_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   FriendOfFriend_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ReceivedInvitation_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ReceivedInvitation_reflection_ = NULL;
 const ::google::protobuf::Descriptor* FriendInvitation_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   FriendInvitation_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SentInvitation_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SentInvitation_reflection_ = NULL;
 const ::google::protobuf::Descriptor* FriendInvitationParams_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   FriendInvitationParams_reflection_ = NULL;
 const ::google::protobuf::Descriptor* SubscribeResponse_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   SubscribeResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AcceptInvitationOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AcceptInvitationOptions_reflection_ = NULL;
 
 }  // namespace
 
@@ -51,12 +60,13 @@ void protobuf_AssignDesc_friends_5ftypes_2eproto() {
       "friends_types.proto");
   GOOGLE_CHECK(file != NULL);
   Friend_descriptor_ = file->message_type(0);
-  static const int Friend_offsets_[5] = {
+  static const int Friend_offsets_[6] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, account_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, attribute_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, role_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, privileges_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, attributes_epoch_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, creation_time_),
   };
   Friend_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -70,12 +80,10 @@ void protobuf_AssignDesc_friends_5ftypes_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(Friend));
   FriendOfFriend_descriptor_ = file->message_type(1);
-  static const int FriendOfFriend_offsets_[7] = {
+  static const int FriendOfFriend_offsets_[5] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendOfFriend, account_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendOfFriend, attribute_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendOfFriend, role_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendOfFriend, privileges_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendOfFriend, attributes_epoch_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendOfFriend, full_name_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendOfFriend, battle_tag_),
   };
@@ -90,10 +98,33 @@ void protobuf_AssignDesc_friends_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(FriendOfFriend));
-  FriendInvitation_descriptor_ = file->message_type(2);
+  ReceivedInvitation_descriptor_ = file->message_type(2);
+  static const int ReceivedInvitation_offsets_[9] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, inviter_identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, invitee_identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, inviter_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, invitee_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, invitation_message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, creation_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, expiration_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, program_),
+  };
+  ReceivedInvitation_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ReceivedInvitation_descriptor_,
+      ReceivedInvitation::default_instance_,
+      ReceivedInvitation_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, _unknown_fields_),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReceivedInvitation, _extensions_),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ReceivedInvitation));
+  FriendInvitation_descriptor_ = file->message_type(3);
   static const int FriendInvitation_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, first_received_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, attribute_),
   };
   FriendInvitation_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -106,15 +137,34 @@ void protobuf_AssignDesc_friends_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(FriendInvitation));
-  FriendInvitationParams_descriptor_ = file->message_type(3);
-  static const int FriendInvitationParams_offsets_[7] = {
+  SentInvitation_descriptor_ = file->message_type(4);
+  static const int SentInvitation_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitation, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitation, target_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitation, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitation, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitation, creation_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitation, program_),
+  };
+  SentInvitation_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SentInvitation_descriptor_,
+      SentInvitation::default_instance_,
+      SentInvitation_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitation, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SentInvitation, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SentInvitation));
+  FriendInvitationParams_descriptor_ = file->message_type(5);
+  static const int FriendInvitationParams_offsets_[6] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, target_email_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, target_battle_tag_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, inviter_battle_tag_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, inviter_full_name_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, invitee_display_name_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, role_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, previous_role_deprecated_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, target_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, program_),
   };
   FriendInvitationParams_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -127,15 +177,15 @@ void protobuf_AssignDesc_friends_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(FriendInvitationParams));
-  SubscribeResponse_descriptor_ = file->message_type(4);
+  SubscribeResponse_descriptor_ = file->message_type(6);
   static const int SubscribeResponse_offsets_[7] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, max_friends_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, max_received_invitations_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, max_sent_invitations_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, role_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, friends_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, sent_invitations_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, received_invitations_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, sent_invitations_),
   };
   SubscribeResponse_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -148,6 +198,22 @@ void protobuf_AssignDesc_friends_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(SubscribeResponse));
+  AcceptInvitationOptions_descriptor_ = file->message_type(7);
+  static const int AcceptInvitationOptions_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationOptions, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationOptions, program_),
+  };
+  AcceptInvitationOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AcceptInvitationOptions_descriptor_,
+      AcceptInvitationOptions::default_instance_,
+      AcceptInvitationOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcceptInvitationOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AcceptInvitationOptions));
 }
 
 namespace {
@@ -165,11 +231,17 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     FriendOfFriend_descriptor_, &FriendOfFriend::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ReceivedInvitation_descriptor_, &ReceivedInvitation::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     FriendInvitation_descriptor_, &FriendInvitation::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SentInvitation_descriptor_, &SentInvitation::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     FriendInvitationParams_descriptor_, &FriendInvitationParams::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     SubscribeResponse_descriptor_, &SubscribeResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AcceptInvitationOptions_descriptor_, &AcceptInvitationOptions::default_instance());
 }
 
 }  // namespace
@@ -179,12 +251,18 @@ void protobuf_ShutdownFile_friends_5ftypes_2eproto() {
   delete Friend_reflection_;
   delete FriendOfFriend::default_instance_;
   delete FriendOfFriend_reflection_;
+  delete ReceivedInvitation::default_instance_;
+  delete ReceivedInvitation_reflection_;
   delete FriendInvitation::default_instance_;
   delete FriendInvitation_reflection_;
+  delete SentInvitation::default_instance_;
+  delete SentInvitation_reflection_;
   delete FriendInvitationParams::default_instance_;
   delete FriendInvitationParams_reflection_;
   delete SubscribeResponse::default_instance_;
   delete SubscribeResponse_reflection_;
+  delete AcceptInvitationOptions::default_instance_;
+  delete AcceptInvitationOptions_reflection_;
 }
 
 void protobuf_AddDesc_friends_5ftypes_2eproto() {
@@ -201,57 +279,75 @@ void protobuf_AddDesc_friends_5ftypes_2eproto() {
     "\n\023friends_types.proto\022\027bgs.protocol.frie"
     "nds.v1\032\025attribute_types.proto\032\022entity_ty"
     "pes.proto\032\026invitation_types.proto\032\020role_"
-    "types.proto\"\243\001\n\006Friend\022*\n\naccount_id\030\001 \002"
+    "types.proto\"\273\001\n\006Friend\022*\n\naccount_id\030\001 \002"
     "(\0132\026.bgs.protocol.EntityId\022*\n\tattribute\030"
     "\002 \003(\0132\027.bgs.protocol.Attribute\022\020\n\004role\030\003"
-    " \003(\rB\002\020\001\022\025\n\nprivileges\030\004 \001(\004:\0010\022\030\n\020attri"
-    "butes_epoch\030\005 \001(\004\"\322\001\n\016FriendOfFriend\022*\n\n"
-    "account_id\030\001 \001(\0132\026.bgs.protocol.EntityId"
-    "\022*\n\tattribute\030\002 \003(\0132\027.bgs.protocol.Attri"
-    "bute\022\020\n\004role\030\003 \003(\rB\002\020\001\022\025\n\nprivileges\030\004 \001"
-    "(\004:\0010\022\030\n\020attributes_epoch\030\005 \001(\004\022\021\n\tfull_"
-    "name\030\006 \001(\t\022\022\n\nbattle_tag\030\007 \001(\t\"\243\001\n\020Frien"
-    "dInvitation\022\035\n\016first_received\030\001 \001(\010:\005fal"
-    "se\022\020\n\004role\030\002 \003(\rB\002\020\0012^\n\021friend_invitatio"
-    "n\022\030.bgs.protocol.Invitation\030g \001(\0132).bgs."
-    "protocol.friends.v1.FriendInvitation\"\300\002\n"
-    "\026FriendInvitationParams\022\024\n\014target_email\030"
-    "\001 \001(\t\022\031\n\021target_battle_tag\030\002 \001(\t\022\032\n\022invi"
-    "ter_battle_tag\030\003 \001(\t\022\031\n\021inviter_full_nam"
-    "e\030\004 \001(\t\022\034\n\024invitee_display_name\030\005 \001(\t\022\020\n"
-    "\004role\030\006 \003(\rB\002\020\001\022&\n\030previous_role_depreca"
-    "ted\030\007 \003(\rB\004\020\001\030\0012f\n\rfriend_params\022\036.bgs.p"
-    "rotocol.InvitationParams\030g \001(\0132/.bgs.pro"
-    "tocol.friends.v1.FriendInvitationParams\""
-    "\250\002\n\021SubscribeResponse\022\023\n\013max_friends\030\001 \001"
-    "(\r\022 \n\030max_received_invitations\030\002 \001(\r\022\034\n\024"
-    "max_sent_invitations\030\003 \001(\r\022 \n\004role\030\004 \003(\013"
-    "2\022.bgs.protocol.Role\0220\n\007friends\030\005 \003(\0132\037."
-    "bgs.protocol.friends.v1.Friend\0222\n\020sent_i"
-    "nvitations\030\006 \003(\0132\030.bgs.protocol.Invitati"
-    "on\0226\n\024received_invitations\030\007 \003(\0132\030.bgs.p"
-    "rotocol.InvitationB/\n\030bnet.protocol.frie"
-    "nds.v1B\021FriendsTypesProtoH\001", 1347);
+    " \003(\rB\002\020\001\022\022\n\nprivileges\030\004 \001(\004\022\034\n\020attribut"
+    "es_epoch\030\005 \001(\004B\002\030\001\022\025\n\rcreation_time\030\006 \001("
+    "\004\"\211\001\n\016FriendOfFriend\022*\n\naccount_id\030\001 \001(\013"
+    "2\026.bgs.protocol.EntityId\022\020\n\004role\030\003 \003(\rB\002"
+    "\020\001\022\022\n\nprivileges\030\004 \001(\004\022\021\n\tfull_name\030\006 \001("
+    "\t\022\022\n\nbattle_tag\030\007 \001(\t\"\224\002\n\022ReceivedInvita"
+    "tion\022\n\n\002id\030\001 \002(\006\0220\n\020inviter_identity\030\002 \002"
+    "(\0132\026.bgs.protocol.Identity\0220\n\020invitee_id"
+    "entity\030\003 \002(\0132\026.bgs.protocol.Identity\022\024\n\014"
+    "inviter_name\030\004 \001(\t\022\024\n\014invitee_name\030\005 \001(\t"
+    "\022\032\n\022invitation_message\030\006 \001(\t\022\025\n\rcreation"
+    "_time\030\007 \001(\004\022\027\n\017expiration_time\030\010 \001(\004\022\017\n\007"
+    "program\030\t \001(\007*\005\010d\020\220N\"\303\001\n\020FriendInvitatio"
+    "n\022\020\n\004role\030\002 \003(\rB\002\020\001\022*\n\tattribute\030\003 \003(\0132\027"
+    ".bgs.protocol.Attribute2q\n\021friend_invita"
+    "tion\022+.bgs.protocol.friends.v1.ReceivedI"
+    "nvitation\030g \001(\0132).bgs.protocol.friends.v"
+    "1.FriendInvitation\"\223\001\n\016SentInvitation\022\n\n"
+    "\002id\030\001 \001(\006\022\023\n\013target_name\030\002 \001(\t\022\014\n\004role\030\003"
+    " \001(\r\022*\n\tattribute\030\004 \003(\0132\027.bgs.protocol.A"
+    "ttribute\022\025\n\rcreation_time\030\005 \001(\004\022\017\n\007progr"
+    "am\030\006 \001(\007\"\231\002\n\026FriendInvitationParams\022\024\n\014t"
+    "arget_email\030\001 \001(\t\022\031\n\021target_battle_tag\030\002"
+    " \001(\t\022\020\n\004role\030\006 \003(\rB\002\020\001\022*\n\tattribute\030\010 \003("
+    "\0132\027.bgs.protocol.Attribute\022\023\n\013target_nam"
+    "e\030\t \001(\t\022\023\n\007program\030\n \001(\007B\002\030\0012f\n\rfriend_p"
+    "arams\022\036.bgs.protocol.InvitationParams\030g "
+    "\001(\0132/.bgs.protocol.friends.v1.FriendInvi"
+    "tationParams\"\312\002\n\021SubscribeResponse\022\023\n\013ma"
+    "x_friends\030\001 \001(\r\022 \n\030max_received_invitati"
+    "ons\030\002 \001(\r\022\034\n\024max_sent_invitations\030\003 \001(\r\022"
+    " \n\004role\030\004 \003(\0132\022.bgs.protocol.Role\0220\n\007fri"
+    "ends\030\005 \003(\0132\037.bgs.protocol.friends.v1.Fri"
+    "end\022I\n\024received_invitations\030\007 \003(\0132+.bgs."
+    "protocol.friends.v1.ReceivedInvitation\022A"
+    "\n\020sent_invitations\030\010 \003(\0132\'.bgs.protocol."
+    "friends.v1.SentInvitation\"8\n\027AcceptInvit"
+    "ationOptions\022\014\n\004role\030\001 \001(\r\022\017\n\007program\030\002 "
+    "\001(\007B/\n\030bnet.protocol.friends.v1B\021Friends"
+    "TypesProtoH\001", 1812);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "friends_types.proto", &protobuf_RegisterTypes);
   Friend::default_instance_ = new Friend();
   FriendOfFriend::default_instance_ = new FriendOfFriend();
+  ReceivedInvitation::default_instance_ = new ReceivedInvitation();
   FriendInvitation::default_instance_ = new FriendInvitation();
+  SentInvitation::default_instance_ = new SentInvitation();
   FriendInvitationParams::default_instance_ = new FriendInvitationParams();
   SubscribeResponse::default_instance_ = new SubscribeResponse();
+  AcceptInvitationOptions::default_instance_ = new AcceptInvitationOptions();
   Friend::default_instance_->InitAsDefaultInstance();
   FriendOfFriend::default_instance_->InitAsDefaultInstance();
+  ReceivedInvitation::default_instance_->InitAsDefaultInstance();
   FriendInvitation::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
-    &::bgs::protocol::Invitation::default_instance(),
+    &::bgs::protocol::friends::v1::ReceivedInvitation::default_instance(),
     103, 11, false, false,
     &::bgs::protocol::friends::v1::FriendInvitation::default_instance());
+  SentInvitation::default_instance_->InitAsDefaultInstance();
   FriendInvitationParams::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
     &::bgs::protocol::InvitationParams::default_instance(),
     103, 11, false, false,
     &::bgs::protocol::friends::v1::FriendInvitationParams::default_instance());
   SubscribeResponse::default_instance_->InitAsDefaultInstance();
+  AcceptInvitationOptions::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_friends_5ftypes_2eproto);
 }
 
@@ -270,6 +366,7 @@ const int Friend::kAttributeFieldNumber;
 const int Friend::kRoleFieldNumber;
 const int Friend::kPrivilegesFieldNumber;
 const int Friend::kAttributesEpochFieldNumber;
+const int Friend::kCreationTimeFieldNumber;
 #endif  // !_MSC_VER
 
 Friend::Friend()
@@ -295,6 +392,7 @@ void Friend::SharedCtor() {
   _role_cached_byte_size_ = 0;
   privileges_ = GOOGLE_ULONGLONG(0);
   attributes_epoch_ = GOOGLE_ULONGLONG(0);
+  creation_time_ = GOOGLE_ULONGLONG(0);
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -341,8 +439,8 @@ void Friend::Clear() {
     ::memset(&first, 0, n);                                \
   } while (0)
 
-  if (_has_bits_[0 / 32] & 25) {
-    ZR_(privileges_, attributes_epoch_);
+  if (_has_bits_[0 / 32] & 57) {
+    ZR_(privileges_, creation_time_);
     if (has_account_id()) {
       if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
     }
@@ -411,7 +509,7 @@ bool Friend::MergePartialFromCodedStream(
         break;
       }
 
-      // optional uint64 privileges = 4 [default = 0];
+      // optional uint64 privileges = 4;
       case 4: {
         if (tag == 32) {
          parse_privileges:
@@ -426,7 +524,7 @@ bool Friend::MergePartialFromCodedStream(
         break;
       }
 
-      // optional uint64 attributes_epoch = 5;
+      // optional uint64 attributes_epoch = 5 [deprecated = true];
       case 5: {
         if (tag == 40) {
          parse_attributes_epoch:
@@ -437,6 +535,21 @@ bool Friend::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(48)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -488,16 +601,21 @@ void Friend::SerializeWithCachedSizes(
       this->role(i), output);
   }
 
-  // optional uint64 privileges = 4 [default = 0];
+  // optional uint64 privileges = 4;
   if (has_privileges()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->privileges(), output);
   }
 
-  // optional uint64 attributes_epoch = 5;
+  // optional uint64 attributes_epoch = 5 [deprecated = true];
   if (has_attributes_epoch()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->attributes_epoch(), output);
   }
 
+  // optional uint64 creation_time = 6;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->creation_time(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -536,16 +654,21 @@ void Friend::SerializeWithCachedSizes(
       WriteUInt32NoTagToArray(this->role(i), target);
   }
 
-  // optional uint64 privileges = 4 [default = 0];
+  // optional uint64 privileges = 4;
   if (has_privileges()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->privileges(), target);
   }
 
-  // optional uint64 attributes_epoch = 5;
+  // optional uint64 attributes_epoch = 5 [deprecated = true];
   if (has_attributes_epoch()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->attributes_epoch(), target);
   }
 
+  // optional uint64 creation_time = 6;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->creation_time(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -565,20 +688,27 @@ int Friend::ByteSize() const {
           this->account_id());
     }
 
-    // optional uint64 privileges = 4 [default = 0];
+    // optional uint64 privileges = 4;
     if (has_privileges()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt64Size(
           this->privileges());
     }
 
-    // optional uint64 attributes_epoch = 5;
+    // optional uint64 attributes_epoch = 5 [deprecated = true];
     if (has_attributes_epoch()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt64Size(
           this->attributes_epoch());
     }
 
+    // optional uint64 creation_time = 6;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
   }
   // repeated .bgs.protocol.Attribute attribute = 2;
   total_size += 1 * this->attribute_size();
@@ -642,6 +772,9 @@ void Friend::MergeFrom(const Friend& from) {
     if (from.has_attributes_epoch()) {
       set_attributes_epoch(from.attributes_epoch());
     }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -675,6 +808,7 @@ void Friend::Swap(Friend* other) {
     role_.Swap(&other->role_);
     std::swap(privileges_, other->privileges_);
     std::swap(attributes_epoch_, other->attributes_epoch_);
+    std::swap(creation_time_, other->creation_time_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -694,10 +828,8 @@ void Friend::Swap(Friend* other) {
 
 #ifndef _MSC_VER
 const int FriendOfFriend::kAccountIdFieldNumber;
-const int FriendOfFriend::kAttributeFieldNumber;
 const int FriendOfFriend::kRoleFieldNumber;
 const int FriendOfFriend::kPrivilegesFieldNumber;
-const int FriendOfFriend::kAttributesEpochFieldNumber;
 const int FriendOfFriend::kFullNameFieldNumber;
 const int FriendOfFriend::kBattleTagFieldNumber;
 #endif  // !_MSC_VER
@@ -725,7 +857,6 @@ void FriendOfFriend::SharedCtor() {
   account_id_ = NULL;
   _role_cached_byte_size_ = 0;
   privileges_ = GOOGLE_ULONGLONG(0);
-  attributes_epoch_ = GOOGLE_ULONGLONG(0);
   full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
@@ -770,21 +901,11 @@ FriendOfFriend* FriendOfFriend::New() const {
 }
 
 void FriendOfFriend::Clear() {
-#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<FriendOfFriend*>(16)->f) - \
-   reinterpret_cast<char*>(16))
-
-#define ZR_(first, last) do {                              \
-    size_t f = OFFSET_OF_FIELD_(first);                    \
-    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
-    ::memset(&first, 0, n);                                \
-  } while (0)
-
-  if (_has_bits_[0 / 32] & 121) {
-    ZR_(privileges_, attributes_epoch_);
+  if (_has_bits_[0 / 32] & 29) {
     if (has_account_id()) {
       if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
     }
+    privileges_ = GOOGLE_ULONGLONG(0);
     if (has_full_name()) {
       if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
         full_name_->clear();
@@ -796,11 +917,6 @@ void FriendOfFriend::Clear() {
       }
     }
   }
-
-#undef OFFSET_OF_FIELD_
-#undef ZR_
-
-  attribute_.Clear();
   role_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -824,20 +940,6 @@ bool FriendOfFriend::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(18)) goto parse_attribute;
-        break;
-      }
-
-      // repeated .bgs.protocol.Attribute attribute = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_attribute:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_attribute()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_attribute;
         if (input->ExpectTag(26)) goto parse_role;
         break;
       }
@@ -860,7 +962,7 @@ bool FriendOfFriend::MergePartialFromCodedStream(
         break;
       }
 
-      // optional uint64 privileges = 4 [default = 0];
+      // optional uint64 privileges = 4;
       case 4: {
         if (tag == 32) {
          parse_privileges:
@@ -871,21 +973,6 @@ bool FriendOfFriend::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(40)) goto parse_attributes_epoch;
-        break;
-      }
-
-      // optional uint64 attributes_epoch = 5;
-      case 5: {
-        if (tag == 40) {
-         parse_attributes_epoch:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
-                 input, &attributes_epoch_)));
-          set_has_attributes_epoch();
-        } else {
-          goto handle_unusual;
-        }
         if (input->ExpectTag(50)) goto parse_full_name;
         break;
       }
@@ -955,12 +1042,6 @@ void FriendOfFriend::SerializeWithCachedSizes(
       1, this->account_id(), output);
   }
 
-  // repeated .bgs.protocol.Attribute attribute = 2;
-  for (int i = 0; i < this->attribute_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->attribute(i), output);
-  }
-
   // repeated uint32 role = 3 [packed = true];
   if (this->role_size() > 0) {
     ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
@@ -971,16 +1052,11 @@ void FriendOfFriend::SerializeWithCachedSizes(
       this->role(i), output);
   }
 
-  // optional uint64 privileges = 4 [default = 0];
+  // optional uint64 privileges = 4;
   if (has_privileges()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->privileges(), output);
   }
 
-  // optional uint64 attributes_epoch = 5;
-  if (has_attributes_epoch()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->attributes_epoch(), output);
-  }
-
   // optional string full_name = 6;
   if (has_full_name()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
@@ -1018,13 +1094,6 @@ void FriendOfFriend::SerializeWithCachedSizes(
         1, this->account_id(), target);
   }
 
-  // repeated .bgs.protocol.Attribute attribute = 2;
-  for (int i = 0; i < this->attribute_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->attribute(i), target);
-  }
-
   // repeated uint32 role = 3 [packed = true];
   if (this->role_size() > 0) {
     target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
@@ -1039,16 +1108,11 @@ void FriendOfFriend::SerializeWithCachedSizes(
       WriteUInt32NoTagToArray(this->role(i), target);
   }
 
-  // optional uint64 privileges = 4 [default = 0];
+  // optional uint64 privileges = 4;
   if (has_privileges()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->privileges(), target);
   }
 
-  // optional uint64 attributes_epoch = 5;
-  if (has_attributes_epoch()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->attributes_epoch(), target);
-  }
-
   // optional string full_name = 6;
   if (has_full_name()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
@@ -1090,20 +1154,13 @@ int FriendOfFriend::ByteSize() const {
           this->account_id());
     }
 
-    // optional uint64 privileges = 4 [default = 0];
+    // optional uint64 privileges = 4;
     if (has_privileges()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt64Size(
           this->privileges());
     }
 
-    // optional uint64 attributes_epoch = 5;
-    if (has_attributes_epoch()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt64Size(
-          this->attributes_epoch());
-    }
-
     // optional string full_name = 6;
     if (has_full_name()) {
       total_size += 1 +
@@ -1119,14 +1176,6 @@ int FriendOfFriend::ByteSize() const {
     }
 
   }
-  // repeated .bgs.protocol.Attribute attribute = 2;
-  total_size += 1 * this->attribute_size();
-  for (int i = 0; i < this->attribute_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->attribute(i));
-  }
-
   // repeated uint32 role = 3 [packed = true];
   {
     int data_size = 0;
@@ -1169,7 +1218,6 @@ void FriendOfFriend::MergeFrom(const ::google::protobuf::Message& from) {
 
 void FriendOfFriend::MergeFrom(const FriendOfFriend& from) {
   GOOGLE_CHECK_NE(&from, this);
-  attribute_.MergeFrom(from.attribute_);
   role_.MergeFrom(from.role_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     if (from.has_account_id()) {
@@ -1178,9 +1226,6 @@ void FriendOfFriend::MergeFrom(const FriendOfFriend& from) {
     if (from.has_privileges()) {
       set_privileges(from.privileges());
     }
-    if (from.has_attributes_epoch()) {
-      set_attributes_epoch(from.attributes_epoch());
-    }
     if (from.has_full_name()) {
       set_full_name(from.full_name());
     }
@@ -1208,17 +1253,14 @@ bool FriendOfFriend::IsInitialized() const {
   if (has_account_id()) {
     if (!this->account_id().IsInitialized()) return false;
   }
-  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
   return true;
 }
 
 void FriendOfFriend::Swap(FriendOfFriend* other) {
   if (other != this) {
     std::swap(account_id_, other->account_id_);
-    attribute_.Swap(&other->attribute_);
     role_.Swap(&other->role_);
     std::swap(privileges_, other->privileges_);
-    std::swap(attributes_epoch_, other->attributes_epoch_);
     std::swap(full_name_, other->full_name_);
     std::swap(battle_tag_, other->battle_tag_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
@@ -1239,14 +1281,660 @@ void FriendOfFriend::Swap(FriendOfFriend* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int FriendInvitation::kFirstReceivedFieldNumber;
+const int ReceivedInvitation::kIdFieldNumber;
+const int ReceivedInvitation::kInviterIdentityFieldNumber;
+const int ReceivedInvitation::kInviteeIdentityFieldNumber;
+const int ReceivedInvitation::kInviterNameFieldNumber;
+const int ReceivedInvitation::kInviteeNameFieldNumber;
+const int ReceivedInvitation::kInvitationMessageFieldNumber;
+const int ReceivedInvitation::kCreationTimeFieldNumber;
+const int ReceivedInvitation::kExpirationTimeFieldNumber;
+const int ReceivedInvitation::kProgramFieldNumber;
+#endif  // !_MSC_VER
+
+ReceivedInvitation::ReceivedInvitation()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.ReceivedInvitation)
+}
+
+void ReceivedInvitation::InitAsDefaultInstance() {
+  inviter_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+  invitee_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+}
+
+ReceivedInvitation::ReceivedInvitation(const ReceivedInvitation& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.ReceivedInvitation)
+}
+
+void ReceivedInvitation::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = GOOGLE_ULONGLONG(0);
+  inviter_identity_ = NULL;
+  invitee_identity_ = NULL;
+  inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ReceivedInvitation::~ReceivedInvitation() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.ReceivedInvitation)
+  SharedDtor();
+}
+
+void ReceivedInvitation::SharedDtor() {
+  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_name_;
+  }
+  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitee_name_;
+  }
+  if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitation_message_;
+  }
+  if (this != default_instance_) {
+    delete inviter_identity_;
+    delete invitee_identity_;
+  }
+}
+
+void ReceivedInvitation::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ReceivedInvitation::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ReceivedInvitation_descriptor_;
+}
+
+const ReceivedInvitation& ReceivedInvitation::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ReceivedInvitation* ReceivedInvitation::default_instance_ = NULL;
+
+ReceivedInvitation* ReceivedInvitation::New() const {
+  return new ReceivedInvitation;
+}
+
+void ReceivedInvitation::Clear() {
+  _extensions_.Clear();
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ReceivedInvitation*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(creation_time_, expiration_time_);
+    id_ = GOOGLE_ULONGLONG(0);
+    if (has_inviter_identity()) {
+      if (inviter_identity_ != NULL) inviter_identity_->::bgs::protocol::Identity::Clear();
+    }
+    if (has_invitee_identity()) {
+      if (invitee_identity_ != NULL) invitee_identity_->::bgs::protocol::Identity::Clear();
+    }
+    if (has_inviter_name()) {
+      if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        inviter_name_->clear();
+      }
+    }
+    if (has_invitee_name()) {
+      if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        invitee_name_->clear();
+      }
+    }
+    if (has_invitation_message()) {
+      if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        invitation_message_->clear();
+      }
+    }
+  }
+  program_ = 0u;
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ReceivedInvitation::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.ReceivedInvitation)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed64 id = 1;
+      case 1: {
+        if (tag == 9) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_inviter_identity;
+        break;
+      }
+
+      // required .bgs.protocol.Identity inviter_identity = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_inviter_identity:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_inviter_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_invitee_identity;
+        break;
+      }
+
+      // required .bgs.protocol.Identity invitee_identity = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_invitee_identity:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_invitee_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_inviter_name;
+        break;
+      }
+
+      // optional string inviter_name = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_inviter_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_inviter_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->inviter_name().data(), this->inviter_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "inviter_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_invitee_name;
+        break;
+      }
+
+      // optional string invitee_name = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_invitee_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_invitee_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->invitee_name().data(), this->invitee_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "invitee_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_invitation_message;
+        break;
+      }
+
+      // optional string invitation_message = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_invitation_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_invitation_message()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->invitation_message().data(), this->invitation_message().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "invitation_message");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_expiration_time;
+        break;
+      }
+
+      // optional uint64 expiration_time = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_expiration_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &expiration_time_)));
+          set_has_expiration_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(77)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 9;
+      case 9: {
+        if (tag == 77) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        if ((800u <= tag && tag < 80000u)) {
+          DO_(_extensions_.ParseField(tag, input, default_instance_,
+                                      mutable_unknown_fields()));
+          continue;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.ReceivedInvitation)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.ReceivedInvitation)
+  return false;
+#undef DO_
+}
+
+void ReceivedInvitation::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.ReceivedInvitation)
+  // required fixed64 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->id(), output);
+  }
+
+  // required .bgs.protocol.Identity inviter_identity = 2;
+  if (has_inviter_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->inviter_identity(), output);
+  }
+
+  // required .bgs.protocol.Identity invitee_identity = 3;
+  if (has_invitee_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->invitee_identity(), output);
+  }
+
+  // optional string inviter_name = 4;
+  if (has_inviter_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_name().data(), this->inviter_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->inviter_name(), output);
+  }
+
+  // optional string invitee_name = 5;
+  if (has_invitee_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitee_name().data(), this->invitee_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitee_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->invitee_name(), output);
+  }
+
+  // optional string invitation_message = 6;
+  if (has_invitation_message()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitation_message().data(), this->invitation_message().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitation_message");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      6, this->invitation_message(), output);
+  }
+
+  // optional uint64 creation_time = 7;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->creation_time(), output);
+  }
+
+  // optional uint64 expiration_time = 8;
+  if (has_expiration_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->expiration_time(), output);
+  }
+
+  // optional fixed32 program = 9;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(9, this->program(), output);
+  }
+
+  // Extension range [100, 10000)
+  _extensions_.SerializeWithCachedSizes(
+      100, 10000, output);
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.ReceivedInvitation)
+}
+
+::google::protobuf::uint8* ReceivedInvitation::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.ReceivedInvitation)
+  // required fixed64 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->id(), target);
+  }
+
+  // required .bgs.protocol.Identity inviter_identity = 2;
+  if (has_inviter_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->inviter_identity(), target);
+  }
+
+  // required .bgs.protocol.Identity invitee_identity = 3;
+  if (has_invitee_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->invitee_identity(), target);
+  }
+
+  // optional string inviter_name = 4;
+  if (has_inviter_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_name().data(), this->inviter_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->inviter_name(), target);
+  }
+
+  // optional string invitee_name = 5;
+  if (has_invitee_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitee_name().data(), this->invitee_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitee_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->invitee_name(), target);
+  }
+
+  // optional string invitation_message = 6;
+  if (has_invitation_message()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitation_message().data(), this->invitation_message().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitation_message");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->invitation_message(), target);
+  }
+
+  // optional uint64 creation_time = 7;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->creation_time(), target);
+  }
+
+  // optional uint64 expiration_time = 8;
+  if (has_expiration_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->expiration_time(), target);
+  }
+
+  // optional fixed32 program = 9;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(9, this->program(), target);
+  }
+
+  // Extension range [100, 10000)
+  target = _extensions_.SerializeWithCachedSizesToArray(
+      100, 10000, target);
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.ReceivedInvitation)
+  return target;
+}
+
+int ReceivedInvitation::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed64 id = 1;
+    if (has_id()) {
+      total_size += 1 + 8;
+    }
+
+    // required .bgs.protocol.Identity inviter_identity = 2;
+    if (has_inviter_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->inviter_identity());
+    }
+
+    // required .bgs.protocol.Identity invitee_identity = 3;
+    if (has_invitee_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->invitee_identity());
+    }
+
+    // optional string inviter_name = 4;
+    if (has_inviter_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->inviter_name());
+    }
+
+    // optional string invitee_name = 5;
+    if (has_invitee_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->invitee_name());
+    }
+
+    // optional string invitation_message = 6;
+    if (has_invitation_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->invitation_message());
+    }
+
+    // optional uint64 creation_time = 7;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+    // optional uint64 expiration_time = 8;
+    if (has_expiration_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->expiration_time());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional fixed32 program = 9;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  total_size += _extensions_.ByteSize();
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ReceivedInvitation::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ReceivedInvitation* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ReceivedInvitation*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ReceivedInvitation::MergeFrom(const ReceivedInvitation& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_inviter_identity()) {
+      mutable_inviter_identity()->::bgs::protocol::Identity::MergeFrom(from.inviter_identity());
+    }
+    if (from.has_invitee_identity()) {
+      mutable_invitee_identity()->::bgs::protocol::Identity::MergeFrom(from.invitee_identity());
+    }
+    if (from.has_inviter_name()) {
+      set_inviter_name(from.inviter_name());
+    }
+    if (from.has_invitee_name()) {
+      set_invitee_name(from.invitee_name());
+    }
+    if (from.has_invitation_message()) {
+      set_invitation_message(from.invitation_message());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+    if (from.has_expiration_time()) {
+      set_expiration_time(from.expiration_time());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+  }
+  _extensions_.MergeFrom(from._extensions_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ReceivedInvitation::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ReceivedInvitation::CopyFrom(const ReceivedInvitation& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ReceivedInvitation::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+
+  if (has_inviter_identity()) {
+    if (!this->inviter_identity().IsInitialized()) return false;
+  }
+  if (has_invitee_identity()) {
+    if (!this->invitee_identity().IsInitialized()) return false;
+  }
+
+  if (!_extensions_.IsInitialized()) return false;  return true;
+}
+
+void ReceivedInvitation::Swap(ReceivedInvitation* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(inviter_identity_, other->inviter_identity_);
+    std::swap(invitee_identity_, other->invitee_identity_);
+    std::swap(inviter_name_, other->inviter_name_);
+    std::swap(invitee_name_, other->invitee_name_);
+    std::swap(invitation_message_, other->invitation_message_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(expiration_time_, other->expiration_time_);
+    std::swap(program_, other->program_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+    _extensions_.Swap(&other->_extensions_);
+  }
+}
+
+::google::protobuf::Metadata ReceivedInvitation::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ReceivedInvitation_descriptor_;
+  metadata.reflection = ReceivedInvitation_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
 const int FriendInvitation::kRoleFieldNumber;
+const int FriendInvitation::kAttributeFieldNumber;
 #endif  // !_MSC_VER
 
 #ifndef _MSC_VER
 const int FriendInvitation::kFriendInvitationFieldNumber;
 #endif
-::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::Invitation,
+::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::friends::v1::ReceivedInvitation,
     ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitation >, 11, false >
   FriendInvitation::friend_invitation(kFriendInvitationFieldNumber, ::bgs::protocol::friends::v1::FriendInvitation::default_instance());
 FriendInvitation::FriendInvitation()
@@ -1267,7 +1955,6 @@ FriendInvitation::FriendInvitation(const FriendInvitation& from)
 
 void FriendInvitation::SharedCtor() {
   _cached_size_ = 0;
-  first_received_ = false;
   _role_cached_byte_size_ = 0;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
@@ -1304,8 +1991,8 @@ FriendInvitation* FriendInvitation::New() const {
 }
 
 void FriendInvitation::Clear() {
-  first_received_ = false;
   role_.Clear();
+  attribute_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
@@ -1320,24 +2007,9 @@ bool FriendInvitation::MergePartialFromCodedStream(
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional bool first_received = 1 [default = false];
-      case 1: {
-        if (tag == 8) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &first_received_)));
-          set_has_first_received();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_role;
-        break;
-      }
-
       // repeated uint32 role = 2 [packed = true];
       case 2: {
         if (tag == 18) {
-         parse_role:
           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                  input, this->mutable_role())));
@@ -1348,6 +2020,20 @@ bool FriendInvitation::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -1377,11 +2063,6 @@ failure:
 void FriendInvitation::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.FriendInvitation)
-  // optional bool first_received = 1 [default = false];
-  if (has_first_received()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->first_received(), output);
-  }
-
   // repeated uint32 role = 2 [packed = true];
   if (this->role_size() > 0) {
     ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
@@ -1392,6 +2073,12 @@ void FriendInvitation::SerializeWithCachedSizes(
       this->role(i), output);
   }
 
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->attribute(i), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -1402,11 +2089,6 @@ void FriendInvitation::SerializeWithCachedSizes(
 ::google::protobuf::uint8* FriendInvitation::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
   // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.FriendInvitation)
-  // optional bool first_received = 1 [default = false];
-  if (has_first_received()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->first_received(), target);
-  }
-
   // repeated uint32 role = 2 [packed = true];
   if (this->role_size() > 0) {
     target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
@@ -1421,6 +2103,13 @@ void FriendInvitation::SerializeWithCachedSizes(
       WriteUInt32NoTagToArray(this->role(i), target);
   }
 
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->attribute(i), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -1432,13 +2121,6 @@ void FriendInvitation::SerializeWithCachedSizes(
 int FriendInvitation::ByteSize() const {
   int total_size = 0;
 
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional bool first_received = 1 [default = false];
-    if (has_first_received()) {
-      total_size += 1 + 1;
-    }
-
-  }
   // repeated uint32 role = 2 [packed = true];
   {
     int data_size = 0;
@@ -1456,6 +2138,14 @@ int FriendInvitation::ByteSize() const {
     total_size += data_size;
   }
 
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -1482,11 +2172,7 @@ void FriendInvitation::MergeFrom(const ::google::protobuf::Message& from) {
 void FriendInvitation::MergeFrom(const FriendInvitation& from) {
   GOOGLE_CHECK_NE(&from, this);
   role_.MergeFrom(from.role_);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_first_received()) {
-      set_first_received(from.first_received());
-    }
-  }
+  attribute_.MergeFrom(from.attribute_);
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
@@ -1504,13 +2190,14 @@ void FriendInvitation::CopyFrom(const FriendInvitation& from) {
 
 bool FriendInvitation::IsInitialized() const {
 
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
   return true;
 }
 
 void FriendInvitation::Swap(FriendInvitation* other) {
   if (other != this) {
-    std::swap(first_received_, other->first_received_);
     role_.Swap(&other->role_);
+    attribute_.Swap(&other->attribute_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -1529,13 +2216,461 @@ void FriendInvitation::Swap(FriendInvitation* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
+const int SentInvitation::kIdFieldNumber;
+const int SentInvitation::kTargetNameFieldNumber;
+const int SentInvitation::kRoleFieldNumber;
+const int SentInvitation::kAttributeFieldNumber;
+const int SentInvitation::kCreationTimeFieldNumber;
+const int SentInvitation::kProgramFieldNumber;
+#endif  // !_MSC_VER
+
+SentInvitation::SentInvitation()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.SentInvitation)
+}
+
+void SentInvitation::InitAsDefaultInstance() {
+}
+
+SentInvitation::SentInvitation(const SentInvitation& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.SentInvitation)
+}
+
+void SentInvitation::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = GOOGLE_ULONGLONG(0);
+  target_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  role_ = 0u;
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SentInvitation::~SentInvitation() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.SentInvitation)
+  SharedDtor();
+}
+
+void SentInvitation::SharedDtor() {
+  if (target_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void SentInvitation::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SentInvitation::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SentInvitation_descriptor_;
+}
+
+const SentInvitation& SentInvitation::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+SentInvitation* SentInvitation::default_instance_ = NULL;
+
+SentInvitation* SentInvitation::New() const {
+  return new SentInvitation;
+}
+
+void SentInvitation::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<SentInvitation*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 55) {
+    ZR_(role_, creation_time_);
+    id_ = GOOGLE_ULONGLONG(0);
+    if (has_target_name()) {
+      if (target_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        target_name_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SentInvitation::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.SentInvitation)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed64 id = 1;
+      case 1: {
+        if (tag == 9) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_name;
+        break;
+      }
+
+      // optional string target_name = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_target_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->target_name().data(), this->target_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "target_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_role;
+        break;
+      }
+
+      // optional uint32 role = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &role_)));
+          set_has_role();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attribute;
+        if (input->ExpectTag(40)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(53)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 6;
+      case 6: {
+        if (tag == 53) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.SentInvitation)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.SentInvitation)
+  return false;
+#undef DO_
+}
+
+void SentInvitation::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.SentInvitation)
+  // optional fixed64 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->id(), output);
+  }
+
+  // optional string target_name = 2;
+  if (has_target_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_name().data(), this->target_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->target_name(), output);
+  }
+
+  // optional uint32 role = 3;
+  if (has_role()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->role(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 4;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->attribute(i), output);
+  }
+
+  // optional uint64 creation_time = 5;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->creation_time(), output);
+  }
+
+  // optional fixed32 program = 6;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(6, this->program(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.SentInvitation)
+}
+
+::google::protobuf::uint8* SentInvitation::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.SentInvitation)
+  // optional fixed64 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->id(), target);
+  }
+
+  // optional string target_name = 2;
+  if (has_target_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_name().data(), this->target_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->target_name(), target);
+  }
+
+  // optional uint32 role = 3;
+  if (has_role()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->role(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 4;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->attribute(i), target);
+  }
+
+  // optional uint64 creation_time = 5;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->creation_time(), target);
+  }
+
+  // optional fixed32 program = 6;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(6, this->program(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.SentInvitation)
+  return target;
+}
+
+int SentInvitation::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed64 id = 1;
+    if (has_id()) {
+      total_size += 1 + 8;
+    }
+
+    // optional string target_name = 2;
+    if (has_target_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->target_name());
+    }
+
+    // optional uint32 role = 3;
+    if (has_role()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->role());
+    }
+
+    // optional uint64 creation_time = 5;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+    // optional fixed32 program = 6;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 4;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SentInvitation::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SentInvitation* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SentInvitation*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SentInvitation::MergeFrom(const SentInvitation& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_target_name()) {
+      set_target_name(from.target_name());
+    }
+    if (from.has_role()) {
+      set_role(from.role());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SentInvitation::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SentInvitation::CopyFrom(const SentInvitation& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SentInvitation::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  return true;
+}
+
+void SentInvitation::Swap(SentInvitation* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(target_name_, other->target_name_);
+    std::swap(role_, other->role_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(program_, other->program_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SentInvitation::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SentInvitation_descriptor_;
+  metadata.reflection = SentInvitation_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
 const int FriendInvitationParams::kTargetEmailFieldNumber;
 const int FriendInvitationParams::kTargetBattleTagFieldNumber;
-const int FriendInvitationParams::kInviterBattleTagFieldNumber;
-const int FriendInvitationParams::kInviterFullNameFieldNumber;
-const int FriendInvitationParams::kInviteeDisplayNameFieldNumber;
 const int FriendInvitationParams::kRoleFieldNumber;
-const int FriendInvitationParams::kPreviousRoleDeprecatedFieldNumber;
+const int FriendInvitationParams::kAttributeFieldNumber;
+const int FriendInvitationParams::kTargetNameFieldNumber;
+const int FriendInvitationParams::kProgramFieldNumber;
 #endif  // !_MSC_VER
 
 #ifndef _MSC_VER
@@ -1565,11 +2700,9 @@ void FriendInvitationParams::SharedCtor() {
   _cached_size_ = 0;
   target_email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  inviter_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  inviter_full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  invitee_display_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   _role_cached_byte_size_ = 0;
-  _previous_role_deprecated_cached_byte_size_ = 0;
+  target_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  program_ = 0u;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -1585,14 +2718,8 @@ void FriendInvitationParams::SharedDtor() {
   if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete target_battle_tag_;
   }
-  if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete inviter_battle_tag_;
-  }
-  if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete inviter_full_name_;
-  }
-  if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete invitee_display_name_;
+  if (target_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_name_;
   }
   if (this != default_instance_) {
   }
@@ -1620,7 +2747,7 @@ FriendInvitationParams* FriendInvitationParams::New() const {
 }
 
 void FriendInvitationParams::Clear() {
-  if (_has_bits_[0 / 32] & 31) {
+  if (_has_bits_[0 / 32] & 51) {
     if (has_target_email()) {
       if (target_email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
         target_email_->clear();
@@ -1631,24 +2758,15 @@ void FriendInvitationParams::Clear() {
         target_battle_tag_->clear();
       }
     }
-    if (has_inviter_battle_tag()) {
-      if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        inviter_battle_tag_->clear();
-      }
-    }
-    if (has_inviter_full_name()) {
-      if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        inviter_full_name_->clear();
-      }
-    }
-    if (has_invitee_display_name()) {
-      if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        invitee_display_name_->clear();
+    if (has_target_name()) {
+      if (target_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        target_name_->clear();
       }
     }
+    program_ = 0u;
   }
   role_.Clear();
-  previous_role_deprecated_.Clear();
+  attribute_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
@@ -1692,90 +2810,67 @@ bool FriendInvitationParams::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(26)) goto parse_inviter_battle_tag;
+        if (input->ExpectTag(50)) goto parse_role;
         break;
       }
 
-      // optional string inviter_battle_tag = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_inviter_battle_tag:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_inviter_battle_tag()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->inviter_battle_tag().data(), this->inviter_battle_tag().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "inviter_battle_tag");
+      // repeated uint32 role = 6 [packed = true];
+      case 6: {
+        if (tag == 50) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 48) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 50, input, this->mutable_role())));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(34)) goto parse_inviter_full_name;
+        if (input->ExpectTag(66)) goto parse_attribute;
         break;
       }
 
-      // optional string inviter_full_name = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_inviter_full_name:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_inviter_full_name()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->inviter_full_name().data(), this->inviter_full_name().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "inviter_full_name");
+      // repeated .bgs.protocol.Attribute attribute = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(42)) goto parse_invitee_display_name;
+        if (input->ExpectTag(66)) goto parse_attribute;
+        if (input->ExpectTag(74)) goto parse_target_name;
         break;
       }
 
-      // optional string invitee_display_name = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_invitee_display_name:
+      // optional string target_name = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_target_name:
           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_invitee_display_name()));
+                input, this->mutable_target_name()));
           ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->invitee_display_name().data(), this->invitee_display_name().length(),
+            this->target_name().data(), this->target_name().length(),
             ::google::protobuf::internal::WireFormat::PARSE,
-            "invitee_display_name");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(50)) goto parse_role;
-        break;
-      }
-
-      // repeated uint32 role = 6 [packed = true];
-      case 6: {
-        if (tag == 50) {
-         parse_role:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, this->mutable_role())));
-        } else if (tag == 48) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 1, 50, input, this->mutable_role())));
+            "target_name");
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(58)) goto parse_previous_role_deprecated;
+        if (input->ExpectTag(85)) goto parse_program;
         break;
       }
 
-      // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
-      case 7: {
-        if (tag == 58) {
-         parse_previous_role_deprecated:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, this->mutable_previous_role_deprecated())));
-        } else if (tag == 56) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 1, 58, input, this->mutable_previous_role_deprecated())));
+      // optional fixed32 program = 10 [deprecated = true];
+      case 10: {
+        if (tag == 85) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
         } else {
           goto handle_unusual;
         }
@@ -1828,36 +2923,6 @@ void FriendInvitationParams::SerializeWithCachedSizes(
       2, this->target_battle_tag(), output);
   }
 
-  // optional string inviter_battle_tag = 3;
-  if (has_inviter_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->inviter_battle_tag().data(), this->inviter_battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "inviter_battle_tag");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      3, this->inviter_battle_tag(), output);
-  }
-
-  // optional string inviter_full_name = 4;
-  if (has_inviter_full_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->inviter_full_name().data(), this->inviter_full_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "inviter_full_name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      4, this->inviter_full_name(), output);
-  }
-
-  // optional string invitee_display_name = 5;
-  if (has_invitee_display_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->invitee_display_name().data(), this->invitee_display_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "invitee_display_name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      5, this->invitee_display_name(), output);
-  }
-
   // repeated uint32 role = 6 [packed = true];
   if (this->role_size() > 0) {
     ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
@@ -1868,14 +2933,25 @@ void FriendInvitationParams::SerializeWithCachedSizes(
       this->role(i), output);
   }
 
-  // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
-  if (this->previous_role_deprecated_size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
-    output->WriteVarint32(_previous_role_deprecated_cached_byte_size_);
+  // repeated .bgs.protocol.Attribute attribute = 8;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      8, this->attribute(i), output);
   }
-  for (int i = 0; i < this->previous_role_deprecated_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
-      this->previous_role_deprecated(i), output);
+
+  // optional string target_name = 9;
+  if (has_target_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_name().data(), this->target_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      9, this->target_name(), output);
+  }
+
+  // optional fixed32 program = 10 [deprecated = true];
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(10, this->program(), output);
   }
 
   if (!unknown_fields().empty()) {
@@ -1910,39 +2986,6 @@ void FriendInvitationParams::SerializeWithCachedSizes(
         2, this->target_battle_tag(), target);
   }
 
-  // optional string inviter_battle_tag = 3;
-  if (has_inviter_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->inviter_battle_tag().data(), this->inviter_battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "inviter_battle_tag");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        3, this->inviter_battle_tag(), target);
-  }
-
-  // optional string inviter_full_name = 4;
-  if (has_inviter_full_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->inviter_full_name().data(), this->inviter_full_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "inviter_full_name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        4, this->inviter_full_name(), target);
-  }
-
-  // optional string invitee_display_name = 5;
-  if (has_invitee_display_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->invitee_display_name().data(), this->invitee_display_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "invitee_display_name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        5, this->invitee_display_name(), target);
-  }
-
   // repeated uint32 role = 6 [packed = true];
   if (this->role_size() > 0) {
     target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
@@ -1957,18 +3000,27 @@ void FriendInvitationParams::SerializeWithCachedSizes(
       WriteUInt32NoTagToArray(this->role(i), target);
   }
 
-  // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
-  if (this->previous_role_deprecated_size() > 0) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
-      7,
-      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
-      target);
-    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
-      _previous_role_deprecated_cached_byte_size_, target);
-  }
-  for (int i = 0; i < this->previous_role_deprecated_size(); i++) {
+  // repeated .bgs.protocol.Attribute attribute = 8;
+  for (int i = 0; i < this->attribute_size(); i++) {
     target = ::google::protobuf::internal::WireFormatLite::
-      WriteUInt32NoTagToArray(this->previous_role_deprecated(i), target);
+      WriteMessageNoVirtualToArray(
+        8, this->attribute(i), target);
+  }
+
+  // optional string target_name = 9;
+  if (has_target_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_name().data(), this->target_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        9, this->target_name(), target);
+  }
+
+  // optional fixed32 program = 10 [deprecated = true];
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(10, this->program(), target);
   }
 
   if (!unknown_fields().empty()) {
@@ -1997,25 +3049,16 @@ int FriendInvitationParams::ByteSize() const {
           this->target_battle_tag());
     }
 
-    // optional string inviter_battle_tag = 3;
-    if (has_inviter_battle_tag()) {
+    // optional string target_name = 9;
+    if (has_target_name()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->inviter_battle_tag());
+          this->target_name());
     }
 
-    // optional string inviter_full_name = 4;
-    if (has_inviter_full_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->inviter_full_name());
-    }
-
-    // optional string invitee_display_name = 5;
-    if (has_invitee_display_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->invitee_display_name());
+    // optional fixed32 program = 10 [deprecated = true];
+    if (has_program()) {
+      total_size += 1 + 4;
     }
 
   }
@@ -2036,21 +3079,12 @@ int FriendInvitationParams::ByteSize() const {
     total_size += data_size;
   }
 
-  // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
-  {
-    int data_size = 0;
-    for (int i = 0; i < this->previous_role_deprecated_size(); i++) {
-      data_size += ::google::protobuf::internal::WireFormatLite::
-        UInt32Size(this->previous_role_deprecated(i));
-    }
-    if (data_size > 0) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
-    }
-    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-    _previous_role_deprecated_cached_byte_size_ = data_size;
-    GOOGLE_SAFE_CONCURRENT_WRITES_END();
-    total_size += data_size;
+  // repeated .bgs.protocol.Attribute attribute = 8;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
   }
 
   if (!unknown_fields().empty()) {
@@ -2079,7 +3113,7 @@ void FriendInvitationParams::MergeFrom(const ::google::protobuf::Message& from)
 void FriendInvitationParams::MergeFrom(const FriendInvitationParams& from) {
   GOOGLE_CHECK_NE(&from, this);
   role_.MergeFrom(from.role_);
-  previous_role_deprecated_.MergeFrom(from.previous_role_deprecated_);
+  attribute_.MergeFrom(from.attribute_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     if (from.has_target_email()) {
       set_target_email(from.target_email());
@@ -2087,14 +3121,11 @@ void FriendInvitationParams::MergeFrom(const FriendInvitationParams& from) {
     if (from.has_target_battle_tag()) {
       set_target_battle_tag(from.target_battle_tag());
     }
-    if (from.has_inviter_battle_tag()) {
-      set_inviter_battle_tag(from.inviter_battle_tag());
-    }
-    if (from.has_inviter_full_name()) {
-      set_inviter_full_name(from.inviter_full_name());
+    if (from.has_target_name()) {
+      set_target_name(from.target_name());
     }
-    if (from.has_invitee_display_name()) {
-      set_invitee_display_name(from.invitee_display_name());
+    if (from.has_program()) {
+      set_program(from.program());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
@@ -2114,6 +3145,7 @@ void FriendInvitationParams::CopyFrom(const FriendInvitationParams& from) {
 
 bool FriendInvitationParams::IsInitialized() const {
 
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
   return true;
 }
 
@@ -2121,11 +3153,10 @@ void FriendInvitationParams::Swap(FriendInvitationParams* other) {
   if (other != this) {
     std::swap(target_email_, other->target_email_);
     std::swap(target_battle_tag_, other->target_battle_tag_);
-    std::swap(inviter_battle_tag_, other->inviter_battle_tag_);
-    std::swap(inviter_full_name_, other->inviter_full_name_);
-    std::swap(invitee_display_name_, other->invitee_display_name_);
     role_.Swap(&other->role_);
-    previous_role_deprecated_.Swap(&other->previous_role_deprecated_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(target_name_, other->target_name_);
+    std::swap(program_, other->program_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -2149,8 +3180,8 @@ const int SubscribeResponse::kMaxReceivedInvitationsFieldNumber;
 const int SubscribeResponse::kMaxSentInvitationsFieldNumber;
 const int SubscribeResponse::kRoleFieldNumber;
 const int SubscribeResponse::kFriendsFieldNumber;
-const int SubscribeResponse::kSentInvitationsFieldNumber;
 const int SubscribeResponse::kReceivedInvitationsFieldNumber;
+const int SubscribeResponse::kSentInvitationsFieldNumber;
 #endif  // !_MSC_VER
 
 SubscribeResponse::SubscribeResponse()
@@ -2229,8 +3260,8 @@ void SubscribeResponse::Clear() {
 
   role_.Clear();
   friends_.Clear();
-  sent_invitations_.Clear();
   received_invitations_.Clear();
+  sent_invitations_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
@@ -2313,34 +3344,34 @@ bool SubscribeResponse::MergePartialFromCodedStream(
           goto handle_unusual;
         }
         if (input->ExpectTag(42)) goto parse_friends;
-        if (input->ExpectTag(50)) goto parse_sent_invitations;
+        if (input->ExpectTag(58)) goto parse_received_invitations;
         break;
       }
 
-      // repeated .bgs.protocol.Invitation sent_invitations = 6;
-      case 6: {
-        if (tag == 50) {
-         parse_sent_invitations:
+      // repeated .bgs.protocol.friends.v1.ReceivedInvitation received_invitations = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_received_invitations:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_sent_invitations()));
+                input, add_received_invitations()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(50)) goto parse_sent_invitations;
         if (input->ExpectTag(58)) goto parse_received_invitations;
+        if (input->ExpectTag(66)) goto parse_sent_invitations;
         break;
       }
 
-      // repeated .bgs.protocol.Invitation received_invitations = 7;
-      case 7: {
-        if (tag == 58) {
-         parse_received_invitations:
+      // repeated .bgs.protocol.friends.v1.SentInvitation sent_invitations = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_sent_invitations:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_received_invitations()));
+                input, add_sent_invitations()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(58)) goto parse_received_invitations;
+        if (input->ExpectTag(66)) goto parse_sent_invitations;
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -2397,16 +3428,16 @@ void SubscribeResponse::SerializeWithCachedSizes(
       5, this->friends(i), output);
   }
 
-  // repeated .bgs.protocol.Invitation sent_invitations = 6;
-  for (int i = 0; i < this->sent_invitations_size(); i++) {
+  // repeated .bgs.protocol.friends.v1.ReceivedInvitation received_invitations = 7;
+  for (int i = 0; i < this->received_invitations_size(); i++) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      6, this->sent_invitations(i), output);
+      7, this->received_invitations(i), output);
   }
 
-  // repeated .bgs.protocol.Invitation received_invitations = 7;
-  for (int i = 0; i < this->received_invitations_size(); i++) {
+  // repeated .bgs.protocol.friends.v1.SentInvitation sent_invitations = 8;
+  for (int i = 0; i < this->sent_invitations_size(); i++) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      7, this->received_invitations(i), output);
+      8, this->sent_invitations(i), output);
   }
 
   if (!unknown_fields().empty()) {
@@ -2448,18 +3479,18 @@ void SubscribeResponse::SerializeWithCachedSizes(
         5, this->friends(i), target);
   }
 
-  // repeated .bgs.protocol.Invitation sent_invitations = 6;
-  for (int i = 0; i < this->sent_invitations_size(); i++) {
+  // repeated .bgs.protocol.friends.v1.ReceivedInvitation received_invitations = 7;
+  for (int i = 0; i < this->received_invitations_size(); i++) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        6, this->sent_invitations(i), target);
+        7, this->received_invitations(i), target);
   }
 
-  // repeated .bgs.protocol.Invitation received_invitations = 7;
-  for (int i = 0; i < this->received_invitations_size(); i++) {
+  // repeated .bgs.protocol.friends.v1.SentInvitation sent_invitations = 8;
+  for (int i = 0; i < this->sent_invitations_size(); i++) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        7, this->received_invitations(i), target);
+        8, this->sent_invitations(i), target);
   }
 
   if (!unknown_fields().empty()) {
@@ -2512,20 +3543,20 @@ int SubscribeResponse::ByteSize() const {
         this->friends(i));
   }
 
-  // repeated .bgs.protocol.Invitation sent_invitations = 6;
-  total_size += 1 * this->sent_invitations_size();
-  for (int i = 0; i < this->sent_invitations_size(); i++) {
+  // repeated .bgs.protocol.friends.v1.ReceivedInvitation received_invitations = 7;
+  total_size += 1 * this->received_invitations_size();
+  for (int i = 0; i < this->received_invitations_size(); i++) {
     total_size +=
       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->sent_invitations(i));
+        this->received_invitations(i));
   }
 
-  // repeated .bgs.protocol.Invitation received_invitations = 7;
-  total_size += 1 * this->received_invitations_size();
-  for (int i = 0; i < this->received_invitations_size(); i++) {
+  // repeated .bgs.protocol.friends.v1.SentInvitation sent_invitations = 8;
+  total_size += 1 * this->sent_invitations_size();
+  for (int i = 0; i < this->sent_invitations_size(); i++) {
     total_size +=
       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->received_invitations(i));
+        this->sent_invitations(i));
   }
 
   if (!unknown_fields().empty()) {
@@ -2555,8 +3586,8 @@ void SubscribeResponse::MergeFrom(const SubscribeResponse& from) {
   GOOGLE_CHECK_NE(&from, this);
   role_.MergeFrom(from.role_);
   friends_.MergeFrom(from.friends_);
-  sent_invitations_.MergeFrom(from.sent_invitations_);
   received_invitations_.MergeFrom(from.received_invitations_);
+  sent_invitations_.MergeFrom(from.sent_invitations_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     if (from.has_max_friends()) {
       set_max_friends(from.max_friends());
@@ -2587,8 +3618,8 @@ bool SubscribeResponse::IsInitialized() const {
 
   if (!::google::protobuf::internal::AllAreInitialized(this->role())) return false;
   if (!::google::protobuf::internal::AllAreInitialized(this->friends())) return false;
-  if (!::google::protobuf::internal::AllAreInitialized(this->sent_invitations())) return false;
   if (!::google::protobuf::internal::AllAreInitialized(this->received_invitations())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->sent_invitations())) return false;
   return true;
 }
 
@@ -2599,8 +3630,8 @@ void SubscribeResponse::Swap(SubscribeResponse* other) {
     std::swap(max_sent_invitations_, other->max_sent_invitations_);
     role_.Swap(&other->role_);
     friends_.Swap(&other->friends_);
-    sent_invitations_.Swap(&other->sent_invitations_);
     received_invitations_.Swap(&other->received_invitations_);
+    sent_invitations_.Swap(&other->sent_invitations_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -2616,6 +3647,278 @@ void SubscribeResponse::Swap(SubscribeResponse* other) {
 }
 
 
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AcceptInvitationOptions::kRoleFieldNumber;
+const int AcceptInvitationOptions::kProgramFieldNumber;
+#endif  // !_MSC_VER
+
+AcceptInvitationOptions::AcceptInvitationOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.AcceptInvitationOptions)
+}
+
+void AcceptInvitationOptions::InitAsDefaultInstance() {
+}
+
+AcceptInvitationOptions::AcceptInvitationOptions(const AcceptInvitationOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.AcceptInvitationOptions)
+}
+
+void AcceptInvitationOptions::SharedCtor() {
+  _cached_size_ = 0;
+  role_ = 0u;
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AcceptInvitationOptions::~AcceptInvitationOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.AcceptInvitationOptions)
+  SharedDtor();
+}
+
+void AcceptInvitationOptions::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AcceptInvitationOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AcceptInvitationOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AcceptInvitationOptions_descriptor_;
+}
+
+const AcceptInvitationOptions& AcceptInvitationOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AcceptInvitationOptions* AcceptInvitationOptions::default_instance_ = NULL;
+
+AcceptInvitationOptions* AcceptInvitationOptions::New() const {
+  return new AcceptInvitationOptions;
+}
+
+void AcceptInvitationOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AcceptInvitationOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(role_, program_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AcceptInvitationOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.AcceptInvitationOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 role = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &role_)));
+          set_has_role();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.AcceptInvitationOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.AcceptInvitationOptions)
+  return false;
+#undef DO_
+}
+
+void AcceptInvitationOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.AcceptInvitationOptions)
+  // optional uint32 role = 1;
+  if (has_role()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->role(), output);
+  }
+
+  // optional fixed32 program = 2;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->program(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.AcceptInvitationOptions)
+}
+
+::google::protobuf::uint8* AcceptInvitationOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.AcceptInvitationOptions)
+  // optional uint32 role = 1;
+  if (has_role()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->role(), target);
+  }
+
+  // optional fixed32 program = 2;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->program(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.AcceptInvitationOptions)
+  return target;
+}
+
+int AcceptInvitationOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 role = 1;
+    if (has_role()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->role());
+    }
+
+    // optional fixed32 program = 2;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AcceptInvitationOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AcceptInvitationOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AcceptInvitationOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AcceptInvitationOptions::MergeFrom(const AcceptInvitationOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_role()) {
+      set_role(from.role());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AcceptInvitationOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AcceptInvitationOptions::CopyFrom(const AcceptInvitationOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AcceptInvitationOptions::IsInitialized() const {
+
+  return true;
+}
+
+void AcceptInvitationOptions::Swap(AcceptInvitationOptions* other) {
+  if (other != this) {
+    std::swap(role_, other->role_);
+    std::swap(program_, other->program_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AcceptInvitationOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AcceptInvitationOptions_descriptor_;
+  metadata.reflection = AcceptInvitationOptions_reflection_;
+  return metadata;
+}
+
+
 // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace v1
diff --git a/src/server/proto/Client/friends_types.pb.h b/src/server/proto/Client/friends_types.pb.h
index 8304a3f38cb..955e7fb28ad 100644
--- a/src/server/proto/Client/friends_types.pb.h
+++ b/src/server/proto/Client/friends_types.pb.h
@@ -43,9 +43,12 @@ void protobuf_ShutdownFile_friends_5ftypes_2eproto();
 
 class Friend;
 class FriendOfFriend;
+class ReceivedInvitation;
 class FriendInvitation;
+class SentInvitation;
 class FriendInvitationParams;
 class SubscribeResponse;
+class AcceptInvitationOptions;
 
 // ===================================================================
 
@@ -135,19 +138,26 @@ class TC_PROTO_API Friend : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
       mutable_role();
 
-  // optional uint64 privileges = 4 [default = 0];
+  // optional uint64 privileges = 4;
   inline bool has_privileges() const;
   inline void clear_privileges();
   static const int kPrivilegesFieldNumber = 4;
   inline ::google::protobuf::uint64 privileges() const;
   inline void set_privileges(::google::protobuf::uint64 value);
 
-  // optional uint64 attributes_epoch = 5;
-  inline bool has_attributes_epoch() const;
-  inline void clear_attributes_epoch();
+  // optional uint64 attributes_epoch = 5 [deprecated = true];
+  inline bool has_attributes_epoch() const PROTOBUF_DEPRECATED;
+  inline void clear_attributes_epoch() PROTOBUF_DEPRECATED;
   static const int kAttributesEpochFieldNumber = 5;
-  inline ::google::protobuf::uint64 attributes_epoch() const;
-  inline void set_attributes_epoch(::google::protobuf::uint64 value);
+  inline ::google::protobuf::uint64 attributes_epoch() const PROTOBUF_DEPRECATED;
+  inline void set_attributes_epoch(::google::protobuf::uint64 value) PROTOBUF_DEPRECATED;
+
+  // optional uint64 creation_time = 6;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 6;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
 
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.Friend)
  private:
@@ -157,6 +167,8 @@ class TC_PROTO_API Friend : public ::google::protobuf::Message {
   inline void clear_has_privileges();
   inline void set_has_attributes_epoch();
   inline void clear_has_attributes_epoch();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -168,6 +180,7 @@ class TC_PROTO_API Friend : public ::google::protobuf::Message {
   mutable int _role_cached_byte_size_;
   ::google::protobuf::uint64 privileges_;
   ::google::protobuf::uint64 attributes_epoch_;
+  ::google::protobuf::uint64 creation_time_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5ftypes_2eproto();
   friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
   friend void protobuf_ShutdownFile_friends_5ftypes_2eproto();
@@ -239,18 +252,6 @@ class TC_PROTO_API FriendOfFriend : public ::google::protobuf::Message {
   inline ::bgs::protocol::EntityId* release_account_id();
   inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
 
-  // repeated .bgs.protocol.Attribute attribute = 2;
-  inline int attribute_size() const;
-  inline void clear_attribute();
-  static const int kAttributeFieldNumber = 2;
-  inline const ::bgs::protocol::Attribute& attribute(int index) const;
-  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
-  inline ::bgs::protocol::Attribute* add_attribute();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
-      attribute() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
-      mutable_attribute();
-
   // repeated uint32 role = 3 [packed = true];
   inline int role_size() const;
   inline void clear_role();
@@ -263,20 +264,13 @@ class TC_PROTO_API FriendOfFriend : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
       mutable_role();
 
-  // optional uint64 privileges = 4 [default = 0];
+  // optional uint64 privileges = 4;
   inline bool has_privileges() const;
   inline void clear_privileges();
   static const int kPrivilegesFieldNumber = 4;
   inline ::google::protobuf::uint64 privileges() const;
   inline void set_privileges(::google::protobuf::uint64 value);
 
-  // optional uint64 attributes_epoch = 5;
-  inline bool has_attributes_epoch() const;
-  inline void clear_attributes_epoch();
-  static const int kAttributesEpochFieldNumber = 5;
-  inline ::google::protobuf::uint64 attributes_epoch() const;
-  inline void set_attributes_epoch(::google::protobuf::uint64 value);
-
   // optional string full_name = 6;
   inline bool has_full_name() const;
   inline void clear_full_name();
@@ -307,8 +301,6 @@ class TC_PROTO_API FriendOfFriend : public ::google::protobuf::Message {
   inline void clear_has_account_id();
   inline void set_has_privileges();
   inline void clear_has_privileges();
-  inline void set_has_attributes_epoch();
-  inline void clear_has_attributes_epoch();
   inline void set_has_full_name();
   inline void clear_has_full_name();
   inline void set_has_battle_tag();
@@ -319,11 +311,9 @@ class TC_PROTO_API FriendOfFriend : public ::google::protobuf::Message {
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
   ::bgs::protocol::EntityId* account_id_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
   ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
   mutable int _role_cached_byte_size_;
   ::google::protobuf::uint64 privileges_;
-  ::google::protobuf::uint64 attributes_epoch_;
   ::std::string* full_name_;
   ::std::string* battle_tag_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5ftypes_2eproto();
@@ -335,6 +325,187 @@ class TC_PROTO_API FriendOfFriend : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
+class TC_PROTO_API ReceivedInvitation : public ::google::protobuf::Message {
+ public:
+  ReceivedInvitation();
+  virtual ~ReceivedInvitation();
+
+  ReceivedInvitation(const ReceivedInvitation& from);
+
+  inline ReceivedInvitation& operator=(const ReceivedInvitation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ReceivedInvitation& default_instance();
+
+  void Swap(ReceivedInvitation* other);
+
+  // implements Message ----------------------------------------------
+
+  ReceivedInvitation* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ReceivedInvitation& from);
+  void MergeFrom(const ReceivedInvitation& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required fixed64 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 id() const;
+  inline void set_id(::google::protobuf::uint64 value);
+
+  // required .bgs.protocol.Identity inviter_identity = 2;
+  inline bool has_inviter_identity() const;
+  inline void clear_inviter_identity();
+  static const int kInviterIdentityFieldNumber = 2;
+  inline const ::bgs::protocol::Identity& inviter_identity() const;
+  inline ::bgs::protocol::Identity* mutable_inviter_identity();
+  inline ::bgs::protocol::Identity* release_inviter_identity();
+  inline void set_allocated_inviter_identity(::bgs::protocol::Identity* inviter_identity);
+
+  // required .bgs.protocol.Identity invitee_identity = 3;
+  inline bool has_invitee_identity() const;
+  inline void clear_invitee_identity();
+  static const int kInviteeIdentityFieldNumber = 3;
+  inline const ::bgs::protocol::Identity& invitee_identity() const;
+  inline ::bgs::protocol::Identity* mutable_invitee_identity();
+  inline ::bgs::protocol::Identity* release_invitee_identity();
+  inline void set_allocated_invitee_identity(::bgs::protocol::Identity* invitee_identity);
+
+  // optional string inviter_name = 4;
+  inline bool has_inviter_name() const;
+  inline void clear_inviter_name();
+  static const int kInviterNameFieldNumber = 4;
+  inline const ::std::string& inviter_name() const;
+  inline void set_inviter_name(const ::std::string& value);
+  inline void set_inviter_name(const char* value);
+  inline void set_inviter_name(const char* value, size_t size);
+  inline ::std::string* mutable_inviter_name();
+  inline ::std::string* release_inviter_name();
+  inline void set_allocated_inviter_name(::std::string* inviter_name);
+
+  // optional string invitee_name = 5;
+  inline bool has_invitee_name() const;
+  inline void clear_invitee_name();
+  static const int kInviteeNameFieldNumber = 5;
+  inline const ::std::string& invitee_name() const;
+  inline void set_invitee_name(const ::std::string& value);
+  inline void set_invitee_name(const char* value);
+  inline void set_invitee_name(const char* value, size_t size);
+  inline ::std::string* mutable_invitee_name();
+  inline ::std::string* release_invitee_name();
+  inline void set_allocated_invitee_name(::std::string* invitee_name);
+
+  // optional string invitation_message = 6;
+  inline bool has_invitation_message() const;
+  inline void clear_invitation_message();
+  static const int kInvitationMessageFieldNumber = 6;
+  inline const ::std::string& invitation_message() const;
+  inline void set_invitation_message(const ::std::string& value);
+  inline void set_invitation_message(const char* value);
+  inline void set_invitation_message(const char* value, size_t size);
+  inline ::std::string* mutable_invitation_message();
+  inline ::std::string* release_invitation_message();
+  inline void set_allocated_invitation_message(::std::string* invitation_message);
+
+  // optional uint64 creation_time = 7;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 7;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // optional uint64 expiration_time = 8;
+  inline bool has_expiration_time() const;
+  inline void clear_expiration_time();
+  static const int kExpirationTimeFieldNumber = 8;
+  inline ::google::protobuf::uint64 expiration_time() const;
+  inline void set_expiration_time(::google::protobuf::uint64 value);
+
+  // optional fixed32 program = 9;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 9;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ReceivedInvitation)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.ReceivedInvitation)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_inviter_identity();
+  inline void clear_has_inviter_identity();
+  inline void set_has_invitee_identity();
+  inline void clear_has_invitee_identity();
+  inline void set_has_inviter_name();
+  inline void clear_has_inviter_name();
+  inline void set_has_invitee_name();
+  inline void clear_has_invitee_name();
+  inline void set_has_invitation_message();
+  inline void clear_has_invitation_message();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+  inline void set_has_expiration_time();
+  inline void clear_has_expiration_time();
+  inline void set_has_program();
+  inline void clear_has_program();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 id_;
+  ::bgs::protocol::Identity* inviter_identity_;
+  ::bgs::protocol::Identity* invitee_identity_;
+  ::std::string* inviter_name_;
+  ::std::string* invitee_name_;
+  ::std::string* invitation_message_;
+  ::google::protobuf::uint64 creation_time_;
+  ::google::protobuf::uint64 expiration_time_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_PROTO_API protobuf_AddDesc_friends_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_friends_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ReceivedInvitation* default_instance_;
+};
+// -------------------------------------------------------------------
+
 class TC_PROTO_API FriendInvitation : public ::google::protobuf::Message {
  public:
   FriendInvitation();
@@ -388,13 +559,6 @@ class TC_PROTO_API FriendInvitation : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional bool first_received = 1 [default = false];
-  inline bool has_first_received() const;
-  inline void clear_first_received();
-  static const int kFirstReceivedFieldNumber = 1;
-  inline bool first_received() const;
-  inline void set_first_received(bool value);
-
   // repeated uint32 role = 2 [packed = true];
   inline int role_size() const;
   inline void clear_role();
@@ -407,14 +571,24 @@ class TC_PROTO_API FriendInvitation : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
       mutable_role();
 
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 3;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
   static const int kFriendInvitationFieldNumber = 103;
-  static ::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::Invitation,
+  static ::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::friends::v1::ReceivedInvitation,
       ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitation >, 11, false >
     friend_invitation;
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.FriendInvitation)
  private:
-  inline void set_has_first_received();
-  inline void clear_has_first_received();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -422,7 +596,7 @@ class TC_PROTO_API FriendInvitation : public ::google::protobuf::Message {
   mutable int _cached_size_;
   ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
   mutable int _role_cached_byte_size_;
-  bool first_received_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5ftypes_2eproto();
   friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
   friend void protobuf_ShutdownFile_friends_5ftypes_2eproto();
@@ -432,6 +606,143 @@ class TC_PROTO_API FriendInvitation : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
+class TC_PROTO_API SentInvitation : public ::google::protobuf::Message {
+ public:
+  SentInvitation();
+  virtual ~SentInvitation();
+
+  SentInvitation(const SentInvitation& from);
+
+  inline SentInvitation& operator=(const SentInvitation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SentInvitation& default_instance();
+
+  void Swap(SentInvitation* other);
+
+  // implements Message ----------------------------------------------
+
+  SentInvitation* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SentInvitation& from);
+  void MergeFrom(const SentInvitation& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional fixed64 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 id() const;
+  inline void set_id(::google::protobuf::uint64 value);
+
+  // optional string target_name = 2;
+  inline bool has_target_name() const;
+  inline void clear_target_name();
+  static const int kTargetNameFieldNumber = 2;
+  inline const ::std::string& target_name() const;
+  inline void set_target_name(const ::std::string& value);
+  inline void set_target_name(const char* value);
+  inline void set_target_name(const char* value, size_t size);
+  inline ::std::string* mutable_target_name();
+  inline ::std::string* release_target_name();
+  inline void set_allocated_target_name(::std::string* target_name);
+
+  // optional uint32 role = 3;
+  inline bool has_role() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 3;
+  inline ::google::protobuf::uint32 role() const;
+  inline void set_role(::google::protobuf::uint32 value);
+
+  // repeated .bgs.protocol.Attribute attribute = 4;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 4;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // optional uint64 creation_time = 5;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 5;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // optional fixed32 program = 6;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 6;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SentInvitation)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_target_name();
+  inline void clear_has_target_name();
+  inline void set_has_role();
+  inline void clear_has_role();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+  inline void set_has_program();
+  inline void clear_has_program();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 id_;
+  ::std::string* target_name_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::google::protobuf::uint32 role_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint64 creation_time_;
+  friend void TC_PROTO_API protobuf_AddDesc_friends_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_friends_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static SentInvitation* default_instance_;
+};
+// -------------------------------------------------------------------
+
 class TC_PROTO_API FriendInvitationParams : public ::google::protobuf::Message {
  public:
   FriendInvitationParams();
@@ -509,42 +820,6 @@ class TC_PROTO_API FriendInvitationParams : public ::google::protobuf::Message {
   inline ::std::string* release_target_battle_tag();
   inline void set_allocated_target_battle_tag(::std::string* target_battle_tag);
 
-  // optional string inviter_battle_tag = 3;
-  inline bool has_inviter_battle_tag() const;
-  inline void clear_inviter_battle_tag();
-  static const int kInviterBattleTagFieldNumber = 3;
-  inline const ::std::string& inviter_battle_tag() const;
-  inline void set_inviter_battle_tag(const ::std::string& value);
-  inline void set_inviter_battle_tag(const char* value);
-  inline void set_inviter_battle_tag(const char* value, size_t size);
-  inline ::std::string* mutable_inviter_battle_tag();
-  inline ::std::string* release_inviter_battle_tag();
-  inline void set_allocated_inviter_battle_tag(::std::string* inviter_battle_tag);
-
-  // optional string inviter_full_name = 4;
-  inline bool has_inviter_full_name() const;
-  inline void clear_inviter_full_name();
-  static const int kInviterFullNameFieldNumber = 4;
-  inline const ::std::string& inviter_full_name() const;
-  inline void set_inviter_full_name(const ::std::string& value);
-  inline void set_inviter_full_name(const char* value);
-  inline void set_inviter_full_name(const char* value, size_t size);
-  inline ::std::string* mutable_inviter_full_name();
-  inline ::std::string* release_inviter_full_name();
-  inline void set_allocated_inviter_full_name(::std::string* inviter_full_name);
-
-  // optional string invitee_display_name = 5;
-  inline bool has_invitee_display_name() const;
-  inline void clear_invitee_display_name();
-  static const int kInviteeDisplayNameFieldNumber = 5;
-  inline const ::std::string& invitee_display_name() const;
-  inline void set_invitee_display_name(const ::std::string& value);
-  inline void set_invitee_display_name(const char* value);
-  inline void set_invitee_display_name(const char* value, size_t size);
-  inline ::std::string* mutable_invitee_display_name();
-  inline ::std::string* release_invitee_display_name();
-  inline void set_allocated_invitee_display_name(::std::string* invitee_display_name);
-
   // repeated uint32 role = 6 [packed = true];
   inline int role_size() const;
   inline void clear_role();
@@ -557,17 +832,36 @@ class TC_PROTO_API FriendInvitationParams : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
       mutable_role();
 
-  // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
-  inline int previous_role_deprecated_size() const PROTOBUF_DEPRECATED;
-  inline void clear_previous_role_deprecated() PROTOBUF_DEPRECATED;
-  static const int kPreviousRoleDeprecatedFieldNumber = 7;
-  inline ::google::protobuf::uint32 previous_role_deprecated(int index) const PROTOBUF_DEPRECATED;
-  inline void set_previous_role_deprecated(int index, ::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
-  inline void add_previous_role_deprecated(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
-  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-      previous_role_deprecated() const PROTOBUF_DEPRECATED;
-  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-      mutable_previous_role_deprecated() PROTOBUF_DEPRECATED;
+  // repeated .bgs.protocol.Attribute attribute = 8;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 8;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // optional string target_name = 9;
+  inline bool has_target_name() const;
+  inline void clear_target_name();
+  static const int kTargetNameFieldNumber = 9;
+  inline const ::std::string& target_name() const;
+  inline void set_target_name(const ::std::string& value);
+  inline void set_target_name(const char* value);
+  inline void set_target_name(const char* value, size_t size);
+  inline ::std::string* mutable_target_name();
+  inline ::std::string* release_target_name();
+  inline void set_allocated_target_name(::std::string* target_name);
+
+  // optional fixed32 program = 10 [deprecated = true];
+  inline bool has_program() const PROTOBUF_DEPRECATED;
+  inline void clear_program() PROTOBUF_DEPRECATED;
+  static const int kProgramFieldNumber = 10;
+  inline ::google::protobuf::uint32 program() const PROTOBUF_DEPRECATED;
+  inline void set_program(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
 
   static const int kFriendParamsFieldNumber = 103;
   static ::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::InvitationParams,
@@ -579,12 +873,10 @@ class TC_PROTO_API FriendInvitationParams : public ::google::protobuf::Message {
   inline void clear_has_target_email();
   inline void set_has_target_battle_tag();
   inline void clear_has_target_battle_tag();
-  inline void set_has_inviter_battle_tag();
-  inline void clear_has_inviter_battle_tag();
-  inline void set_has_inviter_full_name();
-  inline void clear_has_inviter_full_name();
-  inline void set_has_invitee_display_name();
-  inline void clear_has_invitee_display_name();
+  inline void set_has_target_name();
+  inline void clear_has_target_name();
+  inline void set_has_program();
+  inline void clear_has_program();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -592,13 +884,11 @@ class TC_PROTO_API FriendInvitationParams : public ::google::protobuf::Message {
   mutable int _cached_size_;
   ::std::string* target_email_;
   ::std::string* target_battle_tag_;
-  ::std::string* inviter_battle_tag_;
-  ::std::string* inviter_full_name_;
-  ::std::string* invitee_display_name_;
   ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
   mutable int _role_cached_byte_size_;
-  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > previous_role_deprecated_;
-  mutable int _previous_role_deprecated_cached_byte_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::std::string* target_name_;
+  ::google::protobuf::uint32 program_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5ftypes_2eproto();
   friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
   friend void protobuf_ShutdownFile_friends_5ftypes_2eproto();
@@ -706,30 +996,30 @@ class TC_PROTO_API SubscribeResponse : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >*
       mutable_friends();
 
-  // repeated .bgs.protocol.Invitation sent_invitations = 6;
-  inline int sent_invitations_size() const;
-  inline void clear_sent_invitations();
-  static const int kSentInvitationsFieldNumber = 6;
-  inline const ::bgs::protocol::Invitation& sent_invitations(int index) const;
-  inline ::bgs::protocol::Invitation* mutable_sent_invitations(int index);
-  inline ::bgs::protocol::Invitation* add_sent_invitations();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
-      sent_invitations() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
-      mutable_sent_invitations();
-
-  // repeated .bgs.protocol.Invitation received_invitations = 7;
+  // repeated .bgs.protocol.friends.v1.ReceivedInvitation received_invitations = 7;
   inline int received_invitations_size() const;
   inline void clear_received_invitations();
   static const int kReceivedInvitationsFieldNumber = 7;
-  inline const ::bgs::protocol::Invitation& received_invitations(int index) const;
-  inline ::bgs::protocol::Invitation* mutable_received_invitations(int index);
-  inline ::bgs::protocol::Invitation* add_received_invitations();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
+  inline const ::bgs::protocol::friends::v1::ReceivedInvitation& received_invitations(int index) const;
+  inline ::bgs::protocol::friends::v1::ReceivedInvitation* mutable_received_invitations(int index);
+  inline ::bgs::protocol::friends::v1::ReceivedInvitation* add_received_invitations();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::ReceivedInvitation >&
       received_invitations() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::ReceivedInvitation >*
       mutable_received_invitations();
 
+  // repeated .bgs.protocol.friends.v1.SentInvitation sent_invitations = 8;
+  inline int sent_invitations_size() const;
+  inline void clear_sent_invitations();
+  static const int kSentInvitationsFieldNumber = 8;
+  inline const ::bgs::protocol::friends::v1::SentInvitation& sent_invitations(int index) const;
+  inline ::bgs::protocol::friends::v1::SentInvitation* mutable_sent_invitations(int index);
+  inline ::bgs::protocol::friends::v1::SentInvitation* add_sent_invitations();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::SentInvitation >&
+      sent_invitations() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::SentInvitation >*
+      mutable_sent_invitations();
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SubscribeResponse)
  private:
   inline void set_has_max_friends();
@@ -747,8 +1037,8 @@ class TC_PROTO_API SubscribeResponse : public ::google::protobuf::Message {
   ::google::protobuf::uint32 max_received_invitations_;
   ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role > role_;
   ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend > friends_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation > sent_invitations_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation > received_invitations_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::ReceivedInvitation > received_invitations_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::SentInvitation > sent_invitations_;
   ::google::protobuf::uint32 max_sent_invitations_;
   friend void TC_PROTO_API protobuf_AddDesc_friends_5ftypes_2eproto();
   friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
@@ -757,6 +1047,95 @@ class TC_PROTO_API SubscribeResponse : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static SubscribeResponse* default_instance_;
 };
+// -------------------------------------------------------------------
+
+class TC_PROTO_API AcceptInvitationOptions : public ::google::protobuf::Message {
+ public:
+  AcceptInvitationOptions();
+  virtual ~AcceptInvitationOptions();
+
+  AcceptInvitationOptions(const AcceptInvitationOptions& from);
+
+  inline AcceptInvitationOptions& operator=(const AcceptInvitationOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AcceptInvitationOptions& default_instance();
+
+  void Swap(AcceptInvitationOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  AcceptInvitationOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AcceptInvitationOptions& from);
+  void MergeFrom(const AcceptInvitationOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint32 role = 1;
+  inline bool has_role() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 1;
+  inline ::google::protobuf::uint32 role() const;
+  inline void set_role(::google::protobuf::uint32 value);
+
+  // optional fixed32 program = 2;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 2;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.AcceptInvitationOptions)
+ private:
+  inline void set_has_role();
+  inline void clear_has_role();
+  inline void set_has_program();
+  inline void clear_has_program();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 role_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_PROTO_API protobuf_AddDesc_friends_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_friends_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AcceptInvitationOptions* default_instance_;
+};
 // ===================================================================
 
 
@@ -868,7 +1247,7 @@ Friend::mutable_role() {
   return &role_;
 }
 
-// optional uint64 privileges = 4 [default = 0];
+// optional uint64 privileges = 4;
 inline bool Friend::has_privileges() const {
   return (_has_bits_[0] & 0x00000008u) != 0;
 }
@@ -892,7 +1271,7 @@ inline void Friend::set_privileges(::google::protobuf::uint64 value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.privileges)
 }
 
-// optional uint64 attributes_epoch = 5;
+// optional uint64 attributes_epoch = 5 [deprecated = true];
 inline bool Friend::has_attributes_epoch() const {
   return (_has_bits_[0] & 0x00000010u) != 0;
 }
@@ -916,6 +1295,30 @@ inline void Friend::set_attributes_epoch(::google::protobuf::uint64 value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.attributes_epoch)
 }
 
+// optional uint64 creation_time = 6;
+inline bool Friend::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Friend::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Friend::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Friend::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 Friend::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.creation_time)
+  return creation_time_;
+}
+inline void Friend::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.creation_time)
+}
+
 // -------------------------------------------------------------------
 
 // FriendOfFriend
@@ -961,36 +1364,6 @@ inline void FriendOfFriend::set_allocated_account_id(::bgs::protocol::EntityId*
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendOfFriend.account_id)
 }
 
-// repeated .bgs.protocol.Attribute attribute = 2;
-inline int FriendOfFriend::attribute_size() const {
-  return attribute_.size();
-}
-inline void FriendOfFriend::clear_attribute() {
-  attribute_.Clear();
-}
-inline const ::bgs::protocol::Attribute& FriendOfFriend::attribute(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendOfFriend.attribute)
-  return attribute_.Get(index);
-}
-inline ::bgs::protocol::Attribute* FriendOfFriend::mutable_attribute(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendOfFriend.attribute)
-  return attribute_.Mutable(index);
-}
-inline ::bgs::protocol::Attribute* FriendOfFriend::add_attribute() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendOfFriend.attribute)
-  return attribute_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
-FriendOfFriend::attribute() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendOfFriend.attribute)
-  return attribute_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
-FriendOfFriend::mutable_attribute() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendOfFriend.attribute)
-  return &attribute_;
-}
-
 // repeated uint32 role = 3 [packed = true];
 inline int FriendOfFriend::role_size() const {
   return role_.size();
@@ -1021,15 +1394,15 @@ FriendOfFriend::mutable_role() {
   return &role_;
 }
 
-// optional uint64 privileges = 4 [default = 0];
+// optional uint64 privileges = 4;
 inline bool FriendOfFriend::has_privileges() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
+  return (_has_bits_[0] & 0x00000004u) != 0;
 }
 inline void FriendOfFriend::set_has_privileges() {
-  _has_bits_[0] |= 0x00000008u;
+  _has_bits_[0] |= 0x00000004u;
 }
 inline void FriendOfFriend::clear_has_privileges() {
-  _has_bits_[0] &= ~0x00000008u;
+  _has_bits_[0] &= ~0x00000004u;
 }
 inline void FriendOfFriend::clear_privileges() {
   privileges_ = GOOGLE_ULONGLONG(0);
@@ -1045,39 +1418,15 @@ inline void FriendOfFriend::set_privileges(::google::protobuf::uint64 value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendOfFriend.privileges)
 }
 
-// optional uint64 attributes_epoch = 5;
-inline bool FriendOfFriend::has_attributes_epoch() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void FriendOfFriend::set_has_attributes_epoch() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void FriendOfFriend::clear_has_attributes_epoch() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void FriendOfFriend::clear_attributes_epoch() {
-  attributes_epoch_ = GOOGLE_ULONGLONG(0);
-  clear_has_attributes_epoch();
-}
-inline ::google::protobuf::uint64 FriendOfFriend::attributes_epoch() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendOfFriend.attributes_epoch)
-  return attributes_epoch_;
-}
-inline void FriendOfFriend::set_attributes_epoch(::google::protobuf::uint64 value) {
-  set_has_attributes_epoch();
-  attributes_epoch_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendOfFriend.attributes_epoch)
-}
-
 // optional string full_name = 6;
 inline bool FriendOfFriend::has_full_name() const {
-  return (_has_bits_[0] & 0x00000020u) != 0;
+  return (_has_bits_[0] & 0x00000008u) != 0;
 }
 inline void FriendOfFriend::set_has_full_name() {
-  _has_bits_[0] |= 0x00000020u;
+  _has_bits_[0] |= 0x00000008u;
 }
 inline void FriendOfFriend::clear_has_full_name() {
-  _has_bits_[0] &= ~0x00000020u;
+  _has_bits_[0] &= ~0x00000008u;
 }
 inline void FriendOfFriend::clear_full_name() {
   if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
@@ -1147,13 +1496,13 @@ inline void FriendOfFriend::set_allocated_full_name(::std::string* full_name) {
 
 // optional string battle_tag = 7;
 inline bool FriendOfFriend::has_battle_tag() const {
-  return (_has_bits_[0] & 0x00000040u) != 0;
+  return (_has_bits_[0] & 0x00000010u) != 0;
 }
 inline void FriendOfFriend::set_has_battle_tag() {
-  _has_bits_[0] |= 0x00000040u;
+  _has_bits_[0] |= 0x00000010u;
 }
 inline void FriendOfFriend::clear_has_battle_tag() {
-  _has_bits_[0] &= ~0x00000040u;
+  _has_bits_[0] &= ~0x00000010u;
 }
 inline void FriendOfFriend::clear_battle_tag() {
   if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
@@ -1223,32 +1572,418 @@ inline void FriendOfFriend::set_allocated_battle_tag(::std::string* battle_tag)
 
 // -------------------------------------------------------------------
 
-// FriendInvitation
+// ReceivedInvitation
 
-// optional bool first_received = 1 [default = false];
-inline bool FriendInvitation::has_first_received() const {
+// required fixed64 id = 1;
+inline bool ReceivedInvitation::has_id() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void FriendInvitation::set_has_first_received() {
+inline void ReceivedInvitation::set_has_id() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void FriendInvitation::clear_has_first_received() {
+inline void ReceivedInvitation::clear_has_id() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void FriendInvitation::clear_first_received() {
-  first_received_ = false;
-  clear_has_first_received();
+inline void ReceivedInvitation::clear_id() {
+  id_ = GOOGLE_ULONGLONG(0);
+  clear_has_id();
+}
+inline ::google::protobuf::uint64 ReceivedInvitation::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ReceivedInvitation.id)
+  return id_;
+}
+inline void ReceivedInvitation::set_id(::google::protobuf::uint64 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ReceivedInvitation.id)
+}
+
+// required .bgs.protocol.Identity inviter_identity = 2;
+inline bool ReceivedInvitation::has_inviter_identity() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ReceivedInvitation::set_has_inviter_identity() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ReceivedInvitation::clear_has_inviter_identity() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ReceivedInvitation::clear_inviter_identity() {
+  if (inviter_identity_ != NULL) inviter_identity_->::bgs::protocol::Identity::Clear();
+  clear_has_inviter_identity();
+}
+inline const ::bgs::protocol::Identity& ReceivedInvitation::inviter_identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ReceivedInvitation.inviter_identity)
+  return inviter_identity_ != NULL ? *inviter_identity_ : *default_instance_->inviter_identity_;
+}
+inline ::bgs::protocol::Identity* ReceivedInvitation::mutable_inviter_identity() {
+  set_has_inviter_identity();
+  if (inviter_identity_ == NULL) inviter_identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ReceivedInvitation.inviter_identity)
+  return inviter_identity_;
+}
+inline ::bgs::protocol::Identity* ReceivedInvitation::release_inviter_identity() {
+  clear_has_inviter_identity();
+  ::bgs::protocol::Identity* temp = inviter_identity_;
+  inviter_identity_ = NULL;
+  return temp;
+}
+inline void ReceivedInvitation::set_allocated_inviter_identity(::bgs::protocol::Identity* inviter_identity) {
+  delete inviter_identity_;
+  inviter_identity_ = inviter_identity;
+  if (inviter_identity) {
+    set_has_inviter_identity();
+  } else {
+    clear_has_inviter_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ReceivedInvitation.inviter_identity)
+}
+
+// required .bgs.protocol.Identity invitee_identity = 3;
+inline bool ReceivedInvitation::has_invitee_identity() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ReceivedInvitation::set_has_invitee_identity() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ReceivedInvitation::clear_has_invitee_identity() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ReceivedInvitation::clear_invitee_identity() {
+  if (invitee_identity_ != NULL) invitee_identity_->::bgs::protocol::Identity::Clear();
+  clear_has_invitee_identity();
+}
+inline const ::bgs::protocol::Identity& ReceivedInvitation::invitee_identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ReceivedInvitation.invitee_identity)
+  return invitee_identity_ != NULL ? *invitee_identity_ : *default_instance_->invitee_identity_;
+}
+inline ::bgs::protocol::Identity* ReceivedInvitation::mutable_invitee_identity() {
+  set_has_invitee_identity();
+  if (invitee_identity_ == NULL) invitee_identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ReceivedInvitation.invitee_identity)
+  return invitee_identity_;
+}
+inline ::bgs::protocol::Identity* ReceivedInvitation::release_invitee_identity() {
+  clear_has_invitee_identity();
+  ::bgs::protocol::Identity* temp = invitee_identity_;
+  invitee_identity_ = NULL;
+  return temp;
+}
+inline void ReceivedInvitation::set_allocated_invitee_identity(::bgs::protocol::Identity* invitee_identity) {
+  delete invitee_identity_;
+  invitee_identity_ = invitee_identity;
+  if (invitee_identity) {
+    set_has_invitee_identity();
+  } else {
+    clear_has_invitee_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ReceivedInvitation.invitee_identity)
+}
+
+// optional string inviter_name = 4;
+inline bool ReceivedInvitation::has_inviter_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ReceivedInvitation::set_has_inviter_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ReceivedInvitation::clear_has_inviter_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ReceivedInvitation::clear_inviter_name() {
+  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_->clear();
+  }
+  clear_has_inviter_name();
+}
+inline const ::std::string& ReceivedInvitation::inviter_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ReceivedInvitation.inviter_name)
+  return *inviter_name_;
+}
+inline void ReceivedInvitation::set_inviter_name(const ::std::string& value) {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  inviter_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ReceivedInvitation.inviter_name)
+}
+inline void ReceivedInvitation::set_inviter_name(const char* value) {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  inviter_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.ReceivedInvitation.inviter_name)
+}
+inline void ReceivedInvitation::set_inviter_name(const char* value, size_t size) {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  inviter_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.ReceivedInvitation.inviter_name)
+}
+inline ::std::string* ReceivedInvitation::mutable_inviter_name() {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ReceivedInvitation.inviter_name)
+  return inviter_name_;
+}
+inline ::std::string* ReceivedInvitation::release_inviter_name() {
+  clear_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = inviter_name_;
+    inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ReceivedInvitation::set_allocated_inviter_name(::std::string* inviter_name) {
+  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_name_;
+  }
+  if (inviter_name) {
+    set_has_inviter_name();
+    inviter_name_ = inviter_name;
+  } else {
+    clear_has_inviter_name();
+    inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ReceivedInvitation.inviter_name)
 }
-inline bool FriendInvitation::first_received() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitation.first_received)
-  return first_received_;
+
+// optional string invitee_name = 5;
+inline bool ReceivedInvitation::has_invitee_name() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
 }
-inline void FriendInvitation::set_first_received(bool value) {
-  set_has_first_received();
-  first_received_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitation.first_received)
+inline void ReceivedInvitation::set_has_invitee_name() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ReceivedInvitation::clear_has_invitee_name() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ReceivedInvitation::clear_invitee_name() {
+  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_->clear();
+  }
+  clear_has_invitee_name();
+}
+inline const ::std::string& ReceivedInvitation::invitee_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ReceivedInvitation.invitee_name)
+  return *invitee_name_;
+}
+inline void ReceivedInvitation::set_invitee_name(const ::std::string& value) {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  invitee_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ReceivedInvitation.invitee_name)
+}
+inline void ReceivedInvitation::set_invitee_name(const char* value) {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  invitee_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.ReceivedInvitation.invitee_name)
+}
+inline void ReceivedInvitation::set_invitee_name(const char* value, size_t size) {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  invitee_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.ReceivedInvitation.invitee_name)
+}
+inline ::std::string* ReceivedInvitation::mutable_invitee_name() {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ReceivedInvitation.invitee_name)
+  return invitee_name_;
+}
+inline ::std::string* ReceivedInvitation::release_invitee_name() {
+  clear_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = invitee_name_;
+    invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ReceivedInvitation::set_allocated_invitee_name(::std::string* invitee_name) {
+  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitee_name_;
+  }
+  if (invitee_name) {
+    set_has_invitee_name();
+    invitee_name_ = invitee_name;
+  } else {
+    clear_has_invitee_name();
+    invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ReceivedInvitation.invitee_name)
 }
 
+// optional string invitation_message = 6;
+inline bool ReceivedInvitation::has_invitation_message() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ReceivedInvitation::set_has_invitation_message() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ReceivedInvitation::clear_has_invitation_message() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ReceivedInvitation::clear_invitation_message() {
+  if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_->clear();
+  }
+  clear_has_invitation_message();
+}
+inline const ::std::string& ReceivedInvitation::invitation_message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ReceivedInvitation.invitation_message)
+  return *invitation_message_;
+}
+inline void ReceivedInvitation::set_invitation_message(const ::std::string& value) {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  invitation_message_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ReceivedInvitation.invitation_message)
+}
+inline void ReceivedInvitation::set_invitation_message(const char* value) {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  invitation_message_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.ReceivedInvitation.invitation_message)
+}
+inline void ReceivedInvitation::set_invitation_message(const char* value, size_t size) {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  invitation_message_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.ReceivedInvitation.invitation_message)
+}
+inline ::std::string* ReceivedInvitation::mutable_invitation_message() {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ReceivedInvitation.invitation_message)
+  return invitation_message_;
+}
+inline ::std::string* ReceivedInvitation::release_invitation_message() {
+  clear_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = invitation_message_;
+    invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ReceivedInvitation::set_allocated_invitation_message(::std::string* invitation_message) {
+  if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitation_message_;
+  }
+  if (invitation_message) {
+    set_has_invitation_message();
+    invitation_message_ = invitation_message;
+  } else {
+    clear_has_invitation_message();
+    invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ReceivedInvitation.invitation_message)
+}
+
+// optional uint64 creation_time = 7;
+inline bool ReceivedInvitation::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ReceivedInvitation::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ReceivedInvitation::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ReceivedInvitation::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 ReceivedInvitation::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ReceivedInvitation.creation_time)
+  return creation_time_;
+}
+inline void ReceivedInvitation::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ReceivedInvitation.creation_time)
+}
+
+// optional uint64 expiration_time = 8;
+inline bool ReceivedInvitation::has_expiration_time() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ReceivedInvitation::set_has_expiration_time() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ReceivedInvitation::clear_has_expiration_time() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ReceivedInvitation::clear_expiration_time() {
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_expiration_time();
+}
+inline ::google::protobuf::uint64 ReceivedInvitation::expiration_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ReceivedInvitation.expiration_time)
+  return expiration_time_;
+}
+inline void ReceivedInvitation::set_expiration_time(::google::protobuf::uint64 value) {
+  set_has_expiration_time();
+  expiration_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ReceivedInvitation.expiration_time)
+}
+
+// optional fixed32 program = 9;
+inline bool ReceivedInvitation::has_program() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ReceivedInvitation::set_has_program() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ReceivedInvitation::clear_has_program() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ReceivedInvitation::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 ReceivedInvitation::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ReceivedInvitation.program)
+  return program_;
+}
+inline void ReceivedInvitation::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ReceivedInvitation.program)
+}
+
+// -------------------------------------------------------------------
+
+// FriendInvitation
+
 // repeated uint32 role = 2 [packed = true];
 inline int FriendInvitation::role_size() const {
   return role_.size();
@@ -1279,6 +2014,242 @@ FriendInvitation::mutable_role() {
   return &role_;
 }
 
+// repeated .bgs.protocol.Attribute attribute = 3;
+inline int FriendInvitation::attribute_size() const {
+  return attribute_.size();
+}
+inline void FriendInvitation::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& FriendInvitation::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitation.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* FriendInvitation::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitation.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* FriendInvitation::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitation.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+FriendInvitation::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitation.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+FriendInvitation::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitation.attribute)
+  return &attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// SentInvitation
+
+// optional fixed64 id = 1;
+inline bool SentInvitation::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SentInvitation::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SentInvitation::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SentInvitation::clear_id() {
+  id_ = GOOGLE_ULONGLONG(0);
+  clear_has_id();
+}
+inline ::google::protobuf::uint64 SentInvitation::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitation.id)
+  return id_;
+}
+inline void SentInvitation::set_id(::google::protobuf::uint64 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SentInvitation.id)
+}
+
+// optional string target_name = 2;
+inline bool SentInvitation::has_target_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SentInvitation::set_has_target_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SentInvitation::clear_has_target_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SentInvitation::clear_target_name() {
+  if (target_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_->clear();
+  }
+  clear_has_target_name();
+}
+inline const ::std::string& SentInvitation::target_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitation.target_name)
+  return *target_name_;
+}
+inline void SentInvitation::set_target_name(const ::std::string& value) {
+  set_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_ = new ::std::string;
+  }
+  target_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SentInvitation.target_name)
+}
+inline void SentInvitation::set_target_name(const char* value) {
+  set_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_ = new ::std::string;
+  }
+  target_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.SentInvitation.target_name)
+}
+inline void SentInvitation::set_target_name(const char* value, size_t size) {
+  set_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_ = new ::std::string;
+  }
+  target_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.SentInvitation.target_name)
+}
+inline ::std::string* SentInvitation::mutable_target_name() {
+  set_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SentInvitation.target_name)
+  return target_name_;
+}
+inline ::std::string* SentInvitation::release_target_name() {
+  clear_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = target_name_;
+    target_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void SentInvitation::set_allocated_target_name(::std::string* target_name) {
+  if (target_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_name_;
+  }
+  if (target_name) {
+    set_has_target_name();
+    target_name_ = target_name;
+  } else {
+    clear_has_target_name();
+    target_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SentInvitation.target_name)
+}
+
+// optional uint32 role = 3;
+inline bool SentInvitation::has_role() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SentInvitation::set_has_role() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SentInvitation::clear_has_role() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SentInvitation::clear_role() {
+  role_ = 0u;
+  clear_has_role();
+}
+inline ::google::protobuf::uint32 SentInvitation::role() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitation.role)
+  return role_;
+}
+inline void SentInvitation::set_role(::google::protobuf::uint32 value) {
+  set_has_role();
+  role_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SentInvitation.role)
+}
+
+// repeated .bgs.protocol.Attribute attribute = 4;
+inline int SentInvitation::attribute_size() const {
+  return attribute_.size();
+}
+inline void SentInvitation::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& SentInvitation::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitation.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* SentInvitation::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SentInvitation.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* SentInvitation::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SentInvitation.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+SentInvitation::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SentInvitation.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+SentInvitation::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SentInvitation.attribute)
+  return &attribute_;
+}
+
+// optional uint64 creation_time = 5;
+inline bool SentInvitation::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void SentInvitation::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void SentInvitation::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void SentInvitation::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 SentInvitation::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitation.creation_time)
+  return creation_time_;
+}
+inline void SentInvitation::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SentInvitation.creation_time)
+}
+
+// optional fixed32 program = 6;
+inline bool SentInvitation::has_program() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void SentInvitation::set_has_program() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void SentInvitation::clear_has_program() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void SentInvitation::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 SentInvitation::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SentInvitation.program)
+  return program_;
+}
+inline void SentInvitation::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SentInvitation.program)
+}
+
 // -------------------------------------------------------------------
 
 // FriendInvitationParams
@@ -1435,292 +2406,164 @@ inline void FriendInvitationParams::set_allocated_target_battle_tag(::std::strin
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag)
 }
 
-// optional string inviter_battle_tag = 3;
-inline bool FriendInvitationParams::has_inviter_battle_tag() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void FriendInvitationParams::set_has_inviter_battle_tag() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void FriendInvitationParams::clear_has_inviter_battle_tag() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void FriendInvitationParams::clear_inviter_battle_tag() {
-  if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_battle_tag_->clear();
-  }
-  clear_has_inviter_battle_tag();
-}
-inline const ::std::string& FriendInvitationParams::inviter_battle_tag() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
-  return *inviter_battle_tag_;
+// repeated uint32 role = 6 [packed = true];
+inline int FriendInvitationParams::role_size() const {
+  return role_.size();
 }
-inline void FriendInvitationParams::set_inviter_battle_tag(const ::std::string& value) {
-  set_has_inviter_battle_tag();
-  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_battle_tag_ = new ::std::string;
-  }
-  inviter_battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+inline void FriendInvitationParams::clear_role() {
+  role_.Clear();
 }
-inline void FriendInvitationParams::set_inviter_battle_tag(const char* value) {
-  set_has_inviter_battle_tag();
-  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_battle_tag_ = new ::std::string;
-  }
-  inviter_battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+inline ::google::protobuf::uint32 FriendInvitationParams::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.role)
+  return role_.Get(index);
 }
-inline void FriendInvitationParams::set_inviter_battle_tag(const char* value, size_t size) {
-  set_has_inviter_battle_tag();
-  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_battle_tag_ = new ::std::string;
-  }
-  inviter_battle_tag_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+inline void FriendInvitationParams::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.role)
 }
-inline ::std::string* FriendInvitationParams::mutable_inviter_battle_tag() {
-  set_has_inviter_battle_tag();
-  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_battle_tag_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
-  return inviter_battle_tag_;
+inline void FriendInvitationParams::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitationParams.role)
 }
-inline ::std::string* FriendInvitationParams::release_inviter_battle_tag() {
-  clear_has_inviter_battle_tag();
-  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = inviter_battle_tag_;
-    inviter_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+FriendInvitationParams::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitationParams.role)
+  return role_;
 }
-inline void FriendInvitationParams::set_allocated_inviter_battle_tag(::std::string* inviter_battle_tag) {
-  if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete inviter_battle_tag_;
-  }
-  if (inviter_battle_tag) {
-    set_has_inviter_battle_tag();
-    inviter_battle_tag_ = inviter_battle_tag;
-  } else {
-    clear_has_inviter_battle_tag();
-    inviter_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+FriendInvitationParams::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitationParams.role)
+  return &role_;
 }
 
-// optional string inviter_full_name = 4;
-inline bool FriendInvitationParams::has_inviter_full_name() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void FriendInvitationParams::set_has_inviter_full_name() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void FriendInvitationParams::clear_has_inviter_full_name() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void FriendInvitationParams::clear_inviter_full_name() {
-  if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_full_name_->clear();
-  }
-  clear_has_inviter_full_name();
-}
-inline const ::std::string& FriendInvitationParams::inviter_full_name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
-  return *inviter_full_name_;
+// repeated .bgs.protocol.Attribute attribute = 8;
+inline int FriendInvitationParams::attribute_size() const {
+  return attribute_.size();
 }
-inline void FriendInvitationParams::set_inviter_full_name(const ::std::string& value) {
-  set_has_inviter_full_name();
-  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_full_name_ = new ::std::string;
-  }
-  inviter_full_name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+inline void FriendInvitationParams::clear_attribute() {
+  attribute_.Clear();
 }
-inline void FriendInvitationParams::set_inviter_full_name(const char* value) {
-  set_has_inviter_full_name();
-  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_full_name_ = new ::std::string;
-  }
-  inviter_full_name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+inline const ::bgs::protocol::Attribute& FriendInvitationParams::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.attribute)
+  return attribute_.Get(index);
 }
-inline void FriendInvitationParams::set_inviter_full_name(const char* value, size_t size) {
-  set_has_inviter_full_name();
-  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_full_name_ = new ::std::string;
-  }
-  inviter_full_name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+inline ::bgs::protocol::Attribute* FriendInvitationParams::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.attribute)
+  return attribute_.Mutable(index);
 }
-inline ::std::string* FriendInvitationParams::mutable_inviter_full_name() {
-  set_has_inviter_full_name();
-  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_full_name_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
-  return inviter_full_name_;
+inline ::bgs::protocol::Attribute* FriendInvitationParams::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitationParams.attribute)
+  return attribute_.Add();
 }
-inline ::std::string* FriendInvitationParams::release_inviter_full_name() {
-  clear_has_inviter_full_name();
-  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = inviter_full_name_;
-    inviter_full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+FriendInvitationParams::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitationParams.attribute)
+  return attribute_;
 }
-inline void FriendInvitationParams::set_allocated_inviter_full_name(::std::string* inviter_full_name) {
-  if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete inviter_full_name_;
-  }
-  if (inviter_full_name) {
-    set_has_inviter_full_name();
-    inviter_full_name_ = inviter_full_name;
-  } else {
-    clear_has_inviter_full_name();
-    inviter_full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+FriendInvitationParams::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitationParams.attribute)
+  return &attribute_;
 }
 
-// optional string invitee_display_name = 5;
-inline bool FriendInvitationParams::has_invitee_display_name() const {
+// optional string target_name = 9;
+inline bool FriendInvitationParams::has_target_name() const {
   return (_has_bits_[0] & 0x00000010u) != 0;
 }
-inline void FriendInvitationParams::set_has_invitee_display_name() {
+inline void FriendInvitationParams::set_has_target_name() {
   _has_bits_[0] |= 0x00000010u;
 }
-inline void FriendInvitationParams::clear_has_invitee_display_name() {
+inline void FriendInvitationParams::clear_has_target_name() {
   _has_bits_[0] &= ~0x00000010u;
 }
-inline void FriendInvitationParams::clear_invitee_display_name() {
-  if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_display_name_->clear();
+inline void FriendInvitationParams::clear_target_name() {
+  if (target_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_->clear();
   }
-  clear_has_invitee_display_name();
+  clear_has_target_name();
 }
-inline const ::std::string& FriendInvitationParams::invitee_display_name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
-  return *invitee_display_name_;
+inline const ::std::string& FriendInvitationParams::target_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.target_name)
+  return *target_name_;
 }
-inline void FriendInvitationParams::set_invitee_display_name(const ::std::string& value) {
-  set_has_invitee_display_name();
-  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_display_name_ = new ::std::string;
+inline void FriendInvitationParams::set_target_name(const ::std::string& value) {
+  set_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_ = new ::std::string;
   }
-  invitee_display_name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+  target_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.target_name)
 }
-inline void FriendInvitationParams::set_invitee_display_name(const char* value) {
-  set_has_invitee_display_name();
-  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_display_name_ = new ::std::string;
+inline void FriendInvitationParams::set_target_name(const char* value) {
+  set_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_ = new ::std::string;
   }
-  invitee_display_name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+  target_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.target_name)
 }
-inline void FriendInvitationParams::set_invitee_display_name(const char* value, size_t size) {
-  set_has_invitee_display_name();
-  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_display_name_ = new ::std::string;
+inline void FriendInvitationParams::set_target_name(const char* value, size_t size) {
+  set_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_ = new ::std::string;
   }
-  invitee_display_name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+  target_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.target_name)
 }
-inline ::std::string* FriendInvitationParams::mutable_invitee_display_name() {
-  set_has_invitee_display_name();
-  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_display_name_ = new ::std::string;
+inline ::std::string* FriendInvitationParams::mutable_target_name() {
+  set_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_name_ = new ::std::string;
   }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
-  return invitee_display_name_;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.target_name)
+  return target_name_;
 }
-inline ::std::string* FriendInvitationParams::release_invitee_display_name() {
-  clear_has_invitee_display_name();
-  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+inline ::std::string* FriendInvitationParams::release_target_name() {
+  clear_has_target_name();
+  if (target_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     return NULL;
   } else {
-    ::std::string* temp = invitee_display_name_;
-    invitee_display_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    ::std::string* temp = target_name_;
+    target_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
     return temp;
   }
 }
-inline void FriendInvitationParams::set_allocated_invitee_display_name(::std::string* invitee_display_name) {
-  if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete invitee_display_name_;
+inline void FriendInvitationParams::set_allocated_target_name(::std::string* target_name) {
+  if (target_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_name_;
   }
-  if (invitee_display_name) {
-    set_has_invitee_display_name();
-    invitee_display_name_ = invitee_display_name;
+  if (target_name) {
+    set_has_target_name();
+    target_name_ = target_name;
   } else {
-    clear_has_invitee_display_name();
-    invitee_display_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    clear_has_target_name();
+    target_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.target_name)
 }
 
-// repeated uint32 role = 6 [packed = true];
-inline int FriendInvitationParams::role_size() const {
-  return role_.size();
-}
-inline void FriendInvitationParams::clear_role() {
-  role_.Clear();
-}
-inline ::google::protobuf::uint32 FriendInvitationParams::role(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.role)
-  return role_.Get(index);
-}
-inline void FriendInvitationParams::set_role(int index, ::google::protobuf::uint32 value) {
-  role_.Set(index, value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.role)
-}
-inline void FriendInvitationParams::add_role(::google::protobuf::uint32 value) {
-  role_.Add(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitationParams.role)
-}
-inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-FriendInvitationParams::role() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitationParams.role)
-  return role_;
-}
-inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-FriendInvitationParams::mutable_role() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitationParams.role)
-  return &role_;
-}
-
-// repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
-inline int FriendInvitationParams::previous_role_deprecated_size() const {
-  return previous_role_deprecated_.size();
-}
-inline void FriendInvitationParams::clear_previous_role_deprecated() {
-  previous_role_deprecated_.Clear();
+// optional fixed32 program = 10 [deprecated = true];
+inline bool FriendInvitationParams::has_program() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
 }
-inline ::google::protobuf::uint32 FriendInvitationParams::previous_role_deprecated(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
-  return previous_role_deprecated_.Get(index);
+inline void FriendInvitationParams::set_has_program() {
+  _has_bits_[0] |= 0x00000020u;
 }
-inline void FriendInvitationParams::set_previous_role_deprecated(int index, ::google::protobuf::uint32 value) {
-  previous_role_deprecated_.Set(index, value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
+inline void FriendInvitationParams::clear_has_program() {
+  _has_bits_[0] &= ~0x00000020u;
 }
-inline void FriendInvitationParams::add_previous_role_deprecated(::google::protobuf::uint32 value) {
-  previous_role_deprecated_.Add(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
+inline void FriendInvitationParams::clear_program() {
+  program_ = 0u;
+  clear_has_program();
 }
-inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-FriendInvitationParams::previous_role_deprecated() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
-  return previous_role_deprecated_;
+inline ::google::protobuf::uint32 FriendInvitationParams::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.program)
+  return program_;
 }
-inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-FriendInvitationParams::mutable_previous_role_deprecated() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
-  return &previous_role_deprecated_;
+inline void FriendInvitationParams::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.program)
 }
 
 // -------------------------------------------------------------------
@@ -1859,64 +2702,116 @@ SubscribeResponse::mutable_friends() {
   return &friends_;
 }
 
-// repeated .bgs.protocol.Invitation sent_invitations = 6;
+// repeated .bgs.protocol.friends.v1.ReceivedInvitation received_invitations = 7;
+inline int SubscribeResponse::received_invitations_size() const {
+  return received_invitations_.size();
+}
+inline void SubscribeResponse::clear_received_invitations() {
+  received_invitations_.Clear();
+}
+inline const ::bgs::protocol::friends::v1::ReceivedInvitation& SubscribeResponse::received_invitations(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return received_invitations_.Get(index);
+}
+inline ::bgs::protocol::friends::v1::ReceivedInvitation* SubscribeResponse::mutable_received_invitations(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return received_invitations_.Mutable(index);
+}
+inline ::bgs::protocol::friends::v1::ReceivedInvitation* SubscribeResponse::add_received_invitations() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return received_invitations_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::ReceivedInvitation >&
+SubscribeResponse::received_invitations() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return received_invitations_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::ReceivedInvitation >*
+SubscribeResponse::mutable_received_invitations() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return &received_invitations_;
+}
+
+// repeated .bgs.protocol.friends.v1.SentInvitation sent_invitations = 8;
 inline int SubscribeResponse::sent_invitations_size() const {
   return sent_invitations_.size();
 }
 inline void SubscribeResponse::clear_sent_invitations() {
   sent_invitations_.Clear();
 }
-inline const ::bgs::protocol::Invitation& SubscribeResponse::sent_invitations(int index) const {
+inline const ::bgs::protocol::friends::v1::SentInvitation& SubscribeResponse::sent_invitations(int index) const {
   // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
   return sent_invitations_.Get(index);
 }
-inline ::bgs::protocol::Invitation* SubscribeResponse::mutable_sent_invitations(int index) {
+inline ::bgs::protocol::friends::v1::SentInvitation* SubscribeResponse::mutable_sent_invitations(int index) {
   // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
   return sent_invitations_.Mutable(index);
 }
-inline ::bgs::protocol::Invitation* SubscribeResponse::add_sent_invitations() {
+inline ::bgs::protocol::friends::v1::SentInvitation* SubscribeResponse::add_sent_invitations() {
   // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
   return sent_invitations_.Add();
 }
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::SentInvitation >&
 SubscribeResponse::sent_invitations() const {
   // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
   return sent_invitations_;
 }
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::SentInvitation >*
 SubscribeResponse::mutable_sent_invitations() {
   // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
   return &sent_invitations_;
 }
 
-// repeated .bgs.protocol.Invitation received_invitations = 7;
-inline int SubscribeResponse::received_invitations_size() const {
-  return received_invitations_.size();
+// -------------------------------------------------------------------
+
+// AcceptInvitationOptions
+
+// optional uint32 role = 1;
+inline bool AcceptInvitationOptions::has_role() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void SubscribeResponse::clear_received_invitations() {
-  received_invitations_.Clear();
+inline void AcceptInvitationOptions::set_has_role() {
+  _has_bits_[0] |= 0x00000001u;
 }
-inline const ::bgs::protocol::Invitation& SubscribeResponse::received_invitations(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
-  return received_invitations_.Get(index);
+inline void AcceptInvitationOptions::clear_has_role() {
+  _has_bits_[0] &= ~0x00000001u;
 }
-inline ::bgs::protocol::Invitation* SubscribeResponse::mutable_received_invitations(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
-  return received_invitations_.Mutable(index);
+inline void AcceptInvitationOptions::clear_role() {
+  role_ = 0u;
+  clear_has_role();
 }
-inline ::bgs::protocol::Invitation* SubscribeResponse::add_received_invitations() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
-  return received_invitations_.Add();
+inline ::google::protobuf::uint32 AcceptInvitationOptions::role() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AcceptInvitationOptions.role)
+  return role_;
 }
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
-SubscribeResponse::received_invitations() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
-  return received_invitations_;
+inline void AcceptInvitationOptions::set_role(::google::protobuf::uint32 value) {
+  set_has_role();
+  role_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.AcceptInvitationOptions.role)
 }
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
-SubscribeResponse::mutable_received_invitations() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
-  return &received_invitations_;
+
+// optional fixed32 program = 2;
+inline bool AcceptInvitationOptions::has_program() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AcceptInvitationOptions::set_has_program() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AcceptInvitationOptions::clear_has_program() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AcceptInvitationOptions::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 AcceptInvitationOptions::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AcceptInvitationOptions.program)
+  return program_;
+}
+inline void AcceptInvitationOptions::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.AcceptInvitationOptions.program)
 }
 
 
diff --git a/src/server/proto/Client/game_utilities_service.pb.cc b/src/server/proto/Client/game_utilities_service.pb.cc
index 04dfb17c29a..928082f3aca 100644
--- a/src/server/proto/Client/game_utilities_service.pb.cc
+++ b/src/server/proto/Client/game_utilities_service.pb.cc
@@ -417,37 +417,38 @@ void protobuf_AddDesc_game_5futilities_5fservice_2eproto() {
     "(\t\022(\n\010agent_id\030\002 \001(\0132\026.bgs.protocol.Enti"
     "tyId\022\017\n\007program\030\005 \001(\007\"R\n GetAllValuesFor"
     "AttributeResponse\022.\n\017attribute_value\030\001 \003"
-    "(\0132\025.bgs.protocol.Variant2\365\010\n\024GameUtilit"
-    "iesService\022{\n\024ProcessClientRequest\022-.bgs"
+    "(\0132\025.bgs.protocol.Variant2\220\t\n\024GameUtilit"
+    "iesService\022}\n\024ProcessClientRequest\022-.bgs"
     ".protocol.game_utilities.v1.ClientReques"
     "t\032..bgs.protocol.game_utilities.v1.Clien"
-    "tResponse\"\004\200\265\030\001\022s\n\026PresenceChannelCreate"
-    "d\022=.bgs.protocol.game_utilities.v1.Prese"
-    "nceChannelCreatedRequest\032\024.bgs.protocol."
-    "NoData\"\004\200\265\030\002\022\221\001\n\022GetPlayerVariables\0229.bg"
-    "s.protocol.game_utilities.v1.GetPlayerVa"
-    "riablesRequest\032:.bgs.protocol.game_utili"
-    "ties.v1.GetPlayerVariablesResponse\"\004\200\265\030\003"
-    "\022{\n\024ProcessServerRequest\022-.bgs.protocol."
-    "game_utilities.v1.ServerRequest\032..bgs.pr"
-    "otocol.game_utilities.v1.ServerResponse\""
-    "\004\200\265\030\006\022u\n\023OnGameAccountOnline\022=.bgs.proto"
-    "col.game_utilities.v1.GameAccountOnlineN"
-    "otification\032\031.bgs.protocol.NO_RESPONSE\"\004"
-    "\200\265\030\007\022w\n\024OnGameAccountOffline\022>.bgs.proto"
-    "col.game_utilities.v1.GameAccountOffline"
-    "Notification\032\031.bgs.protocol.NO_RESPONSE\""
-    "\004\200\265\030\010\022\224\001\n\023GetAchievementsFile\022:.bgs.prot"
-    "ocol.game_utilities.v1.GetAchievementsFi"
-    "leRequest\032;.bgs.protocol.game_utilities."
-    "v1.GetAchievementsFileResponse\"\004\200\265\030\t\022\243\001\n"
-    "\030GetAllValuesForAttribute\022\?.bgs.protocol"
-    ".game_utilities.v1.GetAllValuesForAttrib"
-    "uteRequest\032@.bgs.protocol.game_utilities"
-    ".v1.GetAllValuesForAttributeResponse\"\004\200\265"
-    "\030\n\032-\312>*bnet.protocol.game_utilities.Game"
-    "UtilitiesBD\n\037bnet.protocol.game_utilitie"
-    "s.v1B\031GameUtilitiesServiceProtoH\001\200\001\000\210\001\001", 2999);
+    "tResponse\"\006\202\371+\002\010\001\022u\n\026PresenceChannelCrea"
+    "ted\022=.bgs.protocol.game_utilities.v1.Pre"
+    "senceChannelCreatedRequest\032\024.bgs.protoco"
+    "l.NoData\"\006\202\371+\002\010\002\022\223\001\n\022GetPlayerVariables\022"
+    "9.bgs.protocol.game_utilities.v1.GetPlay"
+    "erVariablesRequest\032:.bgs.protocol.game_u"
+    "tilities.v1.GetPlayerVariablesResponse\"\006"
+    "\202\371+\002\010\003\022}\n\024ProcessServerRequest\022-.bgs.pro"
+    "tocol.game_utilities.v1.ServerRequest\032.."
+    "bgs.protocol.game_utilities.v1.ServerRes"
+    "ponse\"\006\202\371+\002\010\006\022w\n\023OnGameAccountOnline\022=.b"
+    "gs.protocol.game_utilities.v1.GameAccoun"
+    "tOnlineNotification\032\031.bgs.protocol.NO_RE"
+    "SPONSE\"\006\202\371+\002\010\007\022y\n\024OnGameAccountOffline\022>"
+    ".bgs.protocol.game_utilities.v1.GameAcco"
+    "untOfflineNotification\032\031.bgs.protocol.NO"
+    "_RESPONSE\"\006\202\371+\002\010\010\022\226\001\n\023GetAchievementsFil"
+    "e\022:.bgs.protocol.game_utilities.v1.GetAc"
+    "hievementsFileRequest\032;.bgs.protocol.gam"
+    "e_utilities.v1.GetAchievementsFileRespon"
+    "se\"\006\202\371+\002\010\t\022\245\001\n\030GetAllValuesForAttribute\022"
+    "\?.bgs.protocol.game_utilities.v1.GetAllV"
+    "aluesForAttributeRequest\032@.bgs.protocol."
+    "game_utilities.v1.GetAllValuesForAttribu"
+    "teResponse\"\006\202\371+\002\010\n\0328\202\371+,\n*bnet.protocol."
+    "game_utilities.GameUtilities\212\371+\004\010\001\020\001BD\n\037"
+    "bnet.protocol.game_utilities.v1B\031GameUti"
+    "litiesServiceProtoH\001\200\001\000\210\001\001", 3026);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "game_utilities_service.proto", &protobuf_RegisterTypes);
   ClientRequest::default_instance_ = new ClientRequest();
diff --git a/src/server/proto/Client/global_extensions/field_options.pb.cc b/src/server/proto/Client/global_extensions/field_options.pb.cc
index f5a1e999417..bfc740aee0b 100644
--- a/src/server/proto/Client/global_extensions/field_options.pb.cc
+++ b/src/server/proto/Client/global_extensions/field_options.pb.cc
@@ -18,16 +18,55 @@
 #include "Log.h"
 // @@protoc_insertion_point(includes)
 
-// Fix stupid windows.h included from Log.h->Common.h
-#ifdef SendMessage
-#undef SendMessage
-#endif
-
 namespace bgs {
 namespace protocol {
 
 namespace {
 
+const ::google::protobuf::Descriptor* BGSFieldOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BGSFieldOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* FieldRestriction_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  FieldRestriction_reflection_ = NULL;
+struct FieldRestrictionOneofInstance {
+  const ::bgs::protocol::SignedFieldRestriction* signed__;
+  const ::bgs::protocol::UnsignedFieldRestriction* unsigned__;
+  const ::bgs::protocol::FloatFieldRestriction* float__;
+  const ::bgs::protocol::StringFieldRestriction* string_;
+  const ::bgs::protocol::RepeatedFieldRestriction* repeated_;
+  const ::bgs::protocol::MessageFieldRestriction* message_;
+  const ::bgs::protocol::EntityIdRestriction* entity_id_;
+}* FieldRestriction_default_oneof_instance_ = NULL;
+const ::google::protobuf::Descriptor* RepeatedFieldRestriction_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RepeatedFieldRestriction_reflection_ = NULL;
+struct RepeatedFieldRestrictionOneofInstance {
+  const ::bgs::protocol::SignedFieldRestriction* signed__;
+  const ::bgs::protocol::UnsignedFieldRestriction* unsigned__;
+  const ::bgs::protocol::FloatFieldRestriction* float__;
+  const ::bgs::protocol::StringFieldRestriction* string_;
+  const ::bgs::protocol::EntityIdRestriction* entity_id_;
+}* RepeatedFieldRestriction_default_oneof_instance_ = NULL;
+const ::google::protobuf::Descriptor* SignedFieldRestriction_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SignedFieldRestriction_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnsignedFieldRestriction_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsignedFieldRestriction_reflection_ = NULL;
+const ::google::protobuf::Descriptor* FloatFieldRestriction_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  FloatFieldRestriction_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StringFieldRestriction_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StringFieldRestriction_reflection_ = NULL;
+const ::google::protobuf::Descriptor* EntityIdRestriction_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  EntityIdRestriction_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* EntityIdRestriction_Kind_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* MessageFieldRestriction_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MessageFieldRestriction_reflection_ = NULL;
 const ::google::protobuf::EnumDescriptor* LogOption_descriptor_ = NULL;
 
 }  // namespace
@@ -39,6 +78,166 @@ void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto() {
     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
       "global_extensions/field_options.proto");
   GOOGLE_CHECK(file != NULL);
+  BGSFieldOptions_descriptor_ = file->message_type(0);
+  static const int BGSFieldOptions_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSFieldOptions, log_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSFieldOptions, shard_key_),
+  };
+  BGSFieldOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BGSFieldOptions_descriptor_,
+      BGSFieldOptions::default_instance_,
+      BGSFieldOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSFieldOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSFieldOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BGSFieldOptions));
+  FieldRestriction_descriptor_ = file->message_type(1);
+  static const int FieldRestriction_offsets_[8] = {
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(FieldRestriction_default_oneof_instance_, signed__),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(FieldRestriction_default_oneof_instance_, unsigned__),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(FieldRestriction_default_oneof_instance_, float__),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(FieldRestriction_default_oneof_instance_, string_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(FieldRestriction_default_oneof_instance_, repeated_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(FieldRestriction_default_oneof_instance_, message_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(FieldRestriction_default_oneof_instance_, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldRestriction, type_),
+  };
+  FieldRestriction_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      FieldRestriction_descriptor_,
+      FieldRestriction::default_instance_,
+      FieldRestriction_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldRestriction, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldRestriction, _unknown_fields_),
+      -1,
+      FieldRestriction_default_oneof_instance_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldRestriction, _oneof_case_[0]),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(FieldRestriction));
+  RepeatedFieldRestriction_descriptor_ = file->message_type(2);
+  static const int RepeatedFieldRestriction_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RepeatedFieldRestriction, size_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RepeatedFieldRestriction, unique_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(RepeatedFieldRestriction_default_oneof_instance_, signed__),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(RepeatedFieldRestriction_default_oneof_instance_, unsigned__),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(RepeatedFieldRestriction_default_oneof_instance_, float__),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(RepeatedFieldRestriction_default_oneof_instance_, string_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(RepeatedFieldRestriction_default_oneof_instance_, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RepeatedFieldRestriction, type_),
+  };
+  RepeatedFieldRestriction_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RepeatedFieldRestriction_descriptor_,
+      RepeatedFieldRestriction::default_instance_,
+      RepeatedFieldRestriction_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RepeatedFieldRestriction, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RepeatedFieldRestriction, _unknown_fields_),
+      -1,
+      RepeatedFieldRestriction_default_oneof_instance_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RepeatedFieldRestriction, _oneof_case_[0]),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RepeatedFieldRestriction));
+  SignedFieldRestriction_descriptor_ = file->message_type(3);
+  static const int SignedFieldRestriction_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedFieldRestriction, limits_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedFieldRestriction, exclude_),
+  };
+  SignedFieldRestriction_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SignedFieldRestriction_descriptor_,
+      SignedFieldRestriction::default_instance_,
+      SignedFieldRestriction_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedFieldRestriction, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedFieldRestriction, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SignedFieldRestriction));
+  UnsignedFieldRestriction_descriptor_ = file->message_type(4);
+  static const int UnsignedFieldRestriction_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsignedFieldRestriction, limits_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsignedFieldRestriction, exclude_),
+  };
+  UnsignedFieldRestriction_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsignedFieldRestriction_descriptor_,
+      UnsignedFieldRestriction::default_instance_,
+      UnsignedFieldRestriction_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsignedFieldRestriction, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsignedFieldRestriction, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsignedFieldRestriction));
+  FloatFieldRestriction_descriptor_ = file->message_type(5);
+  static const int FloatFieldRestriction_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatFieldRestriction, limits_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatFieldRestriction, exclude_),
+  };
+  FloatFieldRestriction_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      FloatFieldRestriction_descriptor_,
+      FloatFieldRestriction::default_instance_,
+      FloatFieldRestriction_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatFieldRestriction, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatFieldRestriction, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(FloatFieldRestriction));
+  StringFieldRestriction_descriptor_ = file->message_type(6);
+  static const int StringFieldRestriction_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringFieldRestriction, size_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringFieldRestriction, exclude_),
+  };
+  StringFieldRestriction_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StringFieldRestriction_descriptor_,
+      StringFieldRestriction::default_instance_,
+      StringFieldRestriction_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringFieldRestriction, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringFieldRestriction, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StringFieldRestriction));
+  EntityIdRestriction_descriptor_ = file->message_type(7);
+  static const int EntityIdRestriction_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityIdRestriction, needed_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityIdRestriction, kind_),
+  };
+  EntityIdRestriction_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      EntityIdRestriction_descriptor_,
+      EntityIdRestriction::default_instance_,
+      EntityIdRestriction_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityIdRestriction, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityIdRestriction, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(EntityIdRestriction));
+  EntityIdRestriction_Kind_descriptor_ = EntityIdRestriction_descriptor_->enum_type(0);
+  MessageFieldRestriction_descriptor_ = file->message_type(8);
+  static const int MessageFieldRestriction_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageFieldRestriction, needed_),
+  };
+  MessageFieldRestriction_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MessageFieldRestriction_descriptor_,
+      MessageFieldRestriction::default_instance_,
+      MessageFieldRestriction_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageFieldRestriction, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageFieldRestriction, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MessageFieldRestriction));
   LogOption_descriptor_ = file->enum_type(0);
 }
 
@@ -52,11 +251,49 @@ inline void protobuf_AssignDescriptorsOnce() {
 
 void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BGSFieldOptions_descriptor_, &BGSFieldOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    FieldRestriction_descriptor_, &FieldRestriction::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RepeatedFieldRestriction_descriptor_, &RepeatedFieldRestriction::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SignedFieldRestriction_descriptor_, &SignedFieldRestriction::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsignedFieldRestriction_descriptor_, &UnsignedFieldRestriction::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    FloatFieldRestriction_descriptor_, &FloatFieldRestriction::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StringFieldRestriction_descriptor_, &StringFieldRestriction::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    EntityIdRestriction_descriptor_, &EntityIdRestriction::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MessageFieldRestriction_descriptor_, &MessageFieldRestriction::default_instance());
 }
 
 }  // namespace
 
 void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto() {
+  delete BGSFieldOptions::default_instance_;
+  delete BGSFieldOptions_reflection_;
+  delete FieldRestriction::default_instance_;
+  delete FieldRestriction_default_oneof_instance_;
+  delete FieldRestriction_reflection_;
+  delete RepeatedFieldRestriction::default_instance_;
+  delete RepeatedFieldRestriction_default_oneof_instance_;
+  delete RepeatedFieldRestriction_reflection_;
+  delete SignedFieldRestriction::default_instance_;
+  delete SignedFieldRestriction_reflection_;
+  delete UnsignedFieldRestriction::default_instance_;
+  delete UnsignedFieldRestriction_reflection_;
+  delete FloatFieldRestriction::default_instance_;
+  delete FloatFieldRestriction_reflection_;
+  delete StringFieldRestriction::default_instance_;
+  delete StringFieldRestriction_reflection_;
+  delete EntityIdRestriction::default_instance_;
+  delete EntityIdRestriction_reflection_;
+  delete MessageFieldRestriction::default_instance_;
+  delete MessageFieldRestriction_reflection_;
 }
 
 void protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto() {
@@ -66,19 +303,84 @@ void protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto() {
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
   ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2frange_2eproto();
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n%global_extensions/field_options.proto\022"
     "\014bgs.protocol\032 google/protobuf/descripto"
-    "r.proto* \n\tLogOption\022\n\n\006HIDDEN\020\001\022\007\n\003HEX\020"
-    "\002:E\n\003log\022\035.google.protobuf.FieldOptions\030"
-    "\320\206\003 \001(\0162\027.bgs.protocol.LogOptionB$\n\rbnet"
-    ".protocolB\021FieldOptionsProtoH\001", 230);
+    "r.proto\032\035global_extensions/range.proto\"J"
+    "\n\017BGSFieldOptions\022$\n\003log\030\001 \001(\0162\027.bgs.pro"
+    "tocol.LogOption\022\021\n\tshard_key\030\002 \001(\010\"\252\003\n\020F"
+    "ieldRestriction\0226\n\006signed\030\001 \001(\0132$.bgs.pr"
+    "otocol.SignedFieldRestrictionH\000\022:\n\010unsig"
+    "ned\030\002 \001(\0132&.bgs.protocol.UnsignedFieldRe"
+    "strictionH\000\0224\n\005float\030\003 \001(\0132#.bgs.protoco"
+    "l.FloatFieldRestrictionH\000\0226\n\006string\030\004 \001("
+    "\0132$.bgs.protocol.StringFieldRestrictionH"
+    "\000\022:\n\010repeated\030\005 \001(\0132&.bgs.protocol.Repea"
+    "tedFieldRestrictionH\000\0228\n\007message\030\006 \001(\0132%"
+    ".bgs.protocol.MessageFieldRestrictionH\000\022"
+    "6\n\tentity_id\030\007 \001(\0132!.bgs.protocol.Entity"
+    "IdRestrictionH\000B\006\n\004type\"\372\002\n\030RepeatedFiel"
+    "dRestriction\022,\n\004size\030\001 \001(\0132\036.bgs.protoco"
+    "l.UnsignedIntRange\022\016\n\006unique\030\002 \001(\010\0226\n\006si"
+    "gned\030\003 \001(\0132$.bgs.protocol.SignedFieldRes"
+    "trictionH\000\022:\n\010unsigned\030\004 \001(\0132&.bgs.proto"
+    "col.UnsignedFieldRestrictionH\000\0224\n\005float\030"
+    "\005 \001(\0132#.bgs.protocol.FloatFieldRestricti"
+    "onH\000\0226\n\006string\030\006 \001(\0132$.bgs.protocol.Stri"
+    "ngFieldRestrictionH\000\0226\n\tentity_id\030\007 \001(\0132"
+    "!.bgs.protocol.EntityIdRestrictionH\000B\006\n\004"
+    "type\"W\n\026SignedFieldRestriction\022,\n\006limits"
+    "\030\001 \001(\0132\034.bgs.protocol.SignedIntRange\022\017\n\007"
+    "exclude\030\002 \003(\022\"[\n\030UnsignedFieldRestrictio"
+    "n\022.\n\006limits\030\001 \001(\0132\036.bgs.protocol.Unsigne"
+    "dIntRange\022\017\n\007exclude\030\002 \003(\004\"R\n\025FloatField"
+    "Restriction\022(\n\006limits\030\001 \001(\0132\030.bgs.protoc"
+    "ol.FloatRange\022\017\n\007exclude\030\002 \003(\002\"W\n\026String"
+    "FieldRestriction\022,\n\004size\030\001 \001(\0132\036.bgs.pro"
+    "tocol.UnsignedIntRange\022\017\n\007exclude\030\002 \003(\t\""
+    "\302\001\n\023EntityIdRestriction\022\016\n\006needed\030\001 \001(\010\022"
+    "4\n\004kind\030\002 \001(\0162&.bgs.protocol.EntityIdRes"
+    "triction.Kind\"e\n\004Kind\022\007\n\003ANY\020\000\022\013\n\007ACCOUN"
+    "T\020\001\022\020\n\014GAME_ACCOUNT\020\002\022\033\n\027ACCOUNT_OR_GAME"
+    "_ACCOUNT\020\003\022\013\n\007SERVICE\020\004\022\013\n\007CHANNEL\020\005\")\n\027"
+    "MessageFieldRestriction\022\016\n\006needed\030\001 \001(\010*"
+    " \n\tLogOption\022\n\n\006HIDDEN\020\001\022\007\n\003HEX\020\002:U\n\rfie"
+    "ld_options\022\035.google.protobuf.FieldOption"
+    "s\030\220\277\005 \001(\0132\035.bgs.protocol.BGSFieldOptions"
+    ":N\n\005valid\022\035.google.protobuf.FieldOptions"
+    "\030\221\277\005 \001(\0132\036.bgs.protocol.FieldRestriction"
+    "B$\n\rbnet.protocolB\021FieldOptionsProtoH\001", 1838);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "global_extensions/field_options.proto", &protobuf_RegisterTypes);
-  ::google::protobuf::internal::ExtensionSet::RegisterEnumExtension(
+  BGSFieldOptions::default_instance_ = new BGSFieldOptions();
+  FieldRestriction::default_instance_ = new FieldRestriction();
+  FieldRestriction_default_oneof_instance_ = new FieldRestrictionOneofInstance;
+  RepeatedFieldRestriction::default_instance_ = new RepeatedFieldRestriction();
+  RepeatedFieldRestriction_default_oneof_instance_ = new RepeatedFieldRestrictionOneofInstance;
+  SignedFieldRestriction::default_instance_ = new SignedFieldRestriction();
+  UnsignedFieldRestriction::default_instance_ = new UnsignedFieldRestriction();
+  FloatFieldRestriction::default_instance_ = new FloatFieldRestriction();
+  StringFieldRestriction::default_instance_ = new StringFieldRestriction();
+  EntityIdRestriction::default_instance_ = new EntityIdRestriction();
+  MessageFieldRestriction::default_instance_ = new MessageFieldRestriction();
+  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
+    &::google::protobuf::FieldOptions::default_instance(),
+    90000, 11, false, false,
+    &::bgs::protocol::BGSFieldOptions::default_instance());
+  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
     &::google::protobuf::FieldOptions::default_instance(),
-    50000, 14, false, false,
-    &::bgs::protocol::LogOption_IsValid);
+    90001, 11, false, false,
+    &::bgs::protocol::FieldRestriction::default_instance());
+  BGSFieldOptions::default_instance_->InitAsDefaultInstance();
+  FieldRestriction::default_instance_->InitAsDefaultInstance();
+  RepeatedFieldRestriction::default_instance_->InitAsDefaultInstance();
+  SignedFieldRestriction::default_instance_->InitAsDefaultInstance();
+  UnsignedFieldRestriction::default_instance_->InitAsDefaultInstance();
+  FloatFieldRestriction::default_instance_->InitAsDefaultInstance();
+  StringFieldRestriction::default_instance_->InitAsDefaultInstance();
+  EntityIdRestriction::default_instance_->InitAsDefaultInstance();
+  MessageFieldRestriction::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto);
 }
 
@@ -102,9 +404,2912 @@ bool LogOption_IsValid(int value) {
   }
 }
 
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BGSFieldOptions::kLogFieldNumber;
+const int BGSFieldOptions::kShardKeyFieldNumber;
+#endif  // !_MSC_VER
+
+BGSFieldOptions::BGSFieldOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.BGSFieldOptions)
+}
+
+void BGSFieldOptions::InitAsDefaultInstance() {
+}
+
+BGSFieldOptions::BGSFieldOptions(const BGSFieldOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.BGSFieldOptions)
+}
+
+void BGSFieldOptions::SharedCtor() {
+  _cached_size_ = 0;
+  log_ = 1;
+  shard_key_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BGSFieldOptions::~BGSFieldOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.BGSFieldOptions)
+  SharedDtor();
+}
+
+void BGSFieldOptions::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void BGSFieldOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BGSFieldOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BGSFieldOptions_descriptor_;
+}
+
+const BGSFieldOptions& BGSFieldOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  return *default_instance_;
+}
+
+BGSFieldOptions* BGSFieldOptions::default_instance_ = NULL;
+
+BGSFieldOptions* BGSFieldOptions::New() const {
+  return new BGSFieldOptions;
+}
+
+void BGSFieldOptions::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    log_ = 1;
+    shard_key_ = false;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BGSFieldOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.BGSFieldOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.LogOption log = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::LogOption_IsValid(value)) {
+            set_log(static_cast< ::bgs::protocol::LogOption >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_shard_key;
+        break;
+      }
+
+      // optional bool shard_key = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_shard_key:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &shard_key_)));
+          set_has_shard_key();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.BGSFieldOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.BGSFieldOptions)
+  return false;
+#undef DO_
+}
+
+void BGSFieldOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.BGSFieldOptions)
+  // optional .bgs.protocol.LogOption log = 1;
+  if (has_log()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->log(), output);
+  }
+
+  // optional bool shard_key = 2;
+  if (has_shard_key()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->shard_key(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.BGSFieldOptions)
+}
+
+::google::protobuf::uint8* BGSFieldOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.BGSFieldOptions)
+  // optional .bgs.protocol.LogOption log = 1;
+  if (has_log()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->log(), target);
+  }
+
+  // optional bool shard_key = 2;
+  if (has_shard_key()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->shard_key(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.BGSFieldOptions)
+  return target;
+}
+
+int BGSFieldOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.LogOption log = 1;
+    if (has_log()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->log());
+    }
+
+    // optional bool shard_key = 2;
+    if (has_shard_key()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BGSFieldOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BGSFieldOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BGSFieldOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BGSFieldOptions::MergeFrom(const BGSFieldOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_log()) {
+      set_log(from.log());
+    }
+    if (from.has_shard_key()) {
+      set_shard_key(from.shard_key());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BGSFieldOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BGSFieldOptions::CopyFrom(const BGSFieldOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BGSFieldOptions::IsInitialized() const {
+
+  return true;
+}
+
+void BGSFieldOptions::Swap(BGSFieldOptions* other) {
+  if (other != this) {
+    std::swap(log_, other->log_);
+    std::swap(shard_key_, other->shard_key_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BGSFieldOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BGSFieldOptions_descriptor_;
+  metadata.reflection = BGSFieldOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FieldRestriction::kSignedFieldNumber;
+const int FieldRestriction::kUnsignedFieldNumber;
+const int FieldRestriction::kFloatFieldNumber;
+const int FieldRestriction::kStringFieldNumber;
+const int FieldRestriction::kRepeatedFieldNumber;
+const int FieldRestriction::kMessageFieldNumber;
+const int FieldRestriction::kEntityIdFieldNumber;
+#endif  // !_MSC_VER
+
+FieldRestriction::FieldRestriction()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.FieldRestriction)
+}
+
+void FieldRestriction::InitAsDefaultInstance() {
+  FieldRestriction_default_oneof_instance_->signed__ = const_cast< ::bgs::protocol::SignedFieldRestriction*>(&::bgs::protocol::SignedFieldRestriction::default_instance());
+  FieldRestriction_default_oneof_instance_->unsigned__ = const_cast< ::bgs::protocol::UnsignedFieldRestriction*>(&::bgs::protocol::UnsignedFieldRestriction::default_instance());
+  FieldRestriction_default_oneof_instance_->float__ = const_cast< ::bgs::protocol::FloatFieldRestriction*>(&::bgs::protocol::FloatFieldRestriction::default_instance());
+  FieldRestriction_default_oneof_instance_->string_ = const_cast< ::bgs::protocol::StringFieldRestriction*>(&::bgs::protocol::StringFieldRestriction::default_instance());
+  FieldRestriction_default_oneof_instance_->repeated_ = const_cast< ::bgs::protocol::RepeatedFieldRestriction*>(&::bgs::protocol::RepeatedFieldRestriction::default_instance());
+  FieldRestriction_default_oneof_instance_->message_ = const_cast< ::bgs::protocol::MessageFieldRestriction*>(&::bgs::protocol::MessageFieldRestriction::default_instance());
+  FieldRestriction_default_oneof_instance_->entity_id_ = const_cast< ::bgs::protocol::EntityIdRestriction*>(&::bgs::protocol::EntityIdRestriction::default_instance());
+}
+
+FieldRestriction::FieldRestriction(const FieldRestriction& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.FieldRestriction)
+}
+
+void FieldRestriction::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  clear_has_type();
+}
+
+FieldRestriction::~FieldRestriction() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.FieldRestriction)
+  SharedDtor();
+}
+
+void FieldRestriction::SharedDtor() {
+  if (has_type()) {
+    clear_type();
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void FieldRestriction::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* FieldRestriction::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FieldRestriction_descriptor_;
+}
+
+const FieldRestriction& FieldRestriction::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  return *default_instance_;
+}
+
+FieldRestriction* FieldRestriction::default_instance_ = NULL;
+
+FieldRestriction* FieldRestriction::New() const {
+  return new FieldRestriction;
+}
+
+void FieldRestriction::clear_type() {
+  switch(type_case()) {
+    case kSigned: {
+      delete type_.signed__;
+      break;
+    }
+    case kUnsigned: {
+      delete type_.unsigned__;
+      break;
+    }
+    case kFloat: {
+      delete type_.float__;
+      break;
+    }
+    case kString: {
+      delete type_.string_;
+      break;
+    }
+    case kRepeated: {
+      delete type_.repeated_;
+      break;
+    }
+    case kMessage: {
+      delete type_.message_;
+      break;
+    }
+    case kEntityId: {
+      delete type_.entity_id_;
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+
+
+void FieldRestriction::Clear() {
+  clear_type();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool FieldRestriction::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.FieldRestriction)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.SignedFieldRestriction signed = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_signed_()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_unsigned;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_unsigned:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_unsigned_()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_float;
+        break;
+      }
+
+      // optional .bgs.protocol.FloatFieldRestriction float = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_float:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_float_()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_string;
+        break;
+      }
+
+      // optional .bgs.protocol.StringFieldRestriction string = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_string:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_string()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_repeated;
+        break;
+      }
+
+      // optional .bgs.protocol.RepeatedFieldRestriction repeated = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_repeated:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_repeated()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_message;
+        break;
+      }
+
+      // optional .bgs.protocol.MessageFieldRestriction message = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_entity_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_entity_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.FieldRestriction)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.FieldRestriction)
+  return false;
+#undef DO_
+}
+
+void FieldRestriction::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.FieldRestriction)
+  // optional .bgs.protocol.SignedFieldRestriction signed = 1;
+  if (has_signed_()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->signed_(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 2;
+  if (has_unsigned_()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->unsigned_(), output);
+  }
+
+  // optional .bgs.protocol.FloatFieldRestriction float = 3;
+  if (has_float_()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->float_(), output);
+  }
+
+  // optional .bgs.protocol.StringFieldRestriction string = 4;
+  if (has_string()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->string(), output);
+  }
+
+  // optional .bgs.protocol.RepeatedFieldRestriction repeated = 5;
+  if (has_repeated()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->repeated(), output);
+  }
+
+  // optional .bgs.protocol.MessageFieldRestriction message = 6;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->message(), output);
+  }
+
+  // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->entity_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.FieldRestriction)
+}
+
+::google::protobuf::uint8* FieldRestriction::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.FieldRestriction)
+  // optional .bgs.protocol.SignedFieldRestriction signed = 1;
+  if (has_signed_()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->signed_(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 2;
+  if (has_unsigned_()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->unsigned_(), target);
+  }
+
+  // optional .bgs.protocol.FloatFieldRestriction float = 3;
+  if (has_float_()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->float_(), target);
+  }
+
+  // optional .bgs.protocol.StringFieldRestriction string = 4;
+  if (has_string()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->string(), target);
+  }
+
+  // optional .bgs.protocol.RepeatedFieldRestriction repeated = 5;
+  if (has_repeated()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->repeated(), target);
+  }
+
+  // optional .bgs.protocol.MessageFieldRestriction message = 6;
+  if (has_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->message(), target);
+  }
+
+  // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->entity_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.FieldRestriction)
+  return target;
+}
+
+int FieldRestriction::ByteSize() const {
+  int total_size = 0;
+
+  switch (type_case()) {
+    // optional .bgs.protocol.SignedFieldRestriction signed = 1;
+    case kSigned: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->signed_());
+      break;
+    }
+    // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 2;
+    case kUnsigned: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->unsigned_());
+      break;
+    }
+    // optional .bgs.protocol.FloatFieldRestriction float = 3;
+    case kFloat: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->float_());
+      break;
+    }
+    // optional .bgs.protocol.StringFieldRestriction string = 4;
+    case kString: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->string());
+      break;
+    }
+    // optional .bgs.protocol.RepeatedFieldRestriction repeated = 5;
+    case kRepeated: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->repeated());
+      break;
+    }
+    // optional .bgs.protocol.MessageFieldRestriction message = 6;
+    case kMessage: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message());
+      break;
+    }
+    // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+    case kEntityId: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FieldRestriction::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const FieldRestriction* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const FieldRestriction*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void FieldRestriction::MergeFrom(const FieldRestriction& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  switch (from.type_case()) {
+    case kSigned: {
+      mutable_signed_()->::bgs::protocol::SignedFieldRestriction::MergeFrom(from.signed_());
+      break;
+    }
+    case kUnsigned: {
+      mutable_unsigned_()->::bgs::protocol::UnsignedFieldRestriction::MergeFrom(from.unsigned_());
+      break;
+    }
+    case kFloat: {
+      mutable_float_()->::bgs::protocol::FloatFieldRestriction::MergeFrom(from.float_());
+      break;
+    }
+    case kString: {
+      mutable_string()->::bgs::protocol::StringFieldRestriction::MergeFrom(from.string());
+      break;
+    }
+    case kRepeated: {
+      mutable_repeated()->::bgs::protocol::RepeatedFieldRestriction::MergeFrom(from.repeated());
+      break;
+    }
+    case kMessage: {
+      mutable_message()->::bgs::protocol::MessageFieldRestriction::MergeFrom(from.message());
+      break;
+    }
+    case kEntityId: {
+      mutable_entity_id()->::bgs::protocol::EntityIdRestriction::MergeFrom(from.entity_id());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void FieldRestriction::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FieldRestriction::CopyFrom(const FieldRestriction& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FieldRestriction::IsInitialized() const {
+
+  return true;
+}
+
+void FieldRestriction::Swap(FieldRestriction* other) {
+  if (other != this) {
+    std::swap(type_, other->type_);
+    std::swap(_oneof_case_[0], other->_oneof_case_[0]);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata FieldRestriction::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = FieldRestriction_descriptor_;
+  metadata.reflection = FieldRestriction_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RepeatedFieldRestriction::kSizeFieldNumber;
+const int RepeatedFieldRestriction::kUniqueFieldNumber;
+const int RepeatedFieldRestriction::kSignedFieldNumber;
+const int RepeatedFieldRestriction::kUnsignedFieldNumber;
+const int RepeatedFieldRestriction::kFloatFieldNumber;
+const int RepeatedFieldRestriction::kStringFieldNumber;
+const int RepeatedFieldRestriction::kEntityIdFieldNumber;
+#endif  // !_MSC_VER
+
+RepeatedFieldRestriction::RepeatedFieldRestriction()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.RepeatedFieldRestriction)
+}
+
+void RepeatedFieldRestriction::InitAsDefaultInstance() {
+  size_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+  RepeatedFieldRestriction_default_oneof_instance_->signed__ = const_cast< ::bgs::protocol::SignedFieldRestriction*>(&::bgs::protocol::SignedFieldRestriction::default_instance());
+  RepeatedFieldRestriction_default_oneof_instance_->unsigned__ = const_cast< ::bgs::protocol::UnsignedFieldRestriction*>(&::bgs::protocol::UnsignedFieldRestriction::default_instance());
+  RepeatedFieldRestriction_default_oneof_instance_->float__ = const_cast< ::bgs::protocol::FloatFieldRestriction*>(&::bgs::protocol::FloatFieldRestriction::default_instance());
+  RepeatedFieldRestriction_default_oneof_instance_->string_ = const_cast< ::bgs::protocol::StringFieldRestriction*>(&::bgs::protocol::StringFieldRestriction::default_instance());
+  RepeatedFieldRestriction_default_oneof_instance_->entity_id_ = const_cast< ::bgs::protocol::EntityIdRestriction*>(&::bgs::protocol::EntityIdRestriction::default_instance());
+}
+
+RepeatedFieldRestriction::RepeatedFieldRestriction(const RepeatedFieldRestriction& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.RepeatedFieldRestriction)
+}
+
+void RepeatedFieldRestriction::SharedCtor() {
+  _cached_size_ = 0;
+  size_ = NULL;
+  unique_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  clear_has_type();
+}
+
+RepeatedFieldRestriction::~RepeatedFieldRestriction() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.RepeatedFieldRestriction)
+  SharedDtor();
+}
+
+void RepeatedFieldRestriction::SharedDtor() {
+  if (has_type()) {
+    clear_type();
+  }
+  if (this != default_instance_) {
+    delete size_;
+  }
+}
+
+void RepeatedFieldRestriction::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RepeatedFieldRestriction::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RepeatedFieldRestriction_descriptor_;
+}
+
+const RepeatedFieldRestriction& RepeatedFieldRestriction::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  return *default_instance_;
+}
+
+RepeatedFieldRestriction* RepeatedFieldRestriction::default_instance_ = NULL;
+
+RepeatedFieldRestriction* RepeatedFieldRestriction::New() const {
+  return new RepeatedFieldRestriction;
+}
+
+void RepeatedFieldRestriction::clear_type() {
+  switch(type_case()) {
+    case kSigned: {
+      delete type_.signed__;
+      break;
+    }
+    case kUnsigned: {
+      delete type_.unsigned__;
+      break;
+    }
+    case kFloat: {
+      delete type_.float__;
+      break;
+    }
+    case kString: {
+      delete type_.string_;
+      break;
+    }
+    case kEntityId: {
+      delete type_.entity_id_;
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+
+
+void RepeatedFieldRestriction::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_size()) {
+      if (size_ != NULL) size_->::bgs::protocol::UnsignedIntRange::Clear();
+    }
+    unique_ = false;
+  }
+  clear_type();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RepeatedFieldRestriction::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.RepeatedFieldRestriction)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange size = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_size()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_unique;
+        break;
+      }
+
+      // optional bool unique = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_unique:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &unique_)));
+          set_has_unique();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_signed;
+        break;
+      }
+
+      // optional .bgs.protocol.SignedFieldRestriction signed = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_signed:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_signed_()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_unsigned;
+        break;
+      }
+
+      // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_unsigned:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_unsigned_()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_float;
+        break;
+      }
+
+      // optional .bgs.protocol.FloatFieldRestriction float = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_float:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_float_()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_string;
+        break;
+      }
+
+      // optional .bgs.protocol.StringFieldRestriction string = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_string:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_string()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_entity_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_entity_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.RepeatedFieldRestriction)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.RepeatedFieldRestriction)
+  return false;
+#undef DO_
+}
+
+void RepeatedFieldRestriction::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.RepeatedFieldRestriction)
+  // optional .bgs.protocol.UnsignedIntRange size = 1;
+  if (has_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->size(), output);
+  }
+
+  // optional bool unique = 2;
+  if (has_unique()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->unique(), output);
+  }
+
+  // optional .bgs.protocol.SignedFieldRestriction signed = 3;
+  if (has_signed_()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->signed_(), output);
+  }
+
+  // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 4;
+  if (has_unsigned_()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->unsigned_(), output);
+  }
+
+  // optional .bgs.protocol.FloatFieldRestriction float = 5;
+  if (has_float_()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->float_(), output);
+  }
+
+  // optional .bgs.protocol.StringFieldRestriction string = 6;
+  if (has_string()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->string(), output);
+  }
+
+  // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->entity_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.RepeatedFieldRestriction)
+}
+
+::google::protobuf::uint8* RepeatedFieldRestriction::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.RepeatedFieldRestriction)
+  // optional .bgs.protocol.UnsignedIntRange size = 1;
+  if (has_size()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->size(), target);
+  }
+
+  // optional bool unique = 2;
+  if (has_unique()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->unique(), target);
+  }
+
+  // optional .bgs.protocol.SignedFieldRestriction signed = 3;
+  if (has_signed_()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->signed_(), target);
+  }
+
+  // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 4;
+  if (has_unsigned_()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->unsigned_(), target);
+  }
+
+  // optional .bgs.protocol.FloatFieldRestriction float = 5;
+  if (has_float_()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->float_(), target);
+  }
+
+  // optional .bgs.protocol.StringFieldRestriction string = 6;
+  if (has_string()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->string(), target);
+  }
+
+  // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->entity_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.RepeatedFieldRestriction)
+  return target;
+}
+
+int RepeatedFieldRestriction::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange size = 1;
+    if (has_size()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->size());
+    }
+
+    // optional bool unique = 2;
+    if (has_unique()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  switch (type_case()) {
+    // optional .bgs.protocol.SignedFieldRestriction signed = 3;
+    case kSigned: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->signed_());
+      break;
+    }
+    // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 4;
+    case kUnsigned: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->unsigned_());
+      break;
+    }
+    // optional .bgs.protocol.FloatFieldRestriction float = 5;
+    case kFloat: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->float_());
+      break;
+    }
+    // optional .bgs.protocol.StringFieldRestriction string = 6;
+    case kString: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->string());
+      break;
+    }
+    // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+    case kEntityId: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RepeatedFieldRestriction::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RepeatedFieldRestriction* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RepeatedFieldRestriction*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RepeatedFieldRestriction::MergeFrom(const RepeatedFieldRestriction& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  switch (from.type_case()) {
+    case kSigned: {
+      mutable_signed_()->::bgs::protocol::SignedFieldRestriction::MergeFrom(from.signed_());
+      break;
+    }
+    case kUnsigned: {
+      mutable_unsigned_()->::bgs::protocol::UnsignedFieldRestriction::MergeFrom(from.unsigned_());
+      break;
+    }
+    case kFloat: {
+      mutable_float_()->::bgs::protocol::FloatFieldRestriction::MergeFrom(from.float_());
+      break;
+    }
+    case kString: {
+      mutable_string()->::bgs::protocol::StringFieldRestriction::MergeFrom(from.string());
+      break;
+    }
+    case kEntityId: {
+      mutable_entity_id()->::bgs::protocol::EntityIdRestriction::MergeFrom(from.entity_id());
+      break;
+    }
+    case TYPE_NOT_SET: {
+      break;
+    }
+  }
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_size()) {
+      mutable_size()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.size());
+    }
+    if (from.has_unique()) {
+      set_unique(from.unique());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RepeatedFieldRestriction::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RepeatedFieldRestriction::CopyFrom(const RepeatedFieldRestriction& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RepeatedFieldRestriction::IsInitialized() const {
+
+  return true;
+}
+
+void RepeatedFieldRestriction::Swap(RepeatedFieldRestriction* other) {
+  if (other != this) {
+    std::swap(size_, other->size_);
+    std::swap(unique_, other->unique_);
+    std::swap(type_, other->type_);
+    std::swap(_oneof_case_[0], other->_oneof_case_[0]);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RepeatedFieldRestriction::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RepeatedFieldRestriction_descriptor_;
+  metadata.reflection = RepeatedFieldRestriction_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SignedFieldRestriction::kLimitsFieldNumber;
+const int SignedFieldRestriction::kExcludeFieldNumber;
+#endif  // !_MSC_VER
+
+SignedFieldRestriction::SignedFieldRestriction()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.SignedFieldRestriction)
+}
+
+void SignedFieldRestriction::InitAsDefaultInstance() {
+  limits_ = const_cast< ::bgs::protocol::SignedIntRange*>(&::bgs::protocol::SignedIntRange::default_instance());
+}
+
+SignedFieldRestriction::SignedFieldRestriction(const SignedFieldRestriction& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.SignedFieldRestriction)
+}
+
+void SignedFieldRestriction::SharedCtor() {
+  _cached_size_ = 0;
+  limits_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SignedFieldRestriction::~SignedFieldRestriction() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.SignedFieldRestriction)
+  SharedDtor();
+}
+
+void SignedFieldRestriction::SharedDtor() {
+  if (this != default_instance_) {
+    delete limits_;
+  }
+}
+
+void SignedFieldRestriction::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SignedFieldRestriction::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SignedFieldRestriction_descriptor_;
+}
+
+const SignedFieldRestriction& SignedFieldRestriction::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  return *default_instance_;
+}
+
+SignedFieldRestriction* SignedFieldRestriction::default_instance_ = NULL;
+
+SignedFieldRestriction* SignedFieldRestriction::New() const {
+  return new SignedFieldRestriction;
+}
+
+void SignedFieldRestriction::Clear() {
+  if (has_limits()) {
+    if (limits_ != NULL) limits_->::bgs::protocol::SignedIntRange::Clear();
+  }
+  exclude_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SignedFieldRestriction::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.SignedFieldRestriction)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.SignedIntRange limits = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_limits()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_exclude;
+        break;
+      }
+
+      // repeated sint64 exclude = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_exclude:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
+                 1, 16, input, this->mutable_exclude())));
+        } else if (tag == 18) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
+                 input, this->mutable_exclude())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_exclude;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.SignedFieldRestriction)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.SignedFieldRestriction)
+  return false;
+#undef DO_
+}
+
+void SignedFieldRestriction::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.SignedFieldRestriction)
+  // optional .bgs.protocol.SignedIntRange limits = 1;
+  if (has_limits()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->limits(), output);
+  }
+
+  // repeated sint64 exclude = 2;
+  for (int i = 0; i < this->exclude_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteSInt64(
+      2, this->exclude(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.SignedFieldRestriction)
+}
+
+::google::protobuf::uint8* SignedFieldRestriction::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.SignedFieldRestriction)
+  // optional .bgs.protocol.SignedIntRange limits = 1;
+  if (has_limits()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->limits(), target);
+  }
+
+  // repeated sint64 exclude = 2;
+  for (int i = 0; i < this->exclude_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteSInt64ToArray(2, this->exclude(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.SignedFieldRestriction)
+  return target;
+}
+
+int SignedFieldRestriction::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.SignedIntRange limits = 1;
+    if (has_limits()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->limits());
+    }
+
+  }
+  // repeated sint64 exclude = 2;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->exclude_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        SInt64Size(this->exclude(i));
+    }
+    total_size += 1 * this->exclude_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SignedFieldRestriction::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SignedFieldRestriction* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SignedFieldRestriction*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SignedFieldRestriction::MergeFrom(const SignedFieldRestriction& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  exclude_.MergeFrom(from.exclude_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_limits()) {
+      mutable_limits()->::bgs::protocol::SignedIntRange::MergeFrom(from.limits());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SignedFieldRestriction::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SignedFieldRestriction::CopyFrom(const SignedFieldRestriction& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SignedFieldRestriction::IsInitialized() const {
+
+  return true;
+}
+
+void SignedFieldRestriction::Swap(SignedFieldRestriction* other) {
+  if (other != this) {
+    std::swap(limits_, other->limits_);
+    exclude_.Swap(&other->exclude_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SignedFieldRestriction::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SignedFieldRestriction_descriptor_;
+  metadata.reflection = SignedFieldRestriction_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsignedFieldRestriction::kLimitsFieldNumber;
+const int UnsignedFieldRestriction::kExcludeFieldNumber;
+#endif  // !_MSC_VER
+
+UnsignedFieldRestriction::UnsignedFieldRestriction()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.UnsignedFieldRestriction)
+}
+
+void UnsignedFieldRestriction::InitAsDefaultInstance() {
+  limits_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+}
+
+UnsignedFieldRestriction::UnsignedFieldRestriction(const UnsignedFieldRestriction& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.UnsignedFieldRestriction)
+}
+
+void UnsignedFieldRestriction::SharedCtor() {
+  _cached_size_ = 0;
+  limits_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsignedFieldRestriction::~UnsignedFieldRestriction() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.UnsignedFieldRestriction)
+  SharedDtor();
+}
+
+void UnsignedFieldRestriction::SharedDtor() {
+  if (this != default_instance_) {
+    delete limits_;
+  }
+}
+
+void UnsignedFieldRestriction::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsignedFieldRestriction::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsignedFieldRestriction_descriptor_;
+}
+
+const UnsignedFieldRestriction& UnsignedFieldRestriction::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  return *default_instance_;
+}
+
+UnsignedFieldRestriction* UnsignedFieldRestriction::default_instance_ = NULL;
+
+UnsignedFieldRestriction* UnsignedFieldRestriction::New() const {
+  return new UnsignedFieldRestriction;
+}
+
+void UnsignedFieldRestriction::Clear() {
+  if (has_limits()) {
+    if (limits_ != NULL) limits_->::bgs::protocol::UnsignedIntRange::Clear();
+  }
+  exclude_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsignedFieldRestriction::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.UnsignedFieldRestriction)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange limits = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_limits()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_exclude;
+        break;
+      }
+
+      // repeated uint64 exclude = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_exclude:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 1, 16, input, this->mutable_exclude())));
+        } else if (tag == 18) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, this->mutable_exclude())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_exclude;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.UnsignedFieldRestriction)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.UnsignedFieldRestriction)
+  return false;
+#undef DO_
+}
+
+void UnsignedFieldRestriction::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.UnsignedFieldRestriction)
+  // optional .bgs.protocol.UnsignedIntRange limits = 1;
+  if (has_limits()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->limits(), output);
+  }
+
+  // repeated uint64 exclude = 2;
+  for (int i = 0; i < this->exclude_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(
+      2, this->exclude(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.UnsignedFieldRestriction)
+}
+
+::google::protobuf::uint8* UnsignedFieldRestriction::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.UnsignedFieldRestriction)
+  // optional .bgs.protocol.UnsignedIntRange limits = 1;
+  if (has_limits()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->limits(), target);
+  }
+
+  // repeated uint64 exclude = 2;
+  for (int i = 0; i < this->exclude_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt64ToArray(2, this->exclude(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.UnsignedFieldRestriction)
+  return target;
+}
+
+int UnsignedFieldRestriction::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange limits = 1;
+    if (has_limits()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->limits());
+    }
+
+  }
+  // repeated uint64 exclude = 2;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->exclude_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt64Size(this->exclude(i));
+    }
+    total_size += 1 * this->exclude_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsignedFieldRestriction::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsignedFieldRestriction* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsignedFieldRestriction*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsignedFieldRestriction::MergeFrom(const UnsignedFieldRestriction& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  exclude_.MergeFrom(from.exclude_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_limits()) {
+      mutable_limits()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.limits());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsignedFieldRestriction::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsignedFieldRestriction::CopyFrom(const UnsignedFieldRestriction& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsignedFieldRestriction::IsInitialized() const {
+
+  return true;
+}
+
+void UnsignedFieldRestriction::Swap(UnsignedFieldRestriction* other) {
+  if (other != this) {
+    std::swap(limits_, other->limits_);
+    exclude_.Swap(&other->exclude_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsignedFieldRestriction::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsignedFieldRestriction_descriptor_;
+  metadata.reflection = UnsignedFieldRestriction_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FloatFieldRestriction::kLimitsFieldNumber;
+const int FloatFieldRestriction::kExcludeFieldNumber;
+#endif  // !_MSC_VER
+
+FloatFieldRestriction::FloatFieldRestriction()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.FloatFieldRestriction)
+}
+
+void FloatFieldRestriction::InitAsDefaultInstance() {
+  limits_ = const_cast< ::bgs::protocol::FloatRange*>(&::bgs::protocol::FloatRange::default_instance());
+}
+
+FloatFieldRestriction::FloatFieldRestriction(const FloatFieldRestriction& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.FloatFieldRestriction)
+}
+
+void FloatFieldRestriction::SharedCtor() {
+  _cached_size_ = 0;
+  limits_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FloatFieldRestriction::~FloatFieldRestriction() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.FloatFieldRestriction)
+  SharedDtor();
+}
+
+void FloatFieldRestriction::SharedDtor() {
+  if (this != default_instance_) {
+    delete limits_;
+  }
+}
+
+void FloatFieldRestriction::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* FloatFieldRestriction::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FloatFieldRestriction_descriptor_;
+}
+
+const FloatFieldRestriction& FloatFieldRestriction::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  return *default_instance_;
+}
+
+FloatFieldRestriction* FloatFieldRestriction::default_instance_ = NULL;
+
+FloatFieldRestriction* FloatFieldRestriction::New() const {
+  return new FloatFieldRestriction;
+}
+
+void FloatFieldRestriction::Clear() {
+  if (has_limits()) {
+    if (limits_ != NULL) limits_->::bgs::protocol::FloatRange::Clear();
+  }
+  exclude_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool FloatFieldRestriction::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.FloatFieldRestriction)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.FloatRange limits = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_limits()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_exclude;
+        break;
+      }
+
+      // repeated float exclude = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_exclude:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 1, 21, input, this->mutable_exclude())));
+        } else if (tag == 18) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, this->mutable_exclude())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_exclude;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.FloatFieldRestriction)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.FloatFieldRestriction)
+  return false;
+#undef DO_
+}
+
+void FloatFieldRestriction::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.FloatFieldRestriction)
+  // optional .bgs.protocol.FloatRange limits = 1;
+  if (has_limits()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->limits(), output);
+  }
+
+  // repeated float exclude = 2;
+  for (int i = 0; i < this->exclude_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(
+      2, this->exclude(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.FloatFieldRestriction)
+}
+
+::google::protobuf::uint8* FloatFieldRestriction::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.FloatFieldRestriction)
+  // optional .bgs.protocol.FloatRange limits = 1;
+  if (has_limits()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->limits(), target);
+  }
+
+  // repeated float exclude = 2;
+  for (int i = 0; i < this->exclude_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteFloatToArray(2, this->exclude(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.FloatFieldRestriction)
+  return target;
+}
+
+int FloatFieldRestriction::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.FloatRange limits = 1;
+    if (has_limits()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->limits());
+    }
+
+  }
+  // repeated float exclude = 2;
+  {
+    int data_size = 0;
+    data_size = 4 * this->exclude_size();
+    total_size += 1 * this->exclude_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FloatFieldRestriction::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const FloatFieldRestriction* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const FloatFieldRestriction*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void FloatFieldRestriction::MergeFrom(const FloatFieldRestriction& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  exclude_.MergeFrom(from.exclude_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_limits()) {
+      mutable_limits()->::bgs::protocol::FloatRange::MergeFrom(from.limits());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void FloatFieldRestriction::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FloatFieldRestriction::CopyFrom(const FloatFieldRestriction& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FloatFieldRestriction::IsInitialized() const {
+
+  return true;
+}
+
+void FloatFieldRestriction::Swap(FloatFieldRestriction* other) {
+  if (other != this) {
+    std::swap(limits_, other->limits_);
+    exclude_.Swap(&other->exclude_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata FloatFieldRestriction::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = FloatFieldRestriction_descriptor_;
+  metadata.reflection = FloatFieldRestriction_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StringFieldRestriction::kSizeFieldNumber;
+const int StringFieldRestriction::kExcludeFieldNumber;
+#endif  // !_MSC_VER
+
+StringFieldRestriction::StringFieldRestriction()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.StringFieldRestriction)
+}
+
+void StringFieldRestriction::InitAsDefaultInstance() {
+  size_ = const_cast< ::bgs::protocol::UnsignedIntRange*>(&::bgs::protocol::UnsignedIntRange::default_instance());
+}
+
+StringFieldRestriction::StringFieldRestriction(const StringFieldRestriction& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.StringFieldRestriction)
+}
+
+void StringFieldRestriction::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  size_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StringFieldRestriction::~StringFieldRestriction() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.StringFieldRestriction)
+  SharedDtor();
+}
+
+void StringFieldRestriction::SharedDtor() {
+  if (this != default_instance_) {
+    delete size_;
+  }
+}
+
+void StringFieldRestriction::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StringFieldRestriction::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StringFieldRestriction_descriptor_;
+}
+
+const StringFieldRestriction& StringFieldRestriction::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  return *default_instance_;
+}
+
+StringFieldRestriction* StringFieldRestriction::default_instance_ = NULL;
+
+StringFieldRestriction* StringFieldRestriction::New() const {
+  return new StringFieldRestriction;
+}
+
+void StringFieldRestriction::Clear() {
+  if (has_size()) {
+    if (size_ != NULL) size_->::bgs::protocol::UnsignedIntRange::Clear();
+  }
+  exclude_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StringFieldRestriction::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.StringFieldRestriction)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.UnsignedIntRange size = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_size()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_exclude;
+        break;
+      }
+
+      // repeated string exclude = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_exclude:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_exclude()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->exclude(this->exclude_size() - 1).data(),
+            this->exclude(this->exclude_size() - 1).length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "exclude");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_exclude;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.StringFieldRestriction)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.StringFieldRestriction)
+  return false;
+#undef DO_
+}
+
+void StringFieldRestriction::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.StringFieldRestriction)
+  // optional .bgs.protocol.UnsignedIntRange size = 1;
+  if (has_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->size(), output);
+  }
+
+  // repeated string exclude = 2;
+  for (int i = 0; i < this->exclude_size(); i++) {
+  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+    this->exclude(i).data(), this->exclude(i).length(),
+    ::google::protobuf::internal::WireFormat::SERIALIZE,
+    "exclude");
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->exclude(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.StringFieldRestriction)
+}
+
+::google::protobuf::uint8* StringFieldRestriction::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.StringFieldRestriction)
+  // optional .bgs.protocol.UnsignedIntRange size = 1;
+  if (has_size()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->size(), target);
+  }
+
+  // repeated string exclude = 2;
+  for (int i = 0; i < this->exclude_size(); i++) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->exclude(i).data(), this->exclude(i).length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "exclude");
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(2, this->exclude(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.StringFieldRestriction)
+  return target;
+}
+
+int StringFieldRestriction::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.UnsignedIntRange size = 1;
+    if (has_size()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->size());
+    }
+
+  }
+  // repeated string exclude = 2;
+  total_size += 1 * this->exclude_size();
+  for (int i = 0; i < this->exclude_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->exclude(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StringFieldRestriction::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StringFieldRestriction* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StringFieldRestriction*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StringFieldRestriction::MergeFrom(const StringFieldRestriction& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  exclude_.MergeFrom(from.exclude_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_size()) {
+      mutable_size()->::bgs::protocol::UnsignedIntRange::MergeFrom(from.size());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StringFieldRestriction::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StringFieldRestriction::CopyFrom(const StringFieldRestriction& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StringFieldRestriction::IsInitialized() const {
+
+  return true;
+}
+
+void StringFieldRestriction::Swap(StringFieldRestriction* other) {
+  if (other != this) {
+    std::swap(size_, other->size_);
+    exclude_.Swap(&other->exclude_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StringFieldRestriction::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StringFieldRestriction_descriptor_;
+  metadata.reflection = StringFieldRestriction_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+const ::google::protobuf::EnumDescriptor* EntityIdRestriction_Kind_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EntityIdRestriction_Kind_descriptor_;
+}
+bool EntityIdRestriction_Kind_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const EntityIdRestriction_Kind EntityIdRestriction::ANY;
+const EntityIdRestriction_Kind EntityIdRestriction::ACCOUNT;
+const EntityIdRestriction_Kind EntityIdRestriction::GAME_ACCOUNT;
+const EntityIdRestriction_Kind EntityIdRestriction::ACCOUNT_OR_GAME_ACCOUNT;
+const EntityIdRestriction_Kind EntityIdRestriction::SERVICE;
+const EntityIdRestriction_Kind EntityIdRestriction::CHANNEL;
+const EntityIdRestriction_Kind EntityIdRestriction::Kind_MIN;
+const EntityIdRestriction_Kind EntityIdRestriction::Kind_MAX;
+const int EntityIdRestriction::Kind_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int EntityIdRestriction::kNeededFieldNumber;
+const int EntityIdRestriction::kKindFieldNumber;
+#endif  // !_MSC_VER
+
+EntityIdRestriction::EntityIdRestriction()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.EntityIdRestriction)
+}
+
+void EntityIdRestriction::InitAsDefaultInstance() {
+}
+
+EntityIdRestriction::EntityIdRestriction(const EntityIdRestriction& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.EntityIdRestriction)
+}
+
+void EntityIdRestriction::SharedCtor() {
+  _cached_size_ = 0;
+  needed_ = false;
+  kind_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+EntityIdRestriction::~EntityIdRestriction() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.EntityIdRestriction)
+  SharedDtor();
+}
+
+void EntityIdRestriction::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void EntityIdRestriction::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* EntityIdRestriction::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EntityIdRestriction_descriptor_;
+}
+
+const EntityIdRestriction& EntityIdRestriction::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  return *default_instance_;
+}
+
+EntityIdRestriction* EntityIdRestriction::default_instance_ = NULL;
+
+EntityIdRestriction* EntityIdRestriction::New() const {
+  return new EntityIdRestriction;
+}
+
+void EntityIdRestriction::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<EntityIdRestriction*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(needed_, kind_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool EntityIdRestriction::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.EntityIdRestriction)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool needed = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &needed_)));
+          set_has_needed();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_kind;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityIdRestriction.Kind kind = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_kind:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::EntityIdRestriction_Kind_IsValid(value)) {
+            set_kind(static_cast< ::bgs::protocol::EntityIdRestriction_Kind >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(2, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.EntityIdRestriction)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.EntityIdRestriction)
+  return false;
+#undef DO_
+}
+
+void EntityIdRestriction::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.EntityIdRestriction)
+  // optional bool needed = 1;
+  if (has_needed()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->needed(), output);
+  }
+
+  // optional .bgs.protocol.EntityIdRestriction.Kind kind = 2;
+  if (has_kind()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->kind(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.EntityIdRestriction)
+}
+
+::google::protobuf::uint8* EntityIdRestriction::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.EntityIdRestriction)
+  // optional bool needed = 1;
+  if (has_needed()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->needed(), target);
+  }
+
+  // optional .bgs.protocol.EntityIdRestriction.Kind kind = 2;
+  if (has_kind()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->kind(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.EntityIdRestriction)
+  return target;
+}
+
+int EntityIdRestriction::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool needed = 1;
+    if (has_needed()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.EntityIdRestriction.Kind kind = 2;
+    if (has_kind()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->kind());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void EntityIdRestriction::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const EntityIdRestriction* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const EntityIdRestriction*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void EntityIdRestriction::MergeFrom(const EntityIdRestriction& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_needed()) {
+      set_needed(from.needed());
+    }
+    if (from.has_kind()) {
+      set_kind(from.kind());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void EntityIdRestriction::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void EntityIdRestriction::CopyFrom(const EntityIdRestriction& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EntityIdRestriction::IsInitialized() const {
+
+  return true;
+}
+
+void EntityIdRestriction::Swap(EntityIdRestriction* other) {
+  if (other != this) {
+    std::swap(needed_, other->needed_);
+    std::swap(kind_, other->kind_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata EntityIdRestriction::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = EntityIdRestriction_descriptor_;
+  metadata.reflection = EntityIdRestriction_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MessageFieldRestriction::kNeededFieldNumber;
+#endif  // !_MSC_VER
+
+MessageFieldRestriction::MessageFieldRestriction()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.MessageFieldRestriction)
+}
+
+void MessageFieldRestriction::InitAsDefaultInstance() {
+}
+
+MessageFieldRestriction::MessageFieldRestriction(const MessageFieldRestriction& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.MessageFieldRestriction)
+}
+
+void MessageFieldRestriction::SharedCtor() {
+  _cached_size_ = 0;
+  needed_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MessageFieldRestriction::~MessageFieldRestriction() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.MessageFieldRestriction)
+  SharedDtor();
+}
+
+void MessageFieldRestriction::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void MessageFieldRestriction::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MessageFieldRestriction::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MessageFieldRestriction_descriptor_;
+}
+
+const MessageFieldRestriction& MessageFieldRestriction::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  return *default_instance_;
+}
+
+MessageFieldRestriction* MessageFieldRestriction::default_instance_ = NULL;
+
+MessageFieldRestriction* MessageFieldRestriction::New() const {
+  return new MessageFieldRestriction;
+}
+
+void MessageFieldRestriction::Clear() {
+  needed_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MessageFieldRestriction::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.MessageFieldRestriction)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool needed = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &needed_)));
+          set_has_needed();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.MessageFieldRestriction)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.MessageFieldRestriction)
+  return false;
+#undef DO_
+}
+
+void MessageFieldRestriction::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.MessageFieldRestriction)
+  // optional bool needed = 1;
+  if (has_needed()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->needed(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.MessageFieldRestriction)
+}
+
+::google::protobuf::uint8* MessageFieldRestriction::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.MessageFieldRestriction)
+  // optional bool needed = 1;
+  if (has_needed()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->needed(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.MessageFieldRestriction)
+  return target;
+}
+
+int MessageFieldRestriction::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool needed = 1;
+    if (has_needed()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MessageFieldRestriction::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MessageFieldRestriction* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MessageFieldRestriction*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MessageFieldRestriction::MergeFrom(const MessageFieldRestriction& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_needed()) {
+      set_needed(from.needed());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MessageFieldRestriction::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MessageFieldRestriction::CopyFrom(const MessageFieldRestriction& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MessageFieldRestriction::IsInitialized() const {
+
+  return true;
+}
+
+void MessageFieldRestriction::Swap(MessageFieldRestriction* other) {
+  if (other != this) {
+    std::swap(needed_, other->needed_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MessageFieldRestriction::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MessageFieldRestriction_descriptor_;
+  metadata.reflection = MessageFieldRestriction_reflection_;
+  return metadata;
+}
+
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions,
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::BGSFieldOptions >, 11, false >
+  field_options(kFieldOptionsFieldNumber, ::bgs::protocol::BGSFieldOptions::default_instance());
 ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions,
-    ::google::protobuf::internal::EnumTypeTraits< ::bgs::protocol::LogOption, ::bgs::protocol::LogOption_IsValid>, 14, false >
-  log(kLogFieldNumber, static_cast< ::bgs::protocol::LogOption >(1));
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::FieldRestriction >, 11, false >
+  valid(kValidFieldNumber, ::bgs::protocol::FieldRestriction::default_instance());
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/src/server/proto/Client/global_extensions/field_options.pb.h b/src/server/proto/Client/global_extensions/field_options.pb.h
index 7dc0ddabf64..c1a32a2601d 100644
--- a/src/server/proto/Client/global_extensions/field_options.pb.h
+++ b/src/server/proto/Client/global_extensions/field_options.pb.h
@@ -20,10 +20,13 @@
 #endif
 
 #include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/extension_set.h>
 #include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
 #include "google/protobuf/descriptor.pb.h"
+#include "global_extensions/range.pb.h"
 #include "Define.h" // for TC_PROTO_API
 // @@protoc_insertion_point(includes)
 
@@ -35,7 +38,39 @@ void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto
 void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
 void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
+class BGSFieldOptions;
+class FieldRestriction;
+class RepeatedFieldRestriction;
+class SignedFieldRestriction;
+class UnsignedFieldRestriction;
+class FloatFieldRestriction;
+class StringFieldRestriction;
+class EntityIdRestriction;
+class MessageFieldRestriction;
 
+enum EntityIdRestriction_Kind {
+  EntityIdRestriction_Kind_ANY = 0,
+  EntityIdRestriction_Kind_ACCOUNT = 1,
+  EntityIdRestriction_Kind_GAME_ACCOUNT = 2,
+  EntityIdRestriction_Kind_ACCOUNT_OR_GAME_ACCOUNT = 3,
+  EntityIdRestriction_Kind_SERVICE = 4,
+  EntityIdRestriction_Kind_CHANNEL = 5
+};
+TC_PROTO_API bool EntityIdRestriction_Kind_IsValid(int value);
+const EntityIdRestriction_Kind EntityIdRestriction_Kind_Kind_MIN = EntityIdRestriction_Kind_ANY;
+const EntityIdRestriction_Kind EntityIdRestriction_Kind_Kind_MAX = EntityIdRestriction_Kind_CHANNEL;
+const int EntityIdRestriction_Kind_Kind_ARRAYSIZE = EntityIdRestriction_Kind_Kind_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* EntityIdRestriction_Kind_descriptor();
+inline const ::std::string& EntityIdRestriction_Kind_Name(EntityIdRestriction_Kind value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    EntityIdRestriction_Kind_descriptor(), value);
+}
+inline bool EntityIdRestriction_Kind_Parse(
+    const ::std::string& name, EntityIdRestriction_Kind* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<EntityIdRestriction_Kind>(
+    EntityIdRestriction_Kind_descriptor(), name, value);
+}
 enum LogOption {
   HIDDEN = 1,
   HEX = 2
@@ -57,19 +92,2078 @@ inline bool LogOption_Parse(
 }
 // ===================================================================
 
+class TC_PROTO_API BGSFieldOptions : public ::google::protobuf::Message {
+ public:
+  BGSFieldOptions();
+  virtual ~BGSFieldOptions();
+
+  BGSFieldOptions(const BGSFieldOptions& from);
+
+  inline BGSFieldOptions& operator=(const BGSFieldOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BGSFieldOptions& default_instance();
+
+  void Swap(BGSFieldOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  BGSFieldOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BGSFieldOptions& from);
+  void MergeFrom(const BGSFieldOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.LogOption log = 1;
+  inline bool has_log() const;
+  inline void clear_log();
+  static const int kLogFieldNumber = 1;
+  inline ::bgs::protocol::LogOption log() const;
+  inline void set_log(::bgs::protocol::LogOption value);
+
+  // optional bool shard_key = 2;
+  inline bool has_shard_key() const;
+  inline void clear_shard_key();
+  static const int kShardKeyFieldNumber = 2;
+  inline bool shard_key() const;
+  inline void set_shard_key(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.BGSFieldOptions)
+ private:
+  inline void set_has_log();
+  inline void clear_has_log();
+  inline void set_has_shard_key();
+  inline void clear_has_shard_key();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  int log_;
+  bool shard_key_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static BGSFieldOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API FieldRestriction : public ::google::protobuf::Message {
+ public:
+  FieldRestriction();
+  virtual ~FieldRestriction();
+
+  FieldRestriction(const FieldRestriction& from);
+
+  inline FieldRestriction& operator=(const FieldRestriction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FieldRestriction& default_instance();
+
+  enum TypeCase {
+    kSigned = 1,
+    kUnsigned = 2,
+    kFloat = 3,
+    kString = 4,
+    kRepeated = 5,
+    kMessage = 6,
+    kEntityId = 7,
+    TYPE_NOT_SET = 0,
+  };
+
+  void Swap(FieldRestriction* other);
+
+  // implements Message ----------------------------------------------
+
+  FieldRestriction* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const FieldRestriction& from);
+  void MergeFrom(const FieldRestriction& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.SignedFieldRestriction signed = 1;
+  inline bool has_signed_() const;
+  inline void clear_signed_();
+  static const int kSignedFieldNumber = 1;
+  inline const ::bgs::protocol::SignedFieldRestriction& signed_() const;
+  inline ::bgs::protocol::SignedFieldRestriction* mutable_signed_();
+  inline ::bgs::protocol::SignedFieldRestriction* release_signed_();
+  inline void set_allocated_signed_(::bgs::protocol::SignedFieldRestriction* signed_);
+
+  // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 2;
+  inline bool has_unsigned_() const;
+  inline void clear_unsigned_();
+  static const int kUnsignedFieldNumber = 2;
+  inline const ::bgs::protocol::UnsignedFieldRestriction& unsigned_() const;
+  inline ::bgs::protocol::UnsignedFieldRestriction* mutable_unsigned_();
+  inline ::bgs::protocol::UnsignedFieldRestriction* release_unsigned_();
+  inline void set_allocated_unsigned_(::bgs::protocol::UnsignedFieldRestriction* unsigned_);
+
+  // optional .bgs.protocol.FloatFieldRestriction float = 3;
+  inline bool has_float_() const;
+  inline void clear_float_();
+  static const int kFloatFieldNumber = 3;
+  inline const ::bgs::protocol::FloatFieldRestriction& float_() const;
+  inline ::bgs::protocol::FloatFieldRestriction* mutable_float_();
+  inline ::bgs::protocol::FloatFieldRestriction* release_float_();
+  inline void set_allocated_float_(::bgs::protocol::FloatFieldRestriction* float_);
+
+  // optional .bgs.protocol.StringFieldRestriction string = 4;
+  inline bool has_string() const;
+  inline void clear_string();
+  static const int kStringFieldNumber = 4;
+  inline const ::bgs::protocol::StringFieldRestriction& string() const;
+  inline ::bgs::protocol::StringFieldRestriction* mutable_string();
+  inline ::bgs::protocol::StringFieldRestriction* release_string();
+  inline void set_allocated_string(::bgs::protocol::StringFieldRestriction* string);
+
+  // optional .bgs.protocol.RepeatedFieldRestriction repeated = 5;
+  inline bool has_repeated() const;
+  inline void clear_repeated();
+  static const int kRepeatedFieldNumber = 5;
+  inline const ::bgs::protocol::RepeatedFieldRestriction& repeated() const;
+  inline ::bgs::protocol::RepeatedFieldRestriction* mutable_repeated();
+  inline ::bgs::protocol::RepeatedFieldRestriction* release_repeated();
+  inline void set_allocated_repeated(::bgs::protocol::RepeatedFieldRestriction* repeated);
+
+  // optional .bgs.protocol.MessageFieldRestriction message = 6;
+  inline bool has_message() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 6;
+  inline const ::bgs::protocol::MessageFieldRestriction& message() const;
+  inline ::bgs::protocol::MessageFieldRestriction* mutable_message();
+  inline ::bgs::protocol::MessageFieldRestriction* release_message();
+  inline void set_allocated_message(::bgs::protocol::MessageFieldRestriction* message);
+
+  // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 7;
+  inline const ::bgs::protocol::EntityIdRestriction& entity_id() const;
+  inline ::bgs::protocol::EntityIdRestriction* mutable_entity_id();
+  inline ::bgs::protocol::EntityIdRestriction* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityIdRestriction* entity_id);
+
+  inline TypeCase type_case() const;
+  // @@protoc_insertion_point(class_scope:bgs.protocol.FieldRestriction)
+ private:
+  inline void set_has_signed_();
+  inline void set_has_unsigned_();
+  inline void set_has_float_();
+  inline void set_has_string();
+  inline void set_has_repeated();
+  inline void set_has_message();
+  inline void set_has_entity_id();
+
+  inline bool has_type();
+  void clear_type();
+  inline void clear_has_type();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  union TypeUnion {
+    ::bgs::protocol::SignedFieldRestriction* signed__;
+    ::bgs::protocol::UnsignedFieldRestriction* unsigned__;
+    ::bgs::protocol::FloatFieldRestriction* float__;
+    ::bgs::protocol::StringFieldRestriction* string_;
+    ::bgs::protocol::RepeatedFieldRestriction* repeated_;
+    ::bgs::protocol::MessageFieldRestriction* message_;
+    ::bgs::protocol::EntityIdRestriction* entity_id_;
+  } type_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static FieldRestriction* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RepeatedFieldRestriction : public ::google::protobuf::Message {
+ public:
+  RepeatedFieldRestriction();
+  virtual ~RepeatedFieldRestriction();
+
+  RepeatedFieldRestriction(const RepeatedFieldRestriction& from);
+
+  inline RepeatedFieldRestriction& operator=(const RepeatedFieldRestriction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RepeatedFieldRestriction& default_instance();
+
+  enum TypeCase {
+    kSigned = 3,
+    kUnsigned = 4,
+    kFloat = 5,
+    kString = 6,
+    kEntityId = 7,
+    TYPE_NOT_SET = 0,
+  };
+
+  void Swap(RepeatedFieldRestriction* other);
+
+  // implements Message ----------------------------------------------
+
+  RepeatedFieldRestriction* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RepeatedFieldRestriction& from);
+  void MergeFrom(const RepeatedFieldRestriction& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange size = 1;
+  inline bool has_size() const;
+  inline void clear_size();
+  static const int kSizeFieldNumber = 1;
+  inline const ::bgs::protocol::UnsignedIntRange& size() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_size();
+  inline ::bgs::protocol::UnsignedIntRange* release_size();
+  inline void set_allocated_size(::bgs::protocol::UnsignedIntRange* size);
+
+  // optional bool unique = 2;
+  inline bool has_unique() const;
+  inline void clear_unique();
+  static const int kUniqueFieldNumber = 2;
+  inline bool unique() const;
+  inline void set_unique(bool value);
+
+  // optional .bgs.protocol.SignedFieldRestriction signed = 3;
+  inline bool has_signed_() const;
+  inline void clear_signed_();
+  static const int kSignedFieldNumber = 3;
+  inline const ::bgs::protocol::SignedFieldRestriction& signed_() const;
+  inline ::bgs::protocol::SignedFieldRestriction* mutable_signed_();
+  inline ::bgs::protocol::SignedFieldRestriction* release_signed_();
+  inline void set_allocated_signed_(::bgs::protocol::SignedFieldRestriction* signed_);
+
+  // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 4;
+  inline bool has_unsigned_() const;
+  inline void clear_unsigned_();
+  static const int kUnsignedFieldNumber = 4;
+  inline const ::bgs::protocol::UnsignedFieldRestriction& unsigned_() const;
+  inline ::bgs::protocol::UnsignedFieldRestriction* mutable_unsigned_();
+  inline ::bgs::protocol::UnsignedFieldRestriction* release_unsigned_();
+  inline void set_allocated_unsigned_(::bgs::protocol::UnsignedFieldRestriction* unsigned_);
+
+  // optional .bgs.protocol.FloatFieldRestriction float = 5;
+  inline bool has_float_() const;
+  inline void clear_float_();
+  static const int kFloatFieldNumber = 5;
+  inline const ::bgs::protocol::FloatFieldRestriction& float_() const;
+  inline ::bgs::protocol::FloatFieldRestriction* mutable_float_();
+  inline ::bgs::protocol::FloatFieldRestriction* release_float_();
+  inline void set_allocated_float_(::bgs::protocol::FloatFieldRestriction* float_);
+
+  // optional .bgs.protocol.StringFieldRestriction string = 6;
+  inline bool has_string() const;
+  inline void clear_string();
+  static const int kStringFieldNumber = 6;
+  inline const ::bgs::protocol::StringFieldRestriction& string() const;
+  inline ::bgs::protocol::StringFieldRestriction* mutable_string();
+  inline ::bgs::protocol::StringFieldRestriction* release_string();
+  inline void set_allocated_string(::bgs::protocol::StringFieldRestriction* string);
+
+  // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 7;
+  inline const ::bgs::protocol::EntityIdRestriction& entity_id() const;
+  inline ::bgs::protocol::EntityIdRestriction* mutable_entity_id();
+  inline ::bgs::protocol::EntityIdRestriction* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityIdRestriction* entity_id);
+
+  inline TypeCase type_case() const;
+  // @@protoc_insertion_point(class_scope:bgs.protocol.RepeatedFieldRestriction)
+ private:
+  inline void set_has_size();
+  inline void clear_has_size();
+  inline void set_has_unique();
+  inline void clear_has_unique();
+  inline void set_has_signed_();
+  inline void set_has_unsigned_();
+  inline void set_has_float_();
+  inline void set_has_string();
+  inline void set_has_entity_id();
+
+  inline bool has_type();
+  void clear_type();
+  inline void clear_has_type();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* size_;
+  bool unique_;
+  union TypeUnion {
+    ::bgs::protocol::SignedFieldRestriction* signed__;
+    ::bgs::protocol::UnsignedFieldRestriction* unsigned__;
+    ::bgs::protocol::FloatFieldRestriction* float__;
+    ::bgs::protocol::StringFieldRestriction* string_;
+    ::bgs::protocol::EntityIdRestriction* entity_id_;
+  } type_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static RepeatedFieldRestriction* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SignedFieldRestriction : public ::google::protobuf::Message {
+ public:
+  SignedFieldRestriction();
+  virtual ~SignedFieldRestriction();
+
+  SignedFieldRestriction(const SignedFieldRestriction& from);
+
+  inline SignedFieldRestriction& operator=(const SignedFieldRestriction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SignedFieldRestriction& default_instance();
+
+  void Swap(SignedFieldRestriction* other);
+
+  // implements Message ----------------------------------------------
+
+  SignedFieldRestriction* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SignedFieldRestriction& from);
+  void MergeFrom(const SignedFieldRestriction& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.SignedIntRange limits = 1;
+  inline bool has_limits() const;
+  inline void clear_limits();
+  static const int kLimitsFieldNumber = 1;
+  inline const ::bgs::protocol::SignedIntRange& limits() const;
+  inline ::bgs::protocol::SignedIntRange* mutable_limits();
+  inline ::bgs::protocol::SignedIntRange* release_limits();
+  inline void set_allocated_limits(::bgs::protocol::SignedIntRange* limits);
+
+  // repeated sint64 exclude = 2;
+  inline int exclude_size() const;
+  inline void clear_exclude();
+  static const int kExcludeFieldNumber = 2;
+  inline ::google::protobuf::int64 exclude(int index) const;
+  inline void set_exclude(int index, ::google::protobuf::int64 value);
+  inline void add_exclude(::google::protobuf::int64 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
+      exclude() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
+      mutable_exclude();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.SignedFieldRestriction)
+ private:
+  inline void set_has_limits();
+  inline void clear_has_limits();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::SignedIntRange* limits_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > exclude_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static SignedFieldRestriction* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API UnsignedFieldRestriction : public ::google::protobuf::Message {
+ public:
+  UnsignedFieldRestriction();
+  virtual ~UnsignedFieldRestriction();
+
+  UnsignedFieldRestriction(const UnsignedFieldRestriction& from);
+
+  inline UnsignedFieldRestriction& operator=(const UnsignedFieldRestriction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UnsignedFieldRestriction& default_instance();
+
+  void Swap(UnsignedFieldRestriction* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsignedFieldRestriction* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsignedFieldRestriction& from);
+  void MergeFrom(const UnsignedFieldRestriction& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange limits = 1;
+  inline bool has_limits() const;
+  inline void clear_limits();
+  static const int kLimitsFieldNumber = 1;
+  inline const ::bgs::protocol::UnsignedIntRange& limits() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_limits();
+  inline ::bgs::protocol::UnsignedIntRange* release_limits();
+  inline void set_allocated_limits(::bgs::protocol::UnsignedIntRange* limits);
+
+  // repeated uint64 exclude = 2;
+  inline int exclude_size() const;
+  inline void clear_exclude();
+  static const int kExcludeFieldNumber = 2;
+  inline ::google::protobuf::uint64 exclude(int index) const;
+  inline void set_exclude(int index, ::google::protobuf::uint64 value);
+  inline void add_exclude(::google::protobuf::uint64 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+      exclude() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+      mutable_exclude();
 
+  // @@protoc_insertion_point(class_scope:bgs.protocol.UnsignedFieldRestriction)
+ private:
+  inline void set_has_limits();
+  inline void clear_has_limits();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* limits_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > exclude_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsignedFieldRestriction* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API FloatFieldRestriction : public ::google::protobuf::Message {
+ public:
+  FloatFieldRestriction();
+  virtual ~FloatFieldRestriction();
+
+  FloatFieldRestriction(const FloatFieldRestriction& from);
+
+  inline FloatFieldRestriction& operator=(const FloatFieldRestriction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FloatFieldRestriction& default_instance();
+
+  void Swap(FloatFieldRestriction* other);
+
+  // implements Message ----------------------------------------------
+
+  FloatFieldRestriction* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const FloatFieldRestriction& from);
+  void MergeFrom(const FloatFieldRestriction& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.FloatRange limits = 1;
+  inline bool has_limits() const;
+  inline void clear_limits();
+  static const int kLimitsFieldNumber = 1;
+  inline const ::bgs::protocol::FloatRange& limits() const;
+  inline ::bgs::protocol::FloatRange* mutable_limits();
+  inline ::bgs::protocol::FloatRange* release_limits();
+  inline void set_allocated_limits(::bgs::protocol::FloatRange* limits);
+
+  // repeated float exclude = 2;
+  inline int exclude_size() const;
+  inline void clear_exclude();
+  static const int kExcludeFieldNumber = 2;
+  inline float exclude(int index) const;
+  inline void set_exclude(int index, float value);
+  inline void add_exclude(float value);
+  inline const ::google::protobuf::RepeatedField< float >&
+      exclude() const;
+  inline ::google::protobuf::RepeatedField< float >*
+      mutable_exclude();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.FloatFieldRestriction)
+ private:
+  inline void set_has_limits();
+  inline void clear_has_limits();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::FloatRange* limits_;
+  ::google::protobuf::RepeatedField< float > exclude_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static FloatFieldRestriction* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StringFieldRestriction : public ::google::protobuf::Message {
+ public:
+  StringFieldRestriction();
+  virtual ~StringFieldRestriction();
+
+  StringFieldRestriction(const StringFieldRestriction& from);
+
+  inline StringFieldRestriction& operator=(const StringFieldRestriction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StringFieldRestriction& default_instance();
+
+  void Swap(StringFieldRestriction* other);
+
+  // implements Message ----------------------------------------------
+
+  StringFieldRestriction* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StringFieldRestriction& from);
+  void MergeFrom(const StringFieldRestriction& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.UnsignedIntRange size = 1;
+  inline bool has_size() const;
+  inline void clear_size();
+  static const int kSizeFieldNumber = 1;
+  inline const ::bgs::protocol::UnsignedIntRange& size() const;
+  inline ::bgs::protocol::UnsignedIntRange* mutable_size();
+  inline ::bgs::protocol::UnsignedIntRange* release_size();
+  inline void set_allocated_size(::bgs::protocol::UnsignedIntRange* size);
+
+  // repeated string exclude = 2;
+  inline int exclude_size() const;
+  inline void clear_exclude();
+  static const int kExcludeFieldNumber = 2;
+  inline const ::std::string& exclude(int index) const;
+  inline ::std::string* mutable_exclude(int index);
+  inline void set_exclude(int index, const ::std::string& value);
+  inline void set_exclude(int index, const char* value);
+  inline void set_exclude(int index, const char* value, size_t size);
+  inline ::std::string* add_exclude();
+  inline void add_exclude(const ::std::string& value);
+  inline void add_exclude(const char* value);
+  inline void add_exclude(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& exclude() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_exclude();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.StringFieldRestriction)
+ private:
+  inline void set_has_size();
+  inline void clear_has_size();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::UnsignedIntRange* size_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> exclude_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static StringFieldRestriction* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API EntityIdRestriction : public ::google::protobuf::Message {
+ public:
+  EntityIdRestriction();
+  virtual ~EntityIdRestriction();
+
+  EntityIdRestriction(const EntityIdRestriction& from);
+
+  inline EntityIdRestriction& operator=(const EntityIdRestriction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EntityIdRestriction& default_instance();
+
+  void Swap(EntityIdRestriction* other);
+
+  // implements Message ----------------------------------------------
+
+  EntityIdRestriction* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const EntityIdRestriction& from);
+  void MergeFrom(const EntityIdRestriction& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef EntityIdRestriction_Kind Kind;
+  static const Kind ANY = EntityIdRestriction_Kind_ANY;
+  static const Kind ACCOUNT = EntityIdRestriction_Kind_ACCOUNT;
+  static const Kind GAME_ACCOUNT = EntityIdRestriction_Kind_GAME_ACCOUNT;
+  static const Kind ACCOUNT_OR_GAME_ACCOUNT = EntityIdRestriction_Kind_ACCOUNT_OR_GAME_ACCOUNT;
+  static const Kind SERVICE = EntityIdRestriction_Kind_SERVICE;
+  static const Kind CHANNEL = EntityIdRestriction_Kind_CHANNEL;
+  static inline bool Kind_IsValid(int value) {
+    return EntityIdRestriction_Kind_IsValid(value);
+  }
+  static const Kind Kind_MIN =
+    EntityIdRestriction_Kind_Kind_MIN;
+  static const Kind Kind_MAX =
+    EntityIdRestriction_Kind_Kind_MAX;
+  static const int Kind_ARRAYSIZE =
+    EntityIdRestriction_Kind_Kind_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  Kind_descriptor() {
+    return EntityIdRestriction_Kind_descriptor();
+  }
+  static inline const ::std::string& Kind_Name(Kind value) {
+    return EntityIdRestriction_Kind_Name(value);
+  }
+  static inline bool Kind_Parse(const ::std::string& name,
+      Kind* value) {
+    return EntityIdRestriction_Kind_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // optional bool needed = 1;
+  inline bool has_needed() const;
+  inline void clear_needed();
+  static const int kNeededFieldNumber = 1;
+  inline bool needed() const;
+  inline void set_needed(bool value);
+
+  // optional .bgs.protocol.EntityIdRestriction.Kind kind = 2;
+  inline bool has_kind() const;
+  inline void clear_kind();
+  static const int kKindFieldNumber = 2;
+  inline ::bgs::protocol::EntityIdRestriction_Kind kind() const;
+  inline void set_kind(::bgs::protocol::EntityIdRestriction_Kind value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.EntityIdRestriction)
+ private:
+  inline void set_has_needed();
+  inline void clear_has_needed();
+  inline void set_has_kind();
+  inline void clear_has_kind();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  bool needed_;
+  int kind_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static EntityIdRestriction* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API MessageFieldRestriction : public ::google::protobuf::Message {
+ public:
+  MessageFieldRestriction();
+  virtual ~MessageFieldRestriction();
+
+  MessageFieldRestriction(const MessageFieldRestriction& from);
+
+  inline MessageFieldRestriction& operator=(const MessageFieldRestriction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MessageFieldRestriction& default_instance();
+
+  void Swap(MessageFieldRestriction* other);
+
+  // implements Message ----------------------------------------------
+
+  MessageFieldRestriction* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MessageFieldRestriction& from);
+  void MergeFrom(const MessageFieldRestriction& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bool needed = 1;
+  inline bool has_needed() const;
+  inline void clear_needed();
+  static const int kNeededFieldNumber = 1;
+  inline bool needed() const;
+  inline void set_needed(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.MessageFieldRestriction)
+ private:
+  inline void set_has_needed();
+  inline void clear_has_needed();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  bool needed_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static MessageFieldRestriction* default_instance_;
+};
 // ===================================================================
 
 
 // ===================================================================
 
-static const int kLogFieldNumber = 50000;
+static const int kFieldOptionsFieldNumber = 90000;
+TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions,
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::BGSFieldOptions >, 11, false >
+  field_options;
+static const int kValidFieldNumber = 90001;
 TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions,
-    ::google::protobuf::internal::EnumTypeTraits< ::bgs::protocol::LogOption, ::bgs::protocol::LogOption_IsValid>, 14, false >
-  log;
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::FieldRestriction >, 11, false >
+  valid;
 
 // ===================================================================
 
+// BGSFieldOptions
+
+// optional .bgs.protocol.LogOption log = 1;
+inline bool BGSFieldOptions::has_log() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BGSFieldOptions::set_has_log() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BGSFieldOptions::clear_has_log() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BGSFieldOptions::clear_log() {
+  log_ = 1;
+  clear_has_log();
+}
+inline ::bgs::protocol::LogOption BGSFieldOptions::log() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.BGSFieldOptions.log)
+  return static_cast< ::bgs::protocol::LogOption >(log_);
+}
+inline void BGSFieldOptions::set_log(::bgs::protocol::LogOption value) {
+  assert(::bgs::protocol::LogOption_IsValid(value));
+  set_has_log();
+  log_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.BGSFieldOptions.log)
+}
+
+// optional bool shard_key = 2;
+inline bool BGSFieldOptions::has_shard_key() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void BGSFieldOptions::set_has_shard_key() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void BGSFieldOptions::clear_has_shard_key() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void BGSFieldOptions::clear_shard_key() {
+  shard_key_ = false;
+  clear_has_shard_key();
+}
+inline bool BGSFieldOptions::shard_key() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.BGSFieldOptions.shard_key)
+  return shard_key_;
+}
+inline void BGSFieldOptions::set_shard_key(bool value) {
+  set_has_shard_key();
+  shard_key_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.BGSFieldOptions.shard_key)
+}
+
+// -------------------------------------------------------------------
+
+// FieldRestriction
+
+// optional .bgs.protocol.SignedFieldRestriction signed = 1;
+inline bool FieldRestriction::has_signed_() const {
+  return type_case() == kSigned;
+}
+inline void FieldRestriction::set_has_signed_() {
+  _oneof_case_[0] = kSigned;
+}
+inline void FieldRestriction::clear_signed_() {
+  if (has_signed_()) {
+    delete type_.signed__;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::SignedFieldRestriction& FieldRestriction::signed_() const {
+  return has_signed_() ? *type_.signed__
+                      : ::bgs::protocol::SignedFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::SignedFieldRestriction* FieldRestriction::mutable_signed_() {
+  if (!has_signed_()) {
+    clear_type();
+    set_has_signed_();
+    type_.signed__ = new ::bgs::protocol::SignedFieldRestriction;
+  }
+  return type_.signed__;
+}
+inline ::bgs::protocol::SignedFieldRestriction* FieldRestriction::release_signed_() {
+  if (has_signed_()) {
+    clear_has_type();
+    ::bgs::protocol::SignedFieldRestriction* temp = type_.signed__;
+    type_.signed__ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void FieldRestriction::set_allocated_signed_(::bgs::protocol::SignedFieldRestriction* signed_) {
+  clear_type();
+  if (signed_) {
+    set_has_signed_();
+    type_.signed__ = signed_;
+  }
+}
+
+// optional .bgs.protocol.UnsignedFieldRestriction unsigned = 2;
+inline bool FieldRestriction::has_unsigned_() const {
+  return type_case() == kUnsigned;
+}
+inline void FieldRestriction::set_has_unsigned_() {
+  _oneof_case_[0] = kUnsigned;
+}
+inline void FieldRestriction::clear_unsigned_() {
+  if (has_unsigned_()) {
+    delete type_.unsigned__;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::UnsignedFieldRestriction& FieldRestriction::unsigned_() const {
+  return has_unsigned_() ? *type_.unsigned__
+                      : ::bgs::protocol::UnsignedFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::UnsignedFieldRestriction* FieldRestriction::mutable_unsigned_() {
+  if (!has_unsigned_()) {
+    clear_type();
+    set_has_unsigned_();
+    type_.unsigned__ = new ::bgs::protocol::UnsignedFieldRestriction;
+  }
+  return type_.unsigned__;
+}
+inline ::bgs::protocol::UnsignedFieldRestriction* FieldRestriction::release_unsigned_() {
+  if (has_unsigned_()) {
+    clear_has_type();
+    ::bgs::protocol::UnsignedFieldRestriction* temp = type_.unsigned__;
+    type_.unsigned__ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void FieldRestriction::set_allocated_unsigned_(::bgs::protocol::UnsignedFieldRestriction* unsigned_) {
+  clear_type();
+  if (unsigned_) {
+    set_has_unsigned_();
+    type_.unsigned__ = unsigned_;
+  }
+}
+
+// optional .bgs.protocol.FloatFieldRestriction float = 3;
+inline bool FieldRestriction::has_float_() const {
+  return type_case() == kFloat;
+}
+inline void FieldRestriction::set_has_float_() {
+  _oneof_case_[0] = kFloat;
+}
+inline void FieldRestriction::clear_float_() {
+  if (has_float_()) {
+    delete type_.float__;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::FloatFieldRestriction& FieldRestriction::float_() const {
+  return has_float_() ? *type_.float__
+                      : ::bgs::protocol::FloatFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::FloatFieldRestriction* FieldRestriction::mutable_float_() {
+  if (!has_float_()) {
+    clear_type();
+    set_has_float_();
+    type_.float__ = new ::bgs::protocol::FloatFieldRestriction;
+  }
+  return type_.float__;
+}
+inline ::bgs::protocol::FloatFieldRestriction* FieldRestriction::release_float_() {
+  if (has_float_()) {
+    clear_has_type();
+    ::bgs::protocol::FloatFieldRestriction* temp = type_.float__;
+    type_.float__ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void FieldRestriction::set_allocated_float_(::bgs::protocol::FloatFieldRestriction* float_) {
+  clear_type();
+  if (float_) {
+    set_has_float_();
+    type_.float__ = float_;
+  }
+}
+
+// optional .bgs.protocol.StringFieldRestriction string = 4;
+inline bool FieldRestriction::has_string() const {
+  return type_case() == kString;
+}
+inline void FieldRestriction::set_has_string() {
+  _oneof_case_[0] = kString;
+}
+inline void FieldRestriction::clear_string() {
+  if (has_string()) {
+    delete type_.string_;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::StringFieldRestriction& FieldRestriction::string() const {
+  return has_string() ? *type_.string_
+                      : ::bgs::protocol::StringFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::StringFieldRestriction* FieldRestriction::mutable_string() {
+  if (!has_string()) {
+    clear_type();
+    set_has_string();
+    type_.string_ = new ::bgs::protocol::StringFieldRestriction;
+  }
+  return type_.string_;
+}
+inline ::bgs::protocol::StringFieldRestriction* FieldRestriction::release_string() {
+  if (has_string()) {
+    clear_has_type();
+    ::bgs::protocol::StringFieldRestriction* temp = type_.string_;
+    type_.string_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void FieldRestriction::set_allocated_string(::bgs::protocol::StringFieldRestriction* string) {
+  clear_type();
+  if (string) {
+    set_has_string();
+    type_.string_ = string;
+  }
+}
+
+// optional .bgs.protocol.RepeatedFieldRestriction repeated = 5;
+inline bool FieldRestriction::has_repeated() const {
+  return type_case() == kRepeated;
+}
+inline void FieldRestriction::set_has_repeated() {
+  _oneof_case_[0] = kRepeated;
+}
+inline void FieldRestriction::clear_repeated() {
+  if (has_repeated()) {
+    delete type_.repeated_;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::RepeatedFieldRestriction& FieldRestriction::repeated() const {
+  return has_repeated() ? *type_.repeated_
+                      : ::bgs::protocol::RepeatedFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::RepeatedFieldRestriction* FieldRestriction::mutable_repeated() {
+  if (!has_repeated()) {
+    clear_type();
+    set_has_repeated();
+    type_.repeated_ = new ::bgs::protocol::RepeatedFieldRestriction;
+  }
+  return type_.repeated_;
+}
+inline ::bgs::protocol::RepeatedFieldRestriction* FieldRestriction::release_repeated() {
+  if (has_repeated()) {
+    clear_has_type();
+    ::bgs::protocol::RepeatedFieldRestriction* temp = type_.repeated_;
+    type_.repeated_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void FieldRestriction::set_allocated_repeated(::bgs::protocol::RepeatedFieldRestriction* repeated) {
+  clear_type();
+  if (repeated) {
+    set_has_repeated();
+    type_.repeated_ = repeated;
+  }
+}
+
+// optional .bgs.protocol.MessageFieldRestriction message = 6;
+inline bool FieldRestriction::has_message() const {
+  return type_case() == kMessage;
+}
+inline void FieldRestriction::set_has_message() {
+  _oneof_case_[0] = kMessage;
+}
+inline void FieldRestriction::clear_message() {
+  if (has_message()) {
+    delete type_.message_;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::MessageFieldRestriction& FieldRestriction::message() const {
+  return has_message() ? *type_.message_
+                      : ::bgs::protocol::MessageFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::MessageFieldRestriction* FieldRestriction::mutable_message() {
+  if (!has_message()) {
+    clear_type();
+    set_has_message();
+    type_.message_ = new ::bgs::protocol::MessageFieldRestriction;
+  }
+  return type_.message_;
+}
+inline ::bgs::protocol::MessageFieldRestriction* FieldRestriction::release_message() {
+  if (has_message()) {
+    clear_has_type();
+    ::bgs::protocol::MessageFieldRestriction* temp = type_.message_;
+    type_.message_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void FieldRestriction::set_allocated_message(::bgs::protocol::MessageFieldRestriction* message) {
+  clear_type();
+  if (message) {
+    set_has_message();
+    type_.message_ = message;
+  }
+}
+
+// optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+inline bool FieldRestriction::has_entity_id() const {
+  return type_case() == kEntityId;
+}
+inline void FieldRestriction::set_has_entity_id() {
+  _oneof_case_[0] = kEntityId;
+}
+inline void FieldRestriction::clear_entity_id() {
+  if (has_entity_id()) {
+    delete type_.entity_id_;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::EntityIdRestriction& FieldRestriction::entity_id() const {
+  return has_entity_id() ? *type_.entity_id_
+                      : ::bgs::protocol::EntityIdRestriction::default_instance();
+}
+inline ::bgs::protocol::EntityIdRestriction* FieldRestriction::mutable_entity_id() {
+  if (!has_entity_id()) {
+    clear_type();
+    set_has_entity_id();
+    type_.entity_id_ = new ::bgs::protocol::EntityIdRestriction;
+  }
+  return type_.entity_id_;
+}
+inline ::bgs::protocol::EntityIdRestriction* FieldRestriction::release_entity_id() {
+  if (has_entity_id()) {
+    clear_has_type();
+    ::bgs::protocol::EntityIdRestriction* temp = type_.entity_id_;
+    type_.entity_id_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void FieldRestriction::set_allocated_entity_id(::bgs::protocol::EntityIdRestriction* entity_id) {
+  clear_type();
+  if (entity_id) {
+    set_has_entity_id();
+    type_.entity_id_ = entity_id;
+  }
+}
+
+inline bool FieldRestriction::has_type() {
+  return type_case() != TYPE_NOT_SET;
+}
+inline void FieldRestriction::clear_has_type() {
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+inline FieldRestriction::TypeCase FieldRestriction::type_case() const {
+  return FieldRestriction::TypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// RepeatedFieldRestriction
+
+// optional .bgs.protocol.UnsignedIntRange size = 1;
+inline bool RepeatedFieldRestriction::has_size() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RepeatedFieldRestriction::set_has_size() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RepeatedFieldRestriction::clear_has_size() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RepeatedFieldRestriction::clear_size() {
+  if (size_ != NULL) size_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_size();
+}
+inline const ::bgs::protocol::UnsignedIntRange& RepeatedFieldRestriction::size() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RepeatedFieldRestriction.size)
+  return size_ != NULL ? *size_ : *default_instance_->size_;
+}
+inline ::bgs::protocol::UnsignedIntRange* RepeatedFieldRestriction::mutable_size() {
+  set_has_size();
+  if (size_ == NULL) size_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.RepeatedFieldRestriction.size)
+  return size_;
+}
+inline ::bgs::protocol::UnsignedIntRange* RepeatedFieldRestriction::release_size() {
+  clear_has_size();
+  ::bgs::protocol::UnsignedIntRange* temp = size_;
+  size_ = NULL;
+  return temp;
+}
+inline void RepeatedFieldRestriction::set_allocated_size(::bgs::protocol::UnsignedIntRange* size) {
+  delete size_;
+  size_ = size;
+  if (size) {
+    set_has_size();
+  } else {
+    clear_has_size();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.RepeatedFieldRestriction.size)
+}
+
+// optional bool unique = 2;
+inline bool RepeatedFieldRestriction::has_unique() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RepeatedFieldRestriction::set_has_unique() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RepeatedFieldRestriction::clear_has_unique() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RepeatedFieldRestriction::clear_unique() {
+  unique_ = false;
+  clear_has_unique();
+}
+inline bool RepeatedFieldRestriction::unique() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RepeatedFieldRestriction.unique)
+  return unique_;
+}
+inline void RepeatedFieldRestriction::set_unique(bool value) {
+  set_has_unique();
+  unique_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.RepeatedFieldRestriction.unique)
+}
+
+// optional .bgs.protocol.SignedFieldRestriction signed = 3;
+inline bool RepeatedFieldRestriction::has_signed_() const {
+  return type_case() == kSigned;
+}
+inline void RepeatedFieldRestriction::set_has_signed_() {
+  _oneof_case_[0] = kSigned;
+}
+inline void RepeatedFieldRestriction::clear_signed_() {
+  if (has_signed_()) {
+    delete type_.signed__;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::SignedFieldRestriction& RepeatedFieldRestriction::signed_() const {
+  return has_signed_() ? *type_.signed__
+                      : ::bgs::protocol::SignedFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::SignedFieldRestriction* RepeatedFieldRestriction::mutable_signed_() {
+  if (!has_signed_()) {
+    clear_type();
+    set_has_signed_();
+    type_.signed__ = new ::bgs::protocol::SignedFieldRestriction;
+  }
+  return type_.signed__;
+}
+inline ::bgs::protocol::SignedFieldRestriction* RepeatedFieldRestriction::release_signed_() {
+  if (has_signed_()) {
+    clear_has_type();
+    ::bgs::protocol::SignedFieldRestriction* temp = type_.signed__;
+    type_.signed__ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void RepeatedFieldRestriction::set_allocated_signed_(::bgs::protocol::SignedFieldRestriction* signed_) {
+  clear_type();
+  if (signed_) {
+    set_has_signed_();
+    type_.signed__ = signed_;
+  }
+}
+
+// optional .bgs.protocol.UnsignedFieldRestriction unsigned = 4;
+inline bool RepeatedFieldRestriction::has_unsigned_() const {
+  return type_case() == kUnsigned;
+}
+inline void RepeatedFieldRestriction::set_has_unsigned_() {
+  _oneof_case_[0] = kUnsigned;
+}
+inline void RepeatedFieldRestriction::clear_unsigned_() {
+  if (has_unsigned_()) {
+    delete type_.unsigned__;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::UnsignedFieldRestriction& RepeatedFieldRestriction::unsigned_() const {
+  return has_unsigned_() ? *type_.unsigned__
+                      : ::bgs::protocol::UnsignedFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::UnsignedFieldRestriction* RepeatedFieldRestriction::mutable_unsigned_() {
+  if (!has_unsigned_()) {
+    clear_type();
+    set_has_unsigned_();
+    type_.unsigned__ = new ::bgs::protocol::UnsignedFieldRestriction;
+  }
+  return type_.unsigned__;
+}
+inline ::bgs::protocol::UnsignedFieldRestriction* RepeatedFieldRestriction::release_unsigned_() {
+  if (has_unsigned_()) {
+    clear_has_type();
+    ::bgs::protocol::UnsignedFieldRestriction* temp = type_.unsigned__;
+    type_.unsigned__ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void RepeatedFieldRestriction::set_allocated_unsigned_(::bgs::protocol::UnsignedFieldRestriction* unsigned_) {
+  clear_type();
+  if (unsigned_) {
+    set_has_unsigned_();
+    type_.unsigned__ = unsigned_;
+  }
+}
+
+// optional .bgs.protocol.FloatFieldRestriction float = 5;
+inline bool RepeatedFieldRestriction::has_float_() const {
+  return type_case() == kFloat;
+}
+inline void RepeatedFieldRestriction::set_has_float_() {
+  _oneof_case_[0] = kFloat;
+}
+inline void RepeatedFieldRestriction::clear_float_() {
+  if (has_float_()) {
+    delete type_.float__;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::FloatFieldRestriction& RepeatedFieldRestriction::float_() const {
+  return has_float_() ? *type_.float__
+                      : ::bgs::protocol::FloatFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::FloatFieldRestriction* RepeatedFieldRestriction::mutable_float_() {
+  if (!has_float_()) {
+    clear_type();
+    set_has_float_();
+    type_.float__ = new ::bgs::protocol::FloatFieldRestriction;
+  }
+  return type_.float__;
+}
+inline ::bgs::protocol::FloatFieldRestriction* RepeatedFieldRestriction::release_float_() {
+  if (has_float_()) {
+    clear_has_type();
+    ::bgs::protocol::FloatFieldRestriction* temp = type_.float__;
+    type_.float__ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void RepeatedFieldRestriction::set_allocated_float_(::bgs::protocol::FloatFieldRestriction* float_) {
+  clear_type();
+  if (float_) {
+    set_has_float_();
+    type_.float__ = float_;
+  }
+}
+
+// optional .bgs.protocol.StringFieldRestriction string = 6;
+inline bool RepeatedFieldRestriction::has_string() const {
+  return type_case() == kString;
+}
+inline void RepeatedFieldRestriction::set_has_string() {
+  _oneof_case_[0] = kString;
+}
+inline void RepeatedFieldRestriction::clear_string() {
+  if (has_string()) {
+    delete type_.string_;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::StringFieldRestriction& RepeatedFieldRestriction::string() const {
+  return has_string() ? *type_.string_
+                      : ::bgs::protocol::StringFieldRestriction::default_instance();
+}
+inline ::bgs::protocol::StringFieldRestriction* RepeatedFieldRestriction::mutable_string() {
+  if (!has_string()) {
+    clear_type();
+    set_has_string();
+    type_.string_ = new ::bgs::protocol::StringFieldRestriction;
+  }
+  return type_.string_;
+}
+inline ::bgs::protocol::StringFieldRestriction* RepeatedFieldRestriction::release_string() {
+  if (has_string()) {
+    clear_has_type();
+    ::bgs::protocol::StringFieldRestriction* temp = type_.string_;
+    type_.string_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void RepeatedFieldRestriction::set_allocated_string(::bgs::protocol::StringFieldRestriction* string) {
+  clear_type();
+  if (string) {
+    set_has_string();
+    type_.string_ = string;
+  }
+}
+
+// optional .bgs.protocol.EntityIdRestriction entity_id = 7;
+inline bool RepeatedFieldRestriction::has_entity_id() const {
+  return type_case() == kEntityId;
+}
+inline void RepeatedFieldRestriction::set_has_entity_id() {
+  _oneof_case_[0] = kEntityId;
+}
+inline void RepeatedFieldRestriction::clear_entity_id() {
+  if (has_entity_id()) {
+    delete type_.entity_id_;
+    clear_has_type();
+  }
+}
+inline const ::bgs::protocol::EntityIdRestriction& RepeatedFieldRestriction::entity_id() const {
+  return has_entity_id() ? *type_.entity_id_
+                      : ::bgs::protocol::EntityIdRestriction::default_instance();
+}
+inline ::bgs::protocol::EntityIdRestriction* RepeatedFieldRestriction::mutable_entity_id() {
+  if (!has_entity_id()) {
+    clear_type();
+    set_has_entity_id();
+    type_.entity_id_ = new ::bgs::protocol::EntityIdRestriction;
+  }
+  return type_.entity_id_;
+}
+inline ::bgs::protocol::EntityIdRestriction* RepeatedFieldRestriction::release_entity_id() {
+  if (has_entity_id()) {
+    clear_has_type();
+    ::bgs::protocol::EntityIdRestriction* temp = type_.entity_id_;
+    type_.entity_id_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void RepeatedFieldRestriction::set_allocated_entity_id(::bgs::protocol::EntityIdRestriction* entity_id) {
+  clear_type();
+  if (entity_id) {
+    set_has_entity_id();
+    type_.entity_id_ = entity_id;
+  }
+}
+
+inline bool RepeatedFieldRestriction::has_type() {
+  return type_case() != TYPE_NOT_SET;
+}
+inline void RepeatedFieldRestriction::clear_has_type() {
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+inline RepeatedFieldRestriction::TypeCase RepeatedFieldRestriction::type_case() const {
+  return RepeatedFieldRestriction::TypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// SignedFieldRestriction
+
+// optional .bgs.protocol.SignedIntRange limits = 1;
+inline bool SignedFieldRestriction::has_limits() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SignedFieldRestriction::set_has_limits() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SignedFieldRestriction::clear_has_limits() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SignedFieldRestriction::clear_limits() {
+  if (limits_ != NULL) limits_->::bgs::protocol::SignedIntRange::Clear();
+  clear_has_limits();
+}
+inline const ::bgs::protocol::SignedIntRange& SignedFieldRestriction::limits() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SignedFieldRestriction.limits)
+  return limits_ != NULL ? *limits_ : *default_instance_->limits_;
+}
+inline ::bgs::protocol::SignedIntRange* SignedFieldRestriction::mutable_limits() {
+  set_has_limits();
+  if (limits_ == NULL) limits_ = new ::bgs::protocol::SignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.SignedFieldRestriction.limits)
+  return limits_;
+}
+inline ::bgs::protocol::SignedIntRange* SignedFieldRestriction::release_limits() {
+  clear_has_limits();
+  ::bgs::protocol::SignedIntRange* temp = limits_;
+  limits_ = NULL;
+  return temp;
+}
+inline void SignedFieldRestriction::set_allocated_limits(::bgs::protocol::SignedIntRange* limits) {
+  delete limits_;
+  limits_ = limits;
+  if (limits) {
+    set_has_limits();
+  } else {
+    clear_has_limits();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SignedFieldRestriction.limits)
+}
+
+// repeated sint64 exclude = 2;
+inline int SignedFieldRestriction::exclude_size() const {
+  return exclude_.size();
+}
+inline void SignedFieldRestriction::clear_exclude() {
+  exclude_.Clear();
+}
+inline ::google::protobuf::int64 SignedFieldRestriction::exclude(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SignedFieldRestriction.exclude)
+  return exclude_.Get(index);
+}
+inline void SignedFieldRestriction::set_exclude(int index, ::google::protobuf::int64 value) {
+  exclude_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.SignedFieldRestriction.exclude)
+}
+inline void SignedFieldRestriction::add_exclude(::google::protobuf::int64 value) {
+  exclude_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.SignedFieldRestriction.exclude)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
+SignedFieldRestriction::exclude() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.SignedFieldRestriction.exclude)
+  return exclude_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
+SignedFieldRestriction::mutable_exclude() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.SignedFieldRestriction.exclude)
+  return &exclude_;
+}
+
+// -------------------------------------------------------------------
+
+// UnsignedFieldRestriction
+
+// optional .bgs.protocol.UnsignedIntRange limits = 1;
+inline bool UnsignedFieldRestriction::has_limits() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsignedFieldRestriction::set_has_limits() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsignedFieldRestriction::clear_has_limits() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsignedFieldRestriction::clear_limits() {
+  if (limits_ != NULL) limits_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_limits();
+}
+inline const ::bgs::protocol::UnsignedIntRange& UnsignedFieldRestriction::limits() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.UnsignedFieldRestriction.limits)
+  return limits_ != NULL ? *limits_ : *default_instance_->limits_;
+}
+inline ::bgs::protocol::UnsignedIntRange* UnsignedFieldRestriction::mutable_limits() {
+  set_has_limits();
+  if (limits_ == NULL) limits_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.UnsignedFieldRestriction.limits)
+  return limits_;
+}
+inline ::bgs::protocol::UnsignedIntRange* UnsignedFieldRestriction::release_limits() {
+  clear_has_limits();
+  ::bgs::protocol::UnsignedIntRange* temp = limits_;
+  limits_ = NULL;
+  return temp;
+}
+inline void UnsignedFieldRestriction::set_allocated_limits(::bgs::protocol::UnsignedIntRange* limits) {
+  delete limits_;
+  limits_ = limits;
+  if (limits) {
+    set_has_limits();
+  } else {
+    clear_has_limits();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.UnsignedFieldRestriction.limits)
+}
+
+// repeated uint64 exclude = 2;
+inline int UnsignedFieldRestriction::exclude_size() const {
+  return exclude_.size();
+}
+inline void UnsignedFieldRestriction::clear_exclude() {
+  exclude_.Clear();
+}
+inline ::google::protobuf::uint64 UnsignedFieldRestriction::exclude(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.UnsignedFieldRestriction.exclude)
+  return exclude_.Get(index);
+}
+inline void UnsignedFieldRestriction::set_exclude(int index, ::google::protobuf::uint64 value) {
+  exclude_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.UnsignedFieldRestriction.exclude)
+}
+inline void UnsignedFieldRestriction::add_exclude(::google::protobuf::uint64 value) {
+  exclude_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.UnsignedFieldRestriction.exclude)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
+UnsignedFieldRestriction::exclude() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.UnsignedFieldRestriction.exclude)
+  return exclude_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
+UnsignedFieldRestriction::mutable_exclude() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.UnsignedFieldRestriction.exclude)
+  return &exclude_;
+}
+
+// -------------------------------------------------------------------
+
+// FloatFieldRestriction
+
+// optional .bgs.protocol.FloatRange limits = 1;
+inline bool FloatFieldRestriction::has_limits() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FloatFieldRestriction::set_has_limits() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FloatFieldRestriction::clear_has_limits() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FloatFieldRestriction::clear_limits() {
+  if (limits_ != NULL) limits_->::bgs::protocol::FloatRange::Clear();
+  clear_has_limits();
+}
+inline const ::bgs::protocol::FloatRange& FloatFieldRestriction::limits() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.FloatFieldRestriction.limits)
+  return limits_ != NULL ? *limits_ : *default_instance_->limits_;
+}
+inline ::bgs::protocol::FloatRange* FloatFieldRestriction::mutable_limits() {
+  set_has_limits();
+  if (limits_ == NULL) limits_ = new ::bgs::protocol::FloatRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.FloatFieldRestriction.limits)
+  return limits_;
+}
+inline ::bgs::protocol::FloatRange* FloatFieldRestriction::release_limits() {
+  clear_has_limits();
+  ::bgs::protocol::FloatRange* temp = limits_;
+  limits_ = NULL;
+  return temp;
+}
+inline void FloatFieldRestriction::set_allocated_limits(::bgs::protocol::FloatRange* limits) {
+  delete limits_;
+  limits_ = limits;
+  if (limits) {
+    set_has_limits();
+  } else {
+    clear_has_limits();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.FloatFieldRestriction.limits)
+}
+
+// repeated float exclude = 2;
+inline int FloatFieldRestriction::exclude_size() const {
+  return exclude_.size();
+}
+inline void FloatFieldRestriction::clear_exclude() {
+  exclude_.Clear();
+}
+inline float FloatFieldRestriction::exclude(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.FloatFieldRestriction.exclude)
+  return exclude_.Get(index);
+}
+inline void FloatFieldRestriction::set_exclude(int index, float value) {
+  exclude_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.FloatFieldRestriction.exclude)
+}
+inline void FloatFieldRestriction::add_exclude(float value) {
+  exclude_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.FloatFieldRestriction.exclude)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+FloatFieldRestriction::exclude() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.FloatFieldRestriction.exclude)
+  return exclude_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+FloatFieldRestriction::mutable_exclude() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.FloatFieldRestriction.exclude)
+  return &exclude_;
+}
+
+// -------------------------------------------------------------------
+
+// StringFieldRestriction
+
+// optional .bgs.protocol.UnsignedIntRange size = 1;
+inline bool StringFieldRestriction::has_size() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StringFieldRestriction::set_has_size() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StringFieldRestriction::clear_has_size() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StringFieldRestriction::clear_size() {
+  if (size_ != NULL) size_->::bgs::protocol::UnsignedIntRange::Clear();
+  clear_has_size();
+}
+inline const ::bgs::protocol::UnsignedIntRange& StringFieldRestriction::size() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.StringFieldRestriction.size)
+  return size_ != NULL ? *size_ : *default_instance_->size_;
+}
+inline ::bgs::protocol::UnsignedIntRange* StringFieldRestriction::mutable_size() {
+  set_has_size();
+  if (size_ == NULL) size_ = new ::bgs::protocol::UnsignedIntRange;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.StringFieldRestriction.size)
+  return size_;
+}
+inline ::bgs::protocol::UnsignedIntRange* StringFieldRestriction::release_size() {
+  clear_has_size();
+  ::bgs::protocol::UnsignedIntRange* temp = size_;
+  size_ = NULL;
+  return temp;
+}
+inline void StringFieldRestriction::set_allocated_size(::bgs::protocol::UnsignedIntRange* size) {
+  delete size_;
+  size_ = size;
+  if (size) {
+    set_has_size();
+  } else {
+    clear_has_size();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.StringFieldRestriction.size)
+}
+
+// repeated string exclude = 2;
+inline int StringFieldRestriction::exclude_size() const {
+  return exclude_.size();
+}
+inline void StringFieldRestriction::clear_exclude() {
+  exclude_.Clear();
+}
+inline const ::std::string& StringFieldRestriction::exclude(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.StringFieldRestriction.exclude)
+  return exclude_.Get(index);
+}
+inline ::std::string* StringFieldRestriction::mutable_exclude(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.StringFieldRestriction.exclude)
+  return exclude_.Mutable(index);
+}
+inline void StringFieldRestriction::set_exclude(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:bgs.protocol.StringFieldRestriction.exclude)
+  exclude_.Mutable(index)->assign(value);
+}
+inline void StringFieldRestriction::set_exclude(int index, const char* value) {
+  exclude_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.StringFieldRestriction.exclude)
+}
+inline void StringFieldRestriction::set_exclude(int index, const char* value, size_t size) {
+  exclude_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.StringFieldRestriction.exclude)
+}
+inline ::std::string* StringFieldRestriction::add_exclude() {
+  return exclude_.Add();
+}
+inline void StringFieldRestriction::add_exclude(const ::std::string& value) {
+  exclude_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.StringFieldRestriction.exclude)
+}
+inline void StringFieldRestriction::add_exclude(const char* value) {
+  exclude_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:bgs.protocol.StringFieldRestriction.exclude)
+}
+inline void StringFieldRestriction::add_exclude(const char* value, size_t size) {
+  exclude_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.StringFieldRestriction.exclude)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+StringFieldRestriction::exclude() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.StringFieldRestriction.exclude)
+  return exclude_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+StringFieldRestriction::mutable_exclude() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.StringFieldRestriction.exclude)
+  return &exclude_;
+}
+
+// -------------------------------------------------------------------
+
+// EntityIdRestriction
+
+// optional bool needed = 1;
+inline bool EntityIdRestriction::has_needed() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EntityIdRestriction::set_has_needed() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EntityIdRestriction::clear_has_needed() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EntityIdRestriction::clear_needed() {
+  needed_ = false;
+  clear_has_needed();
+}
+inline bool EntityIdRestriction::needed() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EntityIdRestriction.needed)
+  return needed_;
+}
+inline void EntityIdRestriction::set_needed(bool value) {
+  set_has_needed();
+  needed_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.EntityIdRestriction.needed)
+}
+
+// optional .bgs.protocol.EntityIdRestriction.Kind kind = 2;
+inline bool EntityIdRestriction::has_kind() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EntityIdRestriction::set_has_kind() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EntityIdRestriction::clear_has_kind() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EntityIdRestriction::clear_kind() {
+  kind_ = 0;
+  clear_has_kind();
+}
+inline ::bgs::protocol::EntityIdRestriction_Kind EntityIdRestriction::kind() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EntityIdRestriction.kind)
+  return static_cast< ::bgs::protocol::EntityIdRestriction_Kind >(kind_);
+}
+inline void EntityIdRestriction::set_kind(::bgs::protocol::EntityIdRestriction_Kind value) {
+  assert(::bgs::protocol::EntityIdRestriction_Kind_IsValid(value));
+  set_has_kind();
+  kind_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.EntityIdRestriction.kind)
+}
+
+// -------------------------------------------------------------------
+
+// MessageFieldRestriction
+
+// optional bool needed = 1;
+inline bool MessageFieldRestriction::has_needed() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MessageFieldRestriction::set_has_needed() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MessageFieldRestriction::clear_has_needed() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MessageFieldRestriction::clear_needed() {
+  needed_ = false;
+  clear_has_needed();
+}
+inline bool MessageFieldRestriction::needed() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.MessageFieldRestriction.needed)
+  return needed_;
+}
+inline void MessageFieldRestriction::set_needed(bool value) {
+  set_has_needed();
+  needed_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.MessageFieldRestriction.needed)
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 
@@ -80,6 +2174,11 @@ TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google:
 namespace google {
 namespace protobuf {
 
+template <> struct is_proto_enum< ::bgs::protocol::EntityIdRestriction_Kind> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::EntityIdRestriction_Kind>() {
+  return ::bgs::protocol::EntityIdRestriction_Kind_descriptor();
+}
 template <> struct is_proto_enum< ::bgs::protocol::LogOption> : ::google::protobuf::internal::true_type {};
 template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::LogOption>() {
diff --git a/src/server/proto/Client/global_extensions/message_options.pb.cc b/src/server/proto/Client/global_extensions/message_options.pb.cc
new file mode 100644
index 00000000000..814967073f9
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/message_options.pb.cc
@@ -0,0 +1,390 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/message_options.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "global_extensions/message_options.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* BGSMessageOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BGSMessageOptions_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_global_5fextensions_2fmessage_5foptions_2eproto() {
+  protobuf_AddDesc_global_5fextensions_2fmessage_5foptions_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "global_extensions/message_options.proto");
+  GOOGLE_CHECK(file != NULL);
+  BGSMessageOptions_descriptor_ = file->message_type(0);
+  static const int BGSMessageOptions_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSMessageOptions, custom_select_shard_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSMessageOptions, custom_validator_),
+  };
+  BGSMessageOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BGSMessageOptions_descriptor_,
+      BGSMessageOptions::default_instance_,
+      BGSMessageOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSMessageOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSMessageOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BGSMessageOptions));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_global_5fextensions_2fmessage_5foptions_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BGSMessageOptions_descriptor_, &BGSMessageOptions::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_global_5fextensions_2fmessage_5foptions_2eproto() {
+  delete BGSMessageOptions::default_instance_;
+  delete BGSMessageOptions_reflection_;
+}
+
+void protobuf_AddDesc_global_5fextensions_2fmessage_5foptions_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\'global_extensions/message_options.prot"
+    "o\022\014bgs.protocol\032 google/protobuf/descrip"
+    "tor.proto\"J\n\021BGSMessageOptions\022\033\n\023custom"
+    "_select_shard\030\001 \001(\010\022\030\n\020custom_validator\030"
+    "\002 \001(\010:[\n\017message_options\022\037.google.protob"
+    "uf.MessageOptions\030\220\277\005 \001(\0132\037.bgs.protocol"
+    ".BGSMessageOptionsB&\n\rbnet.protocolB\023Mes"
+    "sageOptionsProtoH\001", 298);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "global_extensions/message_options.proto", &protobuf_RegisterTypes);
+  BGSMessageOptions::default_instance_ = new BGSMessageOptions();
+  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
+    &::google::protobuf::MessageOptions::default_instance(),
+    90000, 11, false, false,
+    &::bgs::protocol::BGSMessageOptions::default_instance());
+  BGSMessageOptions::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2fmessage_5foptions_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_global_5fextensions_2fmessage_5foptions_2eproto {
+  StaticDescriptorInitializer_global_5fextensions_2fmessage_5foptions_2eproto() {
+    protobuf_AddDesc_global_5fextensions_2fmessage_5foptions_2eproto();
+  }
+} static_descriptor_initializer_global_5fextensions_2fmessage_5foptions_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BGSMessageOptions::kCustomSelectShardFieldNumber;
+const int BGSMessageOptions::kCustomValidatorFieldNumber;
+#endif  // !_MSC_VER
+
+BGSMessageOptions::BGSMessageOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.BGSMessageOptions)
+}
+
+void BGSMessageOptions::InitAsDefaultInstance() {
+}
+
+BGSMessageOptions::BGSMessageOptions(const BGSMessageOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.BGSMessageOptions)
+}
+
+void BGSMessageOptions::SharedCtor() {
+  _cached_size_ = 0;
+  custom_select_shard_ = false;
+  custom_validator_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BGSMessageOptions::~BGSMessageOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.BGSMessageOptions)
+  SharedDtor();
+}
+
+void BGSMessageOptions::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void BGSMessageOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BGSMessageOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BGSMessageOptions_descriptor_;
+}
+
+const BGSMessageOptions& BGSMessageOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2fmessage_5foptions_2eproto();
+  return *default_instance_;
+}
+
+BGSMessageOptions* BGSMessageOptions::default_instance_ = NULL;
+
+BGSMessageOptions* BGSMessageOptions::New() const {
+  return new BGSMessageOptions;
+}
+
+void BGSMessageOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<BGSMessageOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(custom_select_shard_, custom_validator_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BGSMessageOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.BGSMessageOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool custom_select_shard = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &custom_select_shard_)));
+          set_has_custom_select_shard();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_custom_validator;
+        break;
+      }
+
+      // optional bool custom_validator = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_custom_validator:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &custom_validator_)));
+          set_has_custom_validator();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.BGSMessageOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.BGSMessageOptions)
+  return false;
+#undef DO_
+}
+
+void BGSMessageOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.BGSMessageOptions)
+  // optional bool custom_select_shard = 1;
+  if (has_custom_select_shard()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->custom_select_shard(), output);
+  }
+
+  // optional bool custom_validator = 2;
+  if (has_custom_validator()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->custom_validator(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.BGSMessageOptions)
+}
+
+::google::protobuf::uint8* BGSMessageOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.BGSMessageOptions)
+  // optional bool custom_select_shard = 1;
+  if (has_custom_select_shard()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->custom_select_shard(), target);
+  }
+
+  // optional bool custom_validator = 2;
+  if (has_custom_validator()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->custom_validator(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.BGSMessageOptions)
+  return target;
+}
+
+int BGSMessageOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool custom_select_shard = 1;
+    if (has_custom_select_shard()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool custom_validator = 2;
+    if (has_custom_validator()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BGSMessageOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BGSMessageOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BGSMessageOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BGSMessageOptions::MergeFrom(const BGSMessageOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_custom_select_shard()) {
+      set_custom_select_shard(from.custom_select_shard());
+    }
+    if (from.has_custom_validator()) {
+      set_custom_validator(from.custom_validator());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BGSMessageOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BGSMessageOptions::CopyFrom(const BGSMessageOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BGSMessageOptions::IsInitialized() const {
+
+  return true;
+}
+
+void BGSMessageOptions::Swap(BGSMessageOptions* other) {
+  if (other != this) {
+    std::swap(custom_select_shard_, other->custom_select_shard_);
+    std::swap(custom_validator_, other->custom_validator_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BGSMessageOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BGSMessageOptions_descriptor_;
+  metadata.reflection = BGSMessageOptions_reflection_;
+  return metadata;
+}
+
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MessageOptions,
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::BGSMessageOptions >, 11, false >
+  message_options(kMessageOptionsFieldNumber, ::bgs::protocol::BGSMessageOptions::default_instance());
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/global_extensions/message_options.pb.h b/src/server/proto/Client/global_extensions/message_options.pb.h
new file mode 100644
index 00000000000..b9a80743723
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/message_options.pb.h
@@ -0,0 +1,209 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/message_options.proto
+
+#ifndef PROTOBUF_global_5fextensions_2fmessage_5foptions_2eproto__INCLUDED
+#define PROTOBUF_global_5fextensions_2fmessage_5foptions_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "google/protobuf/descriptor.pb.h"
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2fmessage_5foptions_2eproto();
+void protobuf_AssignDesc_global_5fextensions_2fmessage_5foptions_2eproto();
+void protobuf_ShutdownFile_global_5fextensions_2fmessage_5foptions_2eproto();
+
+class BGSMessageOptions;
+
+// ===================================================================
+
+class TC_PROTO_API BGSMessageOptions : public ::google::protobuf::Message {
+ public:
+  BGSMessageOptions();
+  virtual ~BGSMessageOptions();
+
+  BGSMessageOptions(const BGSMessageOptions& from);
+
+  inline BGSMessageOptions& operator=(const BGSMessageOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BGSMessageOptions& default_instance();
+
+  void Swap(BGSMessageOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  BGSMessageOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BGSMessageOptions& from);
+  void MergeFrom(const BGSMessageOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bool custom_select_shard = 1;
+  inline bool has_custom_select_shard() const;
+  inline void clear_custom_select_shard();
+  static const int kCustomSelectShardFieldNumber = 1;
+  inline bool custom_select_shard() const;
+  inline void set_custom_select_shard(bool value);
+
+  // optional bool custom_validator = 2;
+  inline bool has_custom_validator() const;
+  inline void clear_custom_validator();
+  static const int kCustomValidatorFieldNumber = 2;
+  inline bool custom_validator() const;
+  inline void set_custom_validator(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.BGSMessageOptions)
+ private:
+  inline void set_has_custom_select_shard();
+  inline void clear_has_custom_select_shard();
+  inline void set_has_custom_validator();
+  inline void clear_has_custom_validator();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  bool custom_select_shard_;
+  bool custom_validator_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2fmessage_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2fmessage_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2fmessage_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static BGSMessageOptions* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+static const int kMessageOptionsFieldNumber = 90000;
+TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MessageOptions,
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::BGSMessageOptions >, 11, false >
+  message_options;
+
+// ===================================================================
+
+// BGSMessageOptions
+
+// optional bool custom_select_shard = 1;
+inline bool BGSMessageOptions::has_custom_select_shard() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BGSMessageOptions::set_has_custom_select_shard() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BGSMessageOptions::clear_has_custom_select_shard() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BGSMessageOptions::clear_custom_select_shard() {
+  custom_select_shard_ = false;
+  clear_has_custom_select_shard();
+}
+inline bool BGSMessageOptions::custom_select_shard() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.BGSMessageOptions.custom_select_shard)
+  return custom_select_shard_;
+}
+inline void BGSMessageOptions::set_custom_select_shard(bool value) {
+  set_has_custom_select_shard();
+  custom_select_shard_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.BGSMessageOptions.custom_select_shard)
+}
+
+// optional bool custom_validator = 2;
+inline bool BGSMessageOptions::has_custom_validator() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void BGSMessageOptions::set_has_custom_validator() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void BGSMessageOptions::clear_has_custom_validator() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void BGSMessageOptions::clear_custom_validator() {
+  custom_validator_ = false;
+  clear_has_custom_validator();
+}
+inline bool BGSMessageOptions::custom_validator() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.BGSMessageOptions.custom_validator)
+  return custom_validator_;
+}
+inline void BGSMessageOptions::set_custom_validator(bool value) {
+  set_has_custom_validator();
+  custom_validator_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.BGSMessageOptions.custom_validator)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_global_5fextensions_2fmessage_5foptions_2eproto__INCLUDED
diff --git a/src/server/proto/Client/global_extensions/method_options.pb.cc b/src/server/proto/Client/global_extensions/method_options.pb.cc
index ad95780a845..836aaa5e575 100644
--- a/src/server/proto/Client/global_extensions/method_options.pb.cc
+++ b/src/server/proto/Client/global_extensions/method_options.pb.cc
@@ -18,16 +18,14 @@
 #include "Log.h"
 // @@protoc_insertion_point(includes)
 
-// Fix stupid windows.h included from Log.h->Common.h
-#ifdef SendMessage
-#undef SendMessage
-#endif
-
 namespace bgs {
 namespace protocol {
 
 namespace {
 
+const ::google::protobuf::Descriptor* BGSMethodOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BGSMethodOptions_reflection_ = NULL;
 
 }  // namespace
 
@@ -38,6 +36,21 @@ void protobuf_AssignDesc_global_5fextensions_2fmethod_5foptions_2eproto() {
     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
       "global_extensions/method_options.proto");
   GOOGLE_CHECK(file != NULL);
+  BGSMethodOptions_descriptor_ = file->message_type(0);
+  static const int BGSMethodOptions_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSMethodOptions, id_),
+  };
+  BGSMethodOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BGSMethodOptions_descriptor_,
+      BGSMethodOptions::default_instance_,
+      BGSMethodOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSMethodOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSMethodOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BGSMethodOptions));
 }
 
 namespace {
@@ -50,11 +63,15 @@ inline void protobuf_AssignDescriptorsOnce() {
 
 void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BGSMethodOptions_descriptor_, &BGSMethodOptions::default_instance());
 }
 
 }  // namespace
 
 void protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto() {
+  delete BGSMethodOptions::default_instance_;
+  delete BGSMethodOptions_reflection_;
 }
 
 void protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto() {
@@ -67,14 +84,19 @@ void protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto() {
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n&global_extensions/method_options.proto"
     "\022\014bgs.protocol\032 google/protobuf/descript"
-    "or.proto:3\n\tmethod_id\022\036.google.protobuf."
-    "MethodOptions\030\320\206\003 \001(\rB%\n\rbnet.protocolB\022"
-    "MethodOptionsProtoH\001", 180);
+    "or.proto\"\036\n\020BGSMethodOptions\022\n\n\002id\030\001 \001(\r"
+    ":X\n\016method_options\022\036.google.protobuf.Met"
+    "hodOptions\030\220\277\005 \001(\0132\036.bgs.protocol.BGSMet"
+    "hodOptionsB%\n\rbnet.protocolB\022MethodOptio"
+    "nsProtoH\001", 249);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "global_extensions/method_options.proto", &protobuf_RegisterTypes);
-  ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+  BGSMethodOptions::default_instance_ = new BGSMethodOptions();
+  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
     &::google::protobuf::MethodOptions::default_instance(),
-    50000, 13, false, false);
+    90000, 11, false, false,
+    &::bgs::protocol::BGSMethodOptions::default_instance());
+  BGSMethodOptions::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto);
 }
 
@@ -84,9 +106,231 @@ struct StaticDescriptorInitializer_global_5fextensions_2fmethod_5foptions_2eprot
     protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto();
   }
 } static_descriptor_initializer_global_5fextensions_2fmethod_5foptions_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BGSMethodOptions::kIdFieldNumber;
+#endif  // !_MSC_VER
+
+BGSMethodOptions::BGSMethodOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.BGSMethodOptions)
+}
+
+void BGSMethodOptions::InitAsDefaultInstance() {
+}
+
+BGSMethodOptions::BGSMethodOptions(const BGSMethodOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.BGSMethodOptions)
+}
+
+void BGSMethodOptions::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BGSMethodOptions::~BGSMethodOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.BGSMethodOptions)
+  SharedDtor();
+}
+
+void BGSMethodOptions::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void BGSMethodOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BGSMethodOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BGSMethodOptions_descriptor_;
+}
+
+const BGSMethodOptions& BGSMethodOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto();
+  return *default_instance_;
+}
+
+BGSMethodOptions* BGSMethodOptions::default_instance_ = NULL;
+
+BGSMethodOptions* BGSMethodOptions::New() const {
+  return new BGSMethodOptions;
+}
+
+void BGSMethodOptions::Clear() {
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BGSMethodOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.BGSMethodOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.BGSMethodOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.BGSMethodOptions)
+  return false;
+#undef DO_
+}
+
+void BGSMethodOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.BGSMethodOptions)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.BGSMethodOptions)
+}
+
+::google::protobuf::uint8* BGSMethodOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.BGSMethodOptions)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.BGSMethodOptions)
+  return target;
+}
+
+int BGSMethodOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BGSMethodOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BGSMethodOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BGSMethodOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BGSMethodOptions::MergeFrom(const BGSMethodOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BGSMethodOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BGSMethodOptions::CopyFrom(const BGSMethodOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BGSMethodOptions::IsInitialized() const {
+
+  return true;
+}
+
+void BGSMethodOptions::Swap(BGSMethodOptions* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BGSMethodOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BGSMethodOptions_descriptor_;
+  metadata.reflection = BGSMethodOptions_reflection_;
+  return metadata;
+}
+
 ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
-    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
-  method_id(kMethodIdFieldNumber, 0u);
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::BGSMethodOptions >, 11, false >
+  method_options(kMethodOptionsFieldNumber, ::bgs::protocol::BGSMethodOptions::default_instance());
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/src/server/proto/Client/global_extensions/method_options.pb.h b/src/server/proto/Client/global_extensions/method_options.pb.h
index 0ca06be0c9d..a58273efa96 100644
--- a/src/server/proto/Client/global_extensions/method_options.pb.h
+++ b/src/server/proto/Client/global_extensions/method_options.pb.h
@@ -20,8 +20,10 @@
 #endif
 
 #include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
 #include "google/protobuf/descriptor.pb.h"
 #include "Define.h" // for TC_PROTO_API
 // @@protoc_insertion_point(includes)
@@ -34,22 +36,125 @@ void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eprot
 void protobuf_AssignDesc_global_5fextensions_2fmethod_5foptions_2eproto();
 void protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto();
 
+class BGSMethodOptions;
 
 // ===================================================================
 
-
+class TC_PROTO_API BGSMethodOptions : public ::google::protobuf::Message {
+ public:
+  BGSMethodOptions();
+  virtual ~BGSMethodOptions();
+
+  BGSMethodOptions(const BGSMethodOptions& from);
+
+  inline BGSMethodOptions& operator=(const BGSMethodOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BGSMethodOptions& default_instance();
+
+  void Swap(BGSMethodOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  BGSMethodOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BGSMethodOptions& from);
+  void MergeFrom(const BGSMethodOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint32 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.BGSMethodOptions)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2fmethod_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static BGSMethodOptions* default_instance_;
+};
 // ===================================================================
 
 
 // ===================================================================
 
-static const int kMethodIdFieldNumber = 50000;
+static const int kMethodOptionsFieldNumber = 90000;
 TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
-    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
-  method_id;
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::BGSMethodOptions >, 11, false >
+  method_options;
 
 // ===================================================================
 
+// BGSMethodOptions
+
+// optional uint32 id = 1;
+inline bool BGSMethodOptions::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BGSMethodOptions::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BGSMethodOptions::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BGSMethodOptions::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 BGSMethodOptions::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.BGSMethodOptions.id)
+  return id_;
+}
+inline void BGSMethodOptions::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.BGSMethodOptions.id)
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/src/server/proto/Client/global_extensions/range.pb.cc b/src/server/proto/Client/global_extensions/range.pb.cc
new file mode 100644
index 00000000000..9ab9be19327
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/range.pb.cc
@@ -0,0 +1,977 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/range.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "global_extensions/range.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* UnsignedIntRange_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsignedIntRange_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SignedIntRange_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SignedIntRange_reflection_ = NULL;
+const ::google::protobuf::Descriptor* FloatRange_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  FloatRange_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_global_5fextensions_2frange_2eproto() {
+  protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "global_extensions/range.proto");
+  GOOGLE_CHECK(file != NULL);
+  UnsignedIntRange_descriptor_ = file->message_type(0);
+  static const int UnsignedIntRange_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsignedIntRange, min_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsignedIntRange, max_),
+  };
+  UnsignedIntRange_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsignedIntRange_descriptor_,
+      UnsignedIntRange::default_instance_,
+      UnsignedIntRange_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsignedIntRange, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsignedIntRange, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsignedIntRange));
+  SignedIntRange_descriptor_ = file->message_type(1);
+  static const int SignedIntRange_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedIntRange, min_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedIntRange, max_),
+  };
+  SignedIntRange_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SignedIntRange_descriptor_,
+      SignedIntRange::default_instance_,
+      SignedIntRange_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedIntRange, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedIntRange, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SignedIntRange));
+  FloatRange_descriptor_ = file->message_type(2);
+  static const int FloatRange_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatRange, min_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatRange, max_),
+  };
+  FloatRange_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      FloatRange_descriptor_,
+      FloatRange::default_instance_,
+      FloatRange_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatRange, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatRange, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(FloatRange));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_global_5fextensions_2frange_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsignedIntRange_descriptor_, &UnsignedIntRange::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SignedIntRange_descriptor_, &SignedIntRange::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    FloatRange_descriptor_, &FloatRange::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_global_5fextensions_2frange_2eproto() {
+  delete UnsignedIntRange::default_instance_;
+  delete UnsignedIntRange_reflection_;
+  delete SignedIntRange::default_instance_;
+  delete SignedIntRange_reflection_;
+  delete FloatRange::default_instance_;
+  delete FloatRange_reflection_;
+}
+
+void protobuf_AddDesc_global_5fextensions_2frange_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\035global_extensions/range.proto\022\014bgs.pro"
+    "tocol\",\n\020UnsignedIntRange\022\013\n\003min\030\001 \001(\004\022\013"
+    "\n\003max\030\002 \001(\004\"*\n\016SignedIntRange\022\013\n\003min\030\001 \001"
+    "(\003\022\013\n\003max\030\002 \001(\003\"&\n\nFloatRange\022\013\n\003min\030\001 \001"
+    "(\002\022\013\n\003max\030\002 \001(\002B\002H\001", 179);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "global_extensions/range.proto", &protobuf_RegisterTypes);
+  UnsignedIntRange::default_instance_ = new UnsignedIntRange();
+  SignedIntRange::default_instance_ = new SignedIntRange();
+  FloatRange::default_instance_ = new FloatRange();
+  UnsignedIntRange::default_instance_->InitAsDefaultInstance();
+  SignedIntRange::default_instance_->InitAsDefaultInstance();
+  FloatRange::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2frange_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_global_5fextensions_2frange_2eproto {
+  StaticDescriptorInitializer_global_5fextensions_2frange_2eproto() {
+    protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+  }
+} static_descriptor_initializer_global_5fextensions_2frange_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsignedIntRange::kMinFieldNumber;
+const int UnsignedIntRange::kMaxFieldNumber;
+#endif  // !_MSC_VER
+
+UnsignedIntRange::UnsignedIntRange()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.UnsignedIntRange)
+}
+
+void UnsignedIntRange::InitAsDefaultInstance() {
+}
+
+UnsignedIntRange::UnsignedIntRange(const UnsignedIntRange& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.UnsignedIntRange)
+}
+
+void UnsignedIntRange::SharedCtor() {
+  _cached_size_ = 0;
+  min_ = GOOGLE_ULONGLONG(0);
+  max_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsignedIntRange::~UnsignedIntRange() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.UnsignedIntRange)
+  SharedDtor();
+}
+
+void UnsignedIntRange::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void UnsignedIntRange::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsignedIntRange::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsignedIntRange_descriptor_;
+}
+
+const UnsignedIntRange& UnsignedIntRange::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+  return *default_instance_;
+}
+
+UnsignedIntRange* UnsignedIntRange::default_instance_ = NULL;
+
+UnsignedIntRange* UnsignedIntRange::New() const {
+  return new UnsignedIntRange;
+}
+
+void UnsignedIntRange::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<UnsignedIntRange*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(min_, max_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsignedIntRange::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.UnsignedIntRange)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 min = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &min_)));
+          set_has_min();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_max;
+        break;
+      }
+
+      // optional uint64 max = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_max:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &max_)));
+          set_has_max();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.UnsignedIntRange)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.UnsignedIntRange)
+  return false;
+#undef DO_
+}
+
+void UnsignedIntRange::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.UnsignedIntRange)
+  // optional uint64 min = 1;
+  if (has_min()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->min(), output);
+  }
+
+  // optional uint64 max = 2;
+  if (has_max()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->max(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.UnsignedIntRange)
+}
+
+::google::protobuf::uint8* UnsignedIntRange::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.UnsignedIntRange)
+  // optional uint64 min = 1;
+  if (has_min()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->min(), target);
+  }
+
+  // optional uint64 max = 2;
+  if (has_max()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->max(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.UnsignedIntRange)
+  return target;
+}
+
+int UnsignedIntRange::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 min = 1;
+    if (has_min()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->min());
+    }
+
+    // optional uint64 max = 2;
+    if (has_max()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->max());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsignedIntRange::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsignedIntRange* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsignedIntRange*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsignedIntRange::MergeFrom(const UnsignedIntRange& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_min()) {
+      set_min(from.min());
+    }
+    if (from.has_max()) {
+      set_max(from.max());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsignedIntRange::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsignedIntRange::CopyFrom(const UnsignedIntRange& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsignedIntRange::IsInitialized() const {
+
+  return true;
+}
+
+void UnsignedIntRange::Swap(UnsignedIntRange* other) {
+  if (other != this) {
+    std::swap(min_, other->min_);
+    std::swap(max_, other->max_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsignedIntRange::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsignedIntRange_descriptor_;
+  metadata.reflection = UnsignedIntRange_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SignedIntRange::kMinFieldNumber;
+const int SignedIntRange::kMaxFieldNumber;
+#endif  // !_MSC_VER
+
+SignedIntRange::SignedIntRange()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.SignedIntRange)
+}
+
+void SignedIntRange::InitAsDefaultInstance() {
+}
+
+SignedIntRange::SignedIntRange(const SignedIntRange& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.SignedIntRange)
+}
+
+void SignedIntRange::SharedCtor() {
+  _cached_size_ = 0;
+  min_ = GOOGLE_LONGLONG(0);
+  max_ = GOOGLE_LONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SignedIntRange::~SignedIntRange() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.SignedIntRange)
+  SharedDtor();
+}
+
+void SignedIntRange::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void SignedIntRange::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SignedIntRange::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SignedIntRange_descriptor_;
+}
+
+const SignedIntRange& SignedIntRange::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+  return *default_instance_;
+}
+
+SignedIntRange* SignedIntRange::default_instance_ = NULL;
+
+SignedIntRange* SignedIntRange::New() const {
+  return new SignedIntRange;
+}
+
+void SignedIntRange::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<SignedIntRange*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(min_, max_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SignedIntRange::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.SignedIntRange)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int64 min = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &min_)));
+          set_has_min();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_max;
+        break;
+      }
+
+      // optional int64 max = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_max:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &max_)));
+          set_has_max();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.SignedIntRange)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.SignedIntRange)
+  return false;
+#undef DO_
+}
+
+void SignedIntRange::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.SignedIntRange)
+  // optional int64 min = 1;
+  if (has_min()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->min(), output);
+  }
+
+  // optional int64 max = 2;
+  if (has_max()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->max(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.SignedIntRange)
+}
+
+::google::protobuf::uint8* SignedIntRange::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.SignedIntRange)
+  // optional int64 min = 1;
+  if (has_min()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->min(), target);
+  }
+
+  // optional int64 max = 2;
+  if (has_max()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->max(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.SignedIntRange)
+  return target;
+}
+
+int SignedIntRange::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int64 min = 1;
+    if (has_min()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->min());
+    }
+
+    // optional int64 max = 2;
+    if (has_max()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->max());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SignedIntRange::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SignedIntRange* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SignedIntRange*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SignedIntRange::MergeFrom(const SignedIntRange& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_min()) {
+      set_min(from.min());
+    }
+    if (from.has_max()) {
+      set_max(from.max());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SignedIntRange::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SignedIntRange::CopyFrom(const SignedIntRange& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SignedIntRange::IsInitialized() const {
+
+  return true;
+}
+
+void SignedIntRange::Swap(SignedIntRange* other) {
+  if (other != this) {
+    std::swap(min_, other->min_);
+    std::swap(max_, other->max_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SignedIntRange::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SignedIntRange_descriptor_;
+  metadata.reflection = SignedIntRange_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FloatRange::kMinFieldNumber;
+const int FloatRange::kMaxFieldNumber;
+#endif  // !_MSC_VER
+
+FloatRange::FloatRange()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.FloatRange)
+}
+
+void FloatRange::InitAsDefaultInstance() {
+}
+
+FloatRange::FloatRange(const FloatRange& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.FloatRange)
+}
+
+void FloatRange::SharedCtor() {
+  _cached_size_ = 0;
+  min_ = 0;
+  max_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FloatRange::~FloatRange() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.FloatRange)
+  SharedDtor();
+}
+
+void FloatRange::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void FloatRange::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* FloatRange::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FloatRange_descriptor_;
+}
+
+const FloatRange& FloatRange::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+  return *default_instance_;
+}
+
+FloatRange* FloatRange::default_instance_ = NULL;
+
+FloatRange* FloatRange::New() const {
+  return new FloatRange;
+}
+
+void FloatRange::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<FloatRange*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(min_, max_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool FloatRange::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.FloatRange)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional float min = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &min_)));
+          set_has_min();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_max;
+        break;
+      }
+
+      // optional float max = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_max:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &max_)));
+          set_has_max();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.FloatRange)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.FloatRange)
+  return false;
+#undef DO_
+}
+
+void FloatRange::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.FloatRange)
+  // optional float min = 1;
+  if (has_min()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->min(), output);
+  }
+
+  // optional float max = 2;
+  if (has_max()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->max(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.FloatRange)
+}
+
+::google::protobuf::uint8* FloatRange::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.FloatRange)
+  // optional float min = 1;
+  if (has_min()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->min(), target);
+  }
+
+  // optional float max = 2;
+  if (has_max()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->max(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.FloatRange)
+  return target;
+}
+
+int FloatRange::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional float min = 1;
+    if (has_min()) {
+      total_size += 1 + 4;
+    }
+
+    // optional float max = 2;
+    if (has_max()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FloatRange::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const FloatRange* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const FloatRange*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void FloatRange::MergeFrom(const FloatRange& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_min()) {
+      set_min(from.min());
+    }
+    if (from.has_max()) {
+      set_max(from.max());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void FloatRange::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FloatRange::CopyFrom(const FloatRange& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FloatRange::IsInitialized() const {
+
+  return true;
+}
+
+void FloatRange::Swap(FloatRange* other) {
+  if (other != this) {
+    std::swap(min_, other->min_);
+    std::swap(max_, other->max_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata FloatRange::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = FloatRange_descriptor_;
+  metadata.reflection = FloatRange_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/global_extensions/range.pb.h b/src/server/proto/Client/global_extensions/range.pb.h
new file mode 100644
index 00000000000..57942ac5325
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/range.pb.h
@@ -0,0 +1,488 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/range.proto
+
+#ifndef PROTOBUF_global_5fextensions_2frange_2eproto__INCLUDED
+#define PROTOBUF_global_5fextensions_2frange_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+void protobuf_AssignDesc_global_5fextensions_2frange_2eproto();
+void protobuf_ShutdownFile_global_5fextensions_2frange_2eproto();
+
+class UnsignedIntRange;
+class SignedIntRange;
+class FloatRange;
+
+// ===================================================================
+
+class TC_PROTO_API UnsignedIntRange : public ::google::protobuf::Message {
+ public:
+  UnsignedIntRange();
+  virtual ~UnsignedIntRange();
+
+  UnsignedIntRange(const UnsignedIntRange& from);
+
+  inline UnsignedIntRange& operator=(const UnsignedIntRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UnsignedIntRange& default_instance();
+
+  void Swap(UnsignedIntRange* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsignedIntRange* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsignedIntRange& from);
+  void MergeFrom(const UnsignedIntRange& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 min = 1;
+  inline bool has_min() const;
+  inline void clear_min();
+  static const int kMinFieldNumber = 1;
+  inline ::google::protobuf::uint64 min() const;
+  inline void set_min(::google::protobuf::uint64 value);
+
+  // optional uint64 max = 2;
+  inline bool has_max() const;
+  inline void clear_max();
+  static const int kMaxFieldNumber = 2;
+  inline ::google::protobuf::uint64 max() const;
+  inline void set_max(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.UnsignedIntRange)
+ private:
+  inline void set_has_min();
+  inline void clear_has_min();
+  inline void set_has_max();
+  inline void clear_has_max();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 min_;
+  ::google::protobuf::uint64 max_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2frange_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2frange_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsignedIntRange* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SignedIntRange : public ::google::protobuf::Message {
+ public:
+  SignedIntRange();
+  virtual ~SignedIntRange();
+
+  SignedIntRange(const SignedIntRange& from);
+
+  inline SignedIntRange& operator=(const SignedIntRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SignedIntRange& default_instance();
+
+  void Swap(SignedIntRange* other);
+
+  // implements Message ----------------------------------------------
+
+  SignedIntRange* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SignedIntRange& from);
+  void MergeFrom(const SignedIntRange& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional int64 min = 1;
+  inline bool has_min() const;
+  inline void clear_min();
+  static const int kMinFieldNumber = 1;
+  inline ::google::protobuf::int64 min() const;
+  inline void set_min(::google::protobuf::int64 value);
+
+  // optional int64 max = 2;
+  inline bool has_max() const;
+  inline void clear_max();
+  static const int kMaxFieldNumber = 2;
+  inline ::google::protobuf::int64 max() const;
+  inline void set_max(::google::protobuf::int64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.SignedIntRange)
+ private:
+  inline void set_has_min();
+  inline void clear_has_min();
+  inline void set_has_max();
+  inline void clear_has_max();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::int64 min_;
+  ::google::protobuf::int64 max_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2frange_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2frange_2eproto();
+
+  void InitAsDefaultInstance();
+  static SignedIntRange* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API FloatRange : public ::google::protobuf::Message {
+ public:
+  FloatRange();
+  virtual ~FloatRange();
+
+  FloatRange(const FloatRange& from);
+
+  inline FloatRange& operator=(const FloatRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FloatRange& default_instance();
+
+  void Swap(FloatRange* other);
+
+  // implements Message ----------------------------------------------
+
+  FloatRange* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const FloatRange& from);
+  void MergeFrom(const FloatRange& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional float min = 1;
+  inline bool has_min() const;
+  inline void clear_min();
+  static const int kMinFieldNumber = 1;
+  inline float min() const;
+  inline void set_min(float value);
+
+  // optional float max = 2;
+  inline bool has_max() const;
+  inline void clear_max();
+  static const int kMaxFieldNumber = 2;
+  inline float max() const;
+  inline void set_max(float value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.FloatRange)
+ private:
+  inline void set_has_min();
+  inline void clear_has_min();
+  inline void set_has_max();
+  inline void clear_has_max();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  float min_;
+  float max_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2frange_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2frange_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2frange_2eproto();
+
+  void InitAsDefaultInstance();
+  static FloatRange* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// UnsignedIntRange
+
+// optional uint64 min = 1;
+inline bool UnsignedIntRange::has_min() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsignedIntRange::set_has_min() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsignedIntRange::clear_has_min() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsignedIntRange::clear_min() {
+  min_ = GOOGLE_ULONGLONG(0);
+  clear_has_min();
+}
+inline ::google::protobuf::uint64 UnsignedIntRange::min() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.UnsignedIntRange.min)
+  return min_;
+}
+inline void UnsignedIntRange::set_min(::google::protobuf::uint64 value) {
+  set_has_min();
+  min_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.UnsignedIntRange.min)
+}
+
+// optional uint64 max = 2;
+inline bool UnsignedIntRange::has_max() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnsignedIntRange::set_has_max() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnsignedIntRange::clear_has_max() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnsignedIntRange::clear_max() {
+  max_ = GOOGLE_ULONGLONG(0);
+  clear_has_max();
+}
+inline ::google::protobuf::uint64 UnsignedIntRange::max() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.UnsignedIntRange.max)
+  return max_;
+}
+inline void UnsignedIntRange::set_max(::google::protobuf::uint64 value) {
+  set_has_max();
+  max_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.UnsignedIntRange.max)
+}
+
+// -------------------------------------------------------------------
+
+// SignedIntRange
+
+// optional int64 min = 1;
+inline bool SignedIntRange::has_min() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SignedIntRange::set_has_min() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SignedIntRange::clear_has_min() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SignedIntRange::clear_min() {
+  min_ = GOOGLE_LONGLONG(0);
+  clear_has_min();
+}
+inline ::google::protobuf::int64 SignedIntRange::min() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SignedIntRange.min)
+  return min_;
+}
+inline void SignedIntRange::set_min(::google::protobuf::int64 value) {
+  set_has_min();
+  min_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.SignedIntRange.min)
+}
+
+// optional int64 max = 2;
+inline bool SignedIntRange::has_max() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SignedIntRange::set_has_max() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SignedIntRange::clear_has_max() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SignedIntRange::clear_max() {
+  max_ = GOOGLE_LONGLONG(0);
+  clear_has_max();
+}
+inline ::google::protobuf::int64 SignedIntRange::max() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SignedIntRange.max)
+  return max_;
+}
+inline void SignedIntRange::set_max(::google::protobuf::int64 value) {
+  set_has_max();
+  max_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.SignedIntRange.max)
+}
+
+// -------------------------------------------------------------------
+
+// FloatRange
+
+// optional float min = 1;
+inline bool FloatRange::has_min() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FloatRange::set_has_min() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FloatRange::clear_has_min() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FloatRange::clear_min() {
+  min_ = 0;
+  clear_has_min();
+}
+inline float FloatRange::min() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.FloatRange.min)
+  return min_;
+}
+inline void FloatRange::set_min(float value) {
+  set_has_min();
+  min_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.FloatRange.min)
+}
+
+// optional float max = 2;
+inline bool FloatRange::has_max() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FloatRange::set_has_max() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FloatRange::clear_has_max() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FloatRange::clear_max() {
+  max_ = 0;
+  clear_has_max();
+}
+inline float FloatRange::max() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.FloatRange.max)
+  return max_;
+}
+inline void FloatRange::set_max(float value) {
+  set_has_max();
+  max_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.FloatRange.max)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_global_5fextensions_2frange_2eproto__INCLUDED
diff --git a/src/server/proto/Client/global_extensions/service_options.pb.cc b/src/server/proto/Client/global_extensions/service_options.pb.cc
index 6bd0768c9a9..ca0ca257e21 100644
--- a/src/server/proto/Client/global_extensions/service_options.pb.cc
+++ b/src/server/proto/Client/global_extensions/service_options.pb.cc
@@ -18,16 +18,17 @@
 #include "Log.h"
 // @@protoc_insertion_point(includes)
 
-// Fix stupid windows.h included from Log.h->Common.h
-#ifdef SendMessage
-#undef SendMessage
-#endif
-
 namespace bgs {
 namespace protocol {
 
 namespace {
 
+const ::google::protobuf::Descriptor* BGSServiceOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BGSServiceOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SDKServiceOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SDKServiceOptions_reflection_ = NULL;
 
 }  // namespace
 
@@ -38,6 +39,40 @@ void protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto() {
     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
       "global_extensions/service_options.proto");
   GOOGLE_CHECK(file != NULL);
+  BGSServiceOptions_descriptor_ = file->message_type(0);
+  static const int BGSServiceOptions_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSServiceOptions, descriptor_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSServiceOptions, version_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSServiceOptions, shard_name_),
+  };
+  BGSServiceOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BGSServiceOptions_descriptor_,
+      BGSServiceOptions::default_instance_,
+      BGSServiceOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSServiceOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BGSServiceOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BGSServiceOptions));
+  SDKServiceOptions_descriptor_ = file->message_type(1);
+  static const int SDKServiceOptions_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SDKServiceOptions, inbound_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SDKServiceOptions, outbound_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SDKServiceOptions, use_client_id_),
+  };
+  SDKServiceOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SDKServiceOptions_descriptor_,
+      SDKServiceOptions::default_instance_,
+      SDKServiceOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SDKServiceOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SDKServiceOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SDKServiceOptions));
 }
 
 namespace {
@@ -50,11 +85,19 @@ inline void protobuf_AssignDescriptorsOnce() {
 
 void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BGSServiceOptions_descriptor_, &BGSServiceOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SDKServiceOptions_descriptor_, &SDKServiceOptions::default_instance());
 }
 
 }  // namespace
 
 void protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto() {
+  delete BGSServiceOptions::default_instance_;
+  delete BGSServiceOptions_reflection_;
+  delete SDKServiceOptions::default_instance_;
+  delete SDKServiceOptions_reflection_;
 }
 
 void protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto() {
@@ -67,19 +110,31 @@ void protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto() {
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\'global_extensions/service_options.prot"
     "o\022\014bgs.protocol\032 google/protobuf/descrip"
-    "tor.proto:R\n(original_fully_qualified_de"
-    "scriptor_name\022\037.google.protobuf.ServiceO"
-    "ptions\030\351\007 \001(\t:5\n\nservice_id\022\037.google.pro"
-    "tobuf.ServiceOptions\030\320\206\003 \001(\rB&\n\rbnet.pro"
-    "tocolB\023ServiceOptionsProtoH\001", 268);
+    "tor.proto\"Q\n\021BGSServiceOptions\022\027\n\017descri"
+    "ptor_name\030\001 \001(\t\022\017\n\007version\030\004 \001(\r\022\022\n\nshar"
+    "d_name\030\005 \001(\t\"M\n\021SDKServiceOptions\022\017\n\007inb"
+    "ound\030\001 \001(\010\022\020\n\010outbound\030\002 \001(\010\022\025\n\ruse_clie"
+    "nt_id\030\003 \001(\010:[\n\017service_options\022\037.google."
+    "protobuf.ServiceOptions\030\220\277\005 \001(\0132\037.bgs.pr"
+    "otocol.BGSServiceOptions:_\n\023sdk_service_"
+    "options\022\037.google.protobuf.ServiceOptions"
+    "\030\221\277\005 \001(\0132\037.bgs.protocol.SDKServiceOption"
+    "sB&\n\rbnet.protocolB\023ServiceOptionsProtoH"
+    "\001", 481);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "global_extensions/service_options.proto", &protobuf_RegisterTypes);
-  ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+  BGSServiceOptions::default_instance_ = new BGSServiceOptions();
+  SDKServiceOptions::default_instance_ = new SDKServiceOptions();
+  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
     &::google::protobuf::ServiceOptions::default_instance(),
-    1001, 9, false, false);
-  ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+    90000, 11, false, false,
+    &::bgs::protocol::BGSServiceOptions::default_instance());
+  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
     &::google::protobuf::ServiceOptions::default_instance(),
-    50000, 13, false, false);
+    90001, 11, false, false,
+    &::bgs::protocol::SDKServiceOptions::default_instance());
+  BGSServiceOptions::default_instance_->InitAsDefaultInstance();
+  SDKServiceOptions::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto);
 }
 
@@ -89,13 +144,661 @@ struct StaticDescriptorInitializer_global_5fextensions_2fservice_5foptions_2epro
     protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
   }
 } static_descriptor_initializer_global_5fextensions_2fservice_5foptions_2eproto_;
-const ::std::string original_fully_qualified_descriptor_name_default("");
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BGSServiceOptions::kDescriptorNameFieldNumber;
+const int BGSServiceOptions::kVersionFieldNumber;
+const int BGSServiceOptions::kShardNameFieldNumber;
+#endif  // !_MSC_VER
+
+BGSServiceOptions::BGSServiceOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.BGSServiceOptions)
+}
+
+void BGSServiceOptions::InitAsDefaultInstance() {
+}
+
+BGSServiceOptions::BGSServiceOptions(const BGSServiceOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.BGSServiceOptions)
+}
+
+void BGSServiceOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  descriptor_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  version_ = 0u;
+  shard_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BGSServiceOptions::~BGSServiceOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.BGSServiceOptions)
+  SharedDtor();
+}
+
+void BGSServiceOptions::SharedDtor() {
+  if (descriptor_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete descriptor_name_;
+  }
+  if (shard_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete shard_name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void BGSServiceOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BGSServiceOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BGSServiceOptions_descriptor_;
+}
+
+const BGSServiceOptions& BGSServiceOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
+  return *default_instance_;
+}
+
+BGSServiceOptions* BGSServiceOptions::default_instance_ = NULL;
+
+BGSServiceOptions* BGSServiceOptions::New() const {
+  return new BGSServiceOptions;
+}
+
+void BGSServiceOptions::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_descriptor_name()) {
+      if (descriptor_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        descriptor_name_->clear();
+      }
+    }
+    version_ = 0u;
+    if (has_shard_name()) {
+      if (shard_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        shard_name_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BGSServiceOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.BGSServiceOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string descriptor_name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_descriptor_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->descriptor_name().data(), this->descriptor_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "descriptor_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_version;
+        break;
+      }
+
+      // optional uint32 version = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_version:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &version_)));
+          set_has_version();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_shard_name;
+        break;
+      }
+
+      // optional string shard_name = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_shard_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_shard_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->shard_name().data(), this->shard_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "shard_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.BGSServiceOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.BGSServiceOptions)
+  return false;
+#undef DO_
+}
+
+void BGSServiceOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.BGSServiceOptions)
+  // optional string descriptor_name = 1;
+  if (has_descriptor_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->descriptor_name().data(), this->descriptor_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "descriptor_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->descriptor_name(), output);
+  }
+
+  // optional uint32 version = 4;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->version(), output);
+  }
+
+  // optional string shard_name = 5;
+  if (has_shard_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->shard_name().data(), this->shard_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "shard_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->shard_name(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.BGSServiceOptions)
+}
+
+::google::protobuf::uint8* BGSServiceOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.BGSServiceOptions)
+  // optional string descriptor_name = 1;
+  if (has_descriptor_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->descriptor_name().data(), this->descriptor_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "descriptor_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->descriptor_name(), target);
+  }
+
+  // optional uint32 version = 4;
+  if (has_version()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->version(), target);
+  }
+
+  // optional string shard_name = 5;
+  if (has_shard_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->shard_name().data(), this->shard_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "shard_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->shard_name(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.BGSServiceOptions)
+  return target;
+}
+
+int BGSServiceOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string descriptor_name = 1;
+    if (has_descriptor_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->descriptor_name());
+    }
+
+    // optional uint32 version = 4;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->version());
+    }
+
+    // optional string shard_name = 5;
+    if (has_shard_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->shard_name());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BGSServiceOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BGSServiceOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BGSServiceOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BGSServiceOptions::MergeFrom(const BGSServiceOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_descriptor_name()) {
+      set_descriptor_name(from.descriptor_name());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+    if (from.has_shard_name()) {
+      set_shard_name(from.shard_name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BGSServiceOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BGSServiceOptions::CopyFrom(const BGSServiceOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BGSServiceOptions::IsInitialized() const {
+
+  return true;
+}
+
+void BGSServiceOptions::Swap(BGSServiceOptions* other) {
+  if (other != this) {
+    std::swap(descriptor_name_, other->descriptor_name_);
+    std::swap(version_, other->version_);
+    std::swap(shard_name_, other->shard_name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BGSServiceOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BGSServiceOptions_descriptor_;
+  metadata.reflection = BGSServiceOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SDKServiceOptions::kInboundFieldNumber;
+const int SDKServiceOptions::kOutboundFieldNumber;
+const int SDKServiceOptions::kUseClientIdFieldNumber;
+#endif  // !_MSC_VER
+
+SDKServiceOptions::SDKServiceOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.SDKServiceOptions)
+}
+
+void SDKServiceOptions::InitAsDefaultInstance() {
+}
+
+SDKServiceOptions::SDKServiceOptions(const SDKServiceOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.SDKServiceOptions)
+}
+
+void SDKServiceOptions::SharedCtor() {
+  _cached_size_ = 0;
+  inbound_ = false;
+  outbound_ = false;
+  use_client_id_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SDKServiceOptions::~SDKServiceOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.SDKServiceOptions)
+  SharedDtor();
+}
+
+void SDKServiceOptions::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void SDKServiceOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SDKServiceOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SDKServiceOptions_descriptor_;
+}
+
+const SDKServiceOptions& SDKServiceOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
+  return *default_instance_;
+}
+
+SDKServiceOptions* SDKServiceOptions::default_instance_ = NULL;
+
+SDKServiceOptions* SDKServiceOptions::New() const {
+  return new SDKServiceOptions;
+}
+
+void SDKServiceOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<SDKServiceOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(inbound_, use_client_id_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SDKServiceOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.SDKServiceOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool inbound = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &inbound_)));
+          set_has_inbound();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_outbound;
+        break;
+      }
+
+      // optional bool outbound = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_outbound:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &outbound_)));
+          set_has_outbound();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_use_client_id;
+        break;
+      }
+
+      // optional bool use_client_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_use_client_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &use_client_id_)));
+          set_has_use_client_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.SDKServiceOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.SDKServiceOptions)
+  return false;
+#undef DO_
+}
+
+void SDKServiceOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.SDKServiceOptions)
+  // optional bool inbound = 1;
+  if (has_inbound()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->inbound(), output);
+  }
+
+  // optional bool outbound = 2;
+  if (has_outbound()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->outbound(), output);
+  }
+
+  // optional bool use_client_id = 3;
+  if (has_use_client_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->use_client_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.SDKServiceOptions)
+}
+
+::google::protobuf::uint8* SDKServiceOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.SDKServiceOptions)
+  // optional bool inbound = 1;
+  if (has_inbound()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->inbound(), target);
+  }
+
+  // optional bool outbound = 2;
+  if (has_outbound()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->outbound(), target);
+  }
+
+  // optional bool use_client_id = 3;
+  if (has_use_client_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->use_client_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.SDKServiceOptions)
+  return target;
+}
+
+int SDKServiceOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool inbound = 1;
+    if (has_inbound()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool outbound = 2;
+    if (has_outbound()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool use_client_id = 3;
+    if (has_use_client_id()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SDKServiceOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SDKServiceOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SDKServiceOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SDKServiceOptions::MergeFrom(const SDKServiceOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_inbound()) {
+      set_inbound(from.inbound());
+    }
+    if (from.has_outbound()) {
+      set_outbound(from.outbound());
+    }
+    if (from.has_use_client_id()) {
+      set_use_client_id(from.use_client_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SDKServiceOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SDKServiceOptions::CopyFrom(const SDKServiceOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SDKServiceOptions::IsInitialized() const {
+
+  return true;
+}
+
+void SDKServiceOptions::Swap(SDKServiceOptions* other) {
+  if (other != this) {
+    std::swap(inbound_, other->inbound_);
+    std::swap(outbound_, other->outbound_);
+    std::swap(use_client_id_, other->use_client_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SDKServiceOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SDKServiceOptions_descriptor_;
+  metadata.reflection = SDKServiceOptions_reflection_;
+  return metadata;
+}
+
 ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
-    ::google::protobuf::internal::StringTypeTraits, 9, false >
-  original_fully_qualified_descriptor_name(kOriginalFullyQualifiedDescriptorNameFieldNumber, original_fully_qualified_descriptor_name_default);
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::BGSServiceOptions >, 11, false >
+  service_options(kServiceOptionsFieldNumber, ::bgs::protocol::BGSServiceOptions::default_instance());
 ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
-    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
-  service_id(kServiceIdFieldNumber, 0u);
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::SDKServiceOptions >, 11, false >
+  sdk_service_options(kSdkServiceOptionsFieldNumber, ::bgs::protocol::SDKServiceOptions::default_instance());
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/src/server/proto/Client/global_extensions/service_options.pb.h b/src/server/proto/Client/global_extensions/service_options.pb.h
index 5a8a1f6a8a6..3e664253dc8 100644
--- a/src/server/proto/Client/global_extensions/service_options.pb.h
+++ b/src/server/proto/Client/global_extensions/service_options.pb.h
@@ -20,8 +20,10 @@
 #endif
 
 #include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
 #include "google/protobuf/descriptor.pb.h"
 #include "Define.h" // for TC_PROTO_API
 // @@protoc_insertion_point(includes)
@@ -34,26 +36,487 @@ void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2epro
 void protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto();
 void protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto();
 
+class BGSServiceOptions;
+class SDKServiceOptions;
 
 // ===================================================================
 
+class TC_PROTO_API BGSServiceOptions : public ::google::protobuf::Message {
+ public:
+  BGSServiceOptions();
+  virtual ~BGSServiceOptions();
 
+  BGSServiceOptions(const BGSServiceOptions& from);
+
+  inline BGSServiceOptions& operator=(const BGSServiceOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BGSServiceOptions& default_instance();
+
+  void Swap(BGSServiceOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  BGSServiceOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BGSServiceOptions& from);
+  void MergeFrom(const BGSServiceOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string descriptor_name = 1;
+  inline bool has_descriptor_name() const;
+  inline void clear_descriptor_name();
+  static const int kDescriptorNameFieldNumber = 1;
+  inline const ::std::string& descriptor_name() const;
+  inline void set_descriptor_name(const ::std::string& value);
+  inline void set_descriptor_name(const char* value);
+  inline void set_descriptor_name(const char* value, size_t size);
+  inline ::std::string* mutable_descriptor_name();
+  inline ::std::string* release_descriptor_name();
+  inline void set_allocated_descriptor_name(::std::string* descriptor_name);
+
+  // optional uint32 version = 4;
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 4;
+  inline ::google::protobuf::uint32 version() const;
+  inline void set_version(::google::protobuf::uint32 value);
+
+  // optional string shard_name = 5;
+  inline bool has_shard_name() const;
+  inline void clear_shard_name();
+  static const int kShardNameFieldNumber = 5;
+  inline const ::std::string& shard_name() const;
+  inline void set_shard_name(const ::std::string& value);
+  inline void set_shard_name(const char* value);
+  inline void set_shard_name(const char* value, size_t size);
+  inline ::std::string* mutable_shard_name();
+  inline ::std::string* release_shard_name();
+  inline void set_allocated_shard_name(::std::string* shard_name);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.BGSServiceOptions)
+ private:
+  inline void set_has_descriptor_name();
+  inline void clear_has_descriptor_name();
+  inline void set_has_version();
+  inline void clear_has_version();
+  inline void set_has_shard_name();
+  inline void clear_has_shard_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* descriptor_name_;
+  ::std::string* shard_name_;
+  ::google::protobuf::uint32 version_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static BGSServiceOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SDKServiceOptions : public ::google::protobuf::Message {
+ public:
+  SDKServiceOptions();
+  virtual ~SDKServiceOptions();
+
+  SDKServiceOptions(const SDKServiceOptions& from);
+
+  inline SDKServiceOptions& operator=(const SDKServiceOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SDKServiceOptions& default_instance();
+
+  void Swap(SDKServiceOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  SDKServiceOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SDKServiceOptions& from);
+  void MergeFrom(const SDKServiceOptions& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional bool inbound = 1;
+  inline bool has_inbound() const;
+  inline void clear_inbound();
+  static const int kInboundFieldNumber = 1;
+  inline bool inbound() const;
+  inline void set_inbound(bool value);
+
+  // optional bool outbound = 2;
+  inline bool has_outbound() const;
+  inline void clear_outbound();
+  static const int kOutboundFieldNumber = 2;
+  inline bool outbound() const;
+  inline void set_outbound(bool value);
+
+  // optional bool use_client_id = 3;
+  inline bool has_use_client_id() const;
+  inline void clear_use_client_id();
+  static const int kUseClientIdFieldNumber = 3;
+  inline bool use_client_id() const;
+  inline void set_use_client_id(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.SDKServiceOptions)
+ private:
+  inline void set_has_inbound();
+  inline void clear_has_inbound();
+  inline void set_has_outbound();
+  inline void clear_has_outbound();
+  inline void set_has_use_client_id();
+  inline void clear_has_use_client_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  bool inbound_;
+  bool outbound_;
+  bool use_client_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
+  friend void protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto();
+  friend void protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto();
+
+  void InitAsDefaultInstance();
+  static SDKServiceOptions* default_instance_;
+};
 // ===================================================================
 
 
 // ===================================================================
 
-static const int kOriginalFullyQualifiedDescriptorNameFieldNumber = 1001;
+static const int kServiceOptionsFieldNumber = 90000;
 TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
-    ::google::protobuf::internal::StringTypeTraits, 9, false >
-  original_fully_qualified_descriptor_name;
-static const int kServiceIdFieldNumber = 50000;
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::BGSServiceOptions >, 11, false >
+  service_options;
+static const int kSdkServiceOptionsFieldNumber = 90001;
 TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
-    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
-  service_id;
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::SDKServiceOptions >, 11, false >
+  sdk_service_options;
 
 // ===================================================================
 
+// BGSServiceOptions
+
+// optional string descriptor_name = 1;
+inline bool BGSServiceOptions::has_descriptor_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BGSServiceOptions::set_has_descriptor_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BGSServiceOptions::clear_has_descriptor_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BGSServiceOptions::clear_descriptor_name() {
+  if (descriptor_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    descriptor_name_->clear();
+  }
+  clear_has_descriptor_name();
+}
+inline const ::std::string& BGSServiceOptions::descriptor_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.BGSServiceOptions.descriptor_name)
+  return *descriptor_name_;
+}
+inline void BGSServiceOptions::set_descriptor_name(const ::std::string& value) {
+  set_has_descriptor_name();
+  if (descriptor_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    descriptor_name_ = new ::std::string;
+  }
+  descriptor_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.BGSServiceOptions.descriptor_name)
+}
+inline void BGSServiceOptions::set_descriptor_name(const char* value) {
+  set_has_descriptor_name();
+  if (descriptor_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    descriptor_name_ = new ::std::string;
+  }
+  descriptor_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.BGSServiceOptions.descriptor_name)
+}
+inline void BGSServiceOptions::set_descriptor_name(const char* value, size_t size) {
+  set_has_descriptor_name();
+  if (descriptor_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    descriptor_name_ = new ::std::string;
+  }
+  descriptor_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.BGSServiceOptions.descriptor_name)
+}
+inline ::std::string* BGSServiceOptions::mutable_descriptor_name() {
+  set_has_descriptor_name();
+  if (descriptor_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    descriptor_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.BGSServiceOptions.descriptor_name)
+  return descriptor_name_;
+}
+inline ::std::string* BGSServiceOptions::release_descriptor_name() {
+  clear_has_descriptor_name();
+  if (descriptor_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = descriptor_name_;
+    descriptor_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void BGSServiceOptions::set_allocated_descriptor_name(::std::string* descriptor_name) {
+  if (descriptor_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete descriptor_name_;
+  }
+  if (descriptor_name) {
+    set_has_descriptor_name();
+    descriptor_name_ = descriptor_name;
+  } else {
+    clear_has_descriptor_name();
+    descriptor_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.BGSServiceOptions.descriptor_name)
+}
+
+// optional uint32 version = 4;
+inline bool BGSServiceOptions::has_version() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void BGSServiceOptions::set_has_version() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void BGSServiceOptions::clear_has_version() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void BGSServiceOptions::clear_version() {
+  version_ = 0u;
+  clear_has_version();
+}
+inline ::google::protobuf::uint32 BGSServiceOptions::version() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.BGSServiceOptions.version)
+  return version_;
+}
+inline void BGSServiceOptions::set_version(::google::protobuf::uint32 value) {
+  set_has_version();
+  version_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.BGSServiceOptions.version)
+}
+
+// optional string shard_name = 5;
+inline bool BGSServiceOptions::has_shard_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void BGSServiceOptions::set_has_shard_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void BGSServiceOptions::clear_has_shard_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void BGSServiceOptions::clear_shard_name() {
+  if (shard_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_name_->clear();
+  }
+  clear_has_shard_name();
+}
+inline const ::std::string& BGSServiceOptions::shard_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.BGSServiceOptions.shard_name)
+  return *shard_name_;
+}
+inline void BGSServiceOptions::set_shard_name(const ::std::string& value) {
+  set_has_shard_name();
+  if (shard_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_name_ = new ::std::string;
+  }
+  shard_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.BGSServiceOptions.shard_name)
+}
+inline void BGSServiceOptions::set_shard_name(const char* value) {
+  set_has_shard_name();
+  if (shard_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_name_ = new ::std::string;
+  }
+  shard_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.BGSServiceOptions.shard_name)
+}
+inline void BGSServiceOptions::set_shard_name(const char* value, size_t size) {
+  set_has_shard_name();
+  if (shard_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_name_ = new ::std::string;
+  }
+  shard_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.BGSServiceOptions.shard_name)
+}
+inline ::std::string* BGSServiceOptions::mutable_shard_name() {
+  set_has_shard_name();
+  if (shard_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.BGSServiceOptions.shard_name)
+  return shard_name_;
+}
+inline ::std::string* BGSServiceOptions::release_shard_name() {
+  clear_has_shard_name();
+  if (shard_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = shard_name_;
+    shard_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void BGSServiceOptions::set_allocated_shard_name(::std::string* shard_name) {
+  if (shard_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete shard_name_;
+  }
+  if (shard_name) {
+    set_has_shard_name();
+    shard_name_ = shard_name;
+  } else {
+    clear_has_shard_name();
+    shard_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.BGSServiceOptions.shard_name)
+}
+
+// -------------------------------------------------------------------
+
+// SDKServiceOptions
+
+// optional bool inbound = 1;
+inline bool SDKServiceOptions::has_inbound() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SDKServiceOptions::set_has_inbound() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SDKServiceOptions::clear_has_inbound() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SDKServiceOptions::clear_inbound() {
+  inbound_ = false;
+  clear_has_inbound();
+}
+inline bool SDKServiceOptions::inbound() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SDKServiceOptions.inbound)
+  return inbound_;
+}
+inline void SDKServiceOptions::set_inbound(bool value) {
+  set_has_inbound();
+  inbound_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.SDKServiceOptions.inbound)
+}
+
+// optional bool outbound = 2;
+inline bool SDKServiceOptions::has_outbound() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SDKServiceOptions::set_has_outbound() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SDKServiceOptions::clear_has_outbound() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SDKServiceOptions::clear_outbound() {
+  outbound_ = false;
+  clear_has_outbound();
+}
+inline bool SDKServiceOptions::outbound() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SDKServiceOptions.outbound)
+  return outbound_;
+}
+inline void SDKServiceOptions::set_outbound(bool value) {
+  set_has_outbound();
+  outbound_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.SDKServiceOptions.outbound)
+}
+
+// optional bool use_client_id = 3;
+inline bool SDKServiceOptions::has_use_client_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SDKServiceOptions::set_has_use_client_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SDKServiceOptions::clear_has_use_client_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SDKServiceOptions::clear_use_client_id() {
+  use_client_id_ = false;
+  clear_has_use_client_id();
+}
+inline bool SDKServiceOptions::use_client_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SDKServiceOptions.use_client_id)
+  return use_client_id_;
+}
+inline void SDKServiceOptions::set_use_client_id(bool value) {
+  set_has_use_client_id();
+  use_client_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.SDKServiceOptions.use_client_id)
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/src/server/proto/Client/invitation_types.pb.cc b/src/server/proto/Client/invitation_types.pb.cc
index 68757c13a29..945f1cb4169 100644
--- a/src/server/proto/Client/invitation_types.pb.cc
+++ b/src/server/proto/Client/invitation_types.pb.cc
@@ -26,27 +26,11 @@ namespace {
 const ::google::protobuf::Descriptor* Invitation_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   Invitation_reflection_ = NULL;
-const ::google::protobuf::Descriptor* InvitationSuggestion_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  InvitationSuggestion_reflection_ = NULL;
-const ::google::protobuf::Descriptor* InvitationTarget_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  InvitationTarget_reflection_ = NULL;
 const ::google::protobuf::Descriptor* InvitationParams_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   InvitationParams_reflection_ = NULL;
-const ::google::protobuf::Descriptor* SendInvitationRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  SendInvitationRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* SendInvitationResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  SendInvitationResponse_reflection_ = NULL;
-const ::google::protobuf::Descriptor* UpdateInvitationRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  UpdateInvitationRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* GenericInvitationRequest_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  GenericInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* InvitationRemovedReason_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* SuggestionRemovedReason_descriptor_ = NULL;
 
 }  // namespace
 
@@ -79,43 +63,7 @@ void protobuf_AssignDesc_invitation_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(Invitation));
-  InvitationSuggestion_descriptor_ = file->message_type(1);
-  static const int InvitationSuggestion_offsets_[5] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, channel_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggester_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggestee_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggester_name_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggestee_name_),
-  };
-  InvitationSuggestion_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      InvitationSuggestion_descriptor_,
-      InvitationSuggestion::default_instance_,
-      InvitationSuggestion_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(InvitationSuggestion));
-  InvitationTarget_descriptor_ = file->message_type(2);
-  static const int InvitationTarget_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, identity_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, email_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, battle_tag_),
-  };
-  InvitationTarget_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      InvitationTarget_descriptor_,
-      InvitationTarget::default_instance_,
-      InvitationTarget_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, _unknown_fields_),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, _extensions_),
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(InvitationTarget));
-  InvitationParams_descriptor_ = file->message_type(3);
+  InvitationParams_descriptor_ = file->message_type(1);
   static const int InvitationParams_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, invitation_message_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, expiration_time_),
@@ -131,78 +79,8 @@ void protobuf_AssignDesc_invitation_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(InvitationParams));
-  SendInvitationRequest_descriptor_ = file->message_type(4);
-  static const int SendInvitationRequest_offsets_[5] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, agent_identity_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, target_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, params_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, agent_info_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, target_),
-  };
-  SendInvitationRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      SendInvitationRequest_descriptor_,
-      SendInvitationRequest::default_instance_,
-      SendInvitationRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(SendInvitationRequest));
-  SendInvitationResponse_descriptor_ = file->message_type(5);
-  static const int SendInvitationResponse_offsets_[1] = {
-  };
-  SendInvitationResponse_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      SendInvitationResponse_descriptor_,
-      SendInvitationResponse::default_instance_,
-      SendInvitationResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationResponse, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(SendInvitationResponse));
-  UpdateInvitationRequest_descriptor_ = file->message_type(6);
-  static const int UpdateInvitationRequest_offsets_[3] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, agent_identity_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, invitation_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, params_),
-  };
-  UpdateInvitationRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      UpdateInvitationRequest_descriptor_,
-      UpdateInvitationRequest::default_instance_,
-      UpdateInvitationRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(UpdateInvitationRequest));
-  GenericInvitationRequest_descriptor_ = file->message_type(7);
-  static const int GenericInvitationRequest_offsets_[8] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, agent_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, target_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, invitation_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, invitee_name_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, inviter_name_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, previous_role_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, desired_role_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, reason_),
-  };
-  GenericInvitationRequest_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      GenericInvitationRequest_descriptor_,
-      GenericInvitationRequest::default_instance_,
-      GenericInvitationRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(GenericInvitationRequest));
+  InvitationRemovedReason_descriptor_ = file->enum_type(0);
+  SuggestionRemovedReason_descriptor_ = file->enum_type(1);
 }
 
 namespace {
@@ -218,19 +96,7 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     Invitation_descriptor_, &Invitation::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    InvitationSuggestion_descriptor_, &InvitationSuggestion::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    InvitationTarget_descriptor_, &InvitationTarget::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     InvitationParams_descriptor_, &InvitationParams::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    SendInvitationRequest_descriptor_, &SendInvitationRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    SendInvitationResponse_descriptor_, &SendInvitationResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    UpdateInvitationRequest_descriptor_, &UpdateInvitationRequest::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    GenericInvitationRequest_descriptor_, &GenericInvitationRequest::default_instance());
 }
 
 }  // namespace
@@ -238,20 +104,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
 void protobuf_ShutdownFile_invitation_5ftypes_2eproto() {
   delete Invitation::default_instance_;
   delete Invitation_reflection_;
-  delete InvitationSuggestion::default_instance_;
-  delete InvitationSuggestion_reflection_;
-  delete InvitationTarget::default_instance_;
-  delete InvitationTarget_reflection_;
   delete InvitationParams::default_instance_;
   delete InvitationParams_reflection_;
-  delete SendInvitationRequest::default_instance_;
-  delete SendInvitationRequest_reflection_;
-  delete SendInvitationResponse::default_instance_;
-  delete SendInvitationResponse_reflection_;
-  delete UpdateInvitationRequest::default_instance_;
-  delete UpdateInvitationRequest_reflection_;
-  delete GenericInvitationRequest::default_instance_;
-  delete GenericInvitationRequest_reflection_;
 }
 
 void protobuf_AddDesc_invitation_5ftypes_2eproto() {
@@ -269,53 +123,28 @@ void protobuf_AddDesc_invitation_5ftypes_2eproto() {
     "\0132\026.bgs.protocol.Identity\022\024\n\014inviter_nam"
     "e\030\004 \001(\t\022\024\n\014invitee_name\030\005 \001(\t\022\032\n\022invitat"
     "ion_message\030\006 \001(\t\022\025\n\rcreation_time\030\007 \001(\004"
-    "\022\027\n\017expiration_time\030\010 \001(\004*\005\010d\020\220N\"\316\001\n\024Inv"
-    "itationSuggestion\022*\n\nchannel_id\030\001 \001(\0132\026."
-    "bgs.protocol.EntityId\022,\n\014suggester_id\030\002 "
-    "\002(\0132\026.bgs.protocol.EntityId\022,\n\014suggestee"
-    "_id\030\003 \002(\0132\026.bgs.protocol.EntityId\022\026\n\016sug"
-    "gester_name\030\004 \001(\t\022\026\n\016suggestee_name\030\005 \001("
-    "\t\"f\n\020InvitationTarget\022(\n\010identity\030\001 \001(\0132"
-    "\026.bgs.protocol.Identity\022\r\n\005email\030\002 \001(\t\022\022"
-    "\n\nbattle_tag\030\003 \001(\t*\005\010d\020\220N\"Q\n\020InvitationP"
-    "arams\022\032\n\022invitation_message\030\001 \001(\t\022\032\n\017exp"
-    "iration_time\030\002 \001(\004:\0010*\005\010d\020\220N\"\205\002\n\025SendInv"
-    "itationRequest\022.\n\016agent_identity\030\001 \001(\0132\026"
-    ".bgs.protocol.Identity\022-\n\ttarget_id\030\002 \002("
-    "\0132\026.bgs.protocol.EntityIdB\002\030\001\022.\n\006params\030"
-    "\003 \002(\0132\036.bgs.protocol.InvitationParams\022-\n"
-    "\nagent_info\030\004 \001(\0132\031.bgs.protocol.Account"
-    "Info\022.\n\006target\030\005 \001(\0132\036.bgs.protocol.Invi"
-    "tationTarget\"\030\n\026SendInvitationResponse\"\220"
-    "\001\n\027UpdateInvitationRequest\022.\n\016agent_iden"
-    "tity\030\001 \001(\0132\026.bgs.protocol.Identity\022\025\n\rin"
-    "vitation_id\030\002 \002(\006\022.\n\006params\030\003 \002(\0132\036.bgs."
-    "protocol.InvitationParams\"\367\001\n\030GenericInv"
-    "itationRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.p"
-    "rotocol.EntityId\022)\n\ttarget_id\030\002 \001(\0132\026.bg"
-    "s.protocol.EntityId\022\025\n\rinvitation_id\030\003 \002"
-    "(\006\022\024\n\014invitee_name\030\004 \001(\t\022\024\n\014inviter_name"
-    "\030\005 \001(\t\022\031\n\rprevious_role\030\006 \003(\rB\002\020\001\022\030\n\014des"
-    "ired_role\030\007 \003(\rB\002\020\001\022\016\n\006reason\030\010 \001(\rB\'\n\rb"
-    "net.protocolB\024InvitationTypesProtoH\001", 1436);
+    "\022\027\n\017expiration_time\030\010 \001(\004*\005\010d\020\220N\"R\n\020Invi"
+    "tationParams\022\036\n\022invitation_message\030\001 \001(\t"
+    "B\002\030\001\022\027\n\017expiration_time\030\002 \001(\004*\005\010d\020\220N*\206\002\n"
+    "\027InvitationRemovedReason\022&\n\"INVITATION_R"
+    "EMOVED_REASON_ACCEPTED\020\000\022&\n\"INVITATION_R"
+    "EMOVED_REASON_DECLINED\020\001\022%\n!INVITATION_R"
+    "EMOVED_REASON_REVOKED\020\002\022%\n!INVITATION_RE"
+    "MOVED_REASON_IGNORED\020\003\022%\n!INVITATION_REM"
+    "OVED_REASON_EXPIRED\020\004\022&\n\"INVITATION_REMO"
+    "VED_REASON_CANCELED\020\005*\270\001\n\027SuggestionRemo"
+    "vedReason\022&\n\"SUGGESTION_REMOVED_REASON_A"
+    "PPROVED\020\000\022&\n\"SUGGESTION_REMOVED_REASON_D"
+    "ECLINED\020\001\022%\n!SUGGESTION_REMOVED_REASON_E"
+    "XPIRED\020\002\022&\n\"SUGGESTION_REMOVED_REASON_CA"
+    "NCELED\020\003B\'\n\rbnet.protocolB\024InvitationTyp"
+    "esProtoH\001", 889);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "invitation_types.proto", &protobuf_RegisterTypes);
   Invitation::default_instance_ = new Invitation();
-  InvitationSuggestion::default_instance_ = new InvitationSuggestion();
-  InvitationTarget::default_instance_ = new InvitationTarget();
   InvitationParams::default_instance_ = new InvitationParams();
-  SendInvitationRequest::default_instance_ = new SendInvitationRequest();
-  SendInvitationResponse::default_instance_ = new SendInvitationResponse();
-  UpdateInvitationRequest::default_instance_ = new UpdateInvitationRequest();
-  GenericInvitationRequest::default_instance_ = new GenericInvitationRequest();
   Invitation::default_instance_->InitAsDefaultInstance();
-  InvitationSuggestion::default_instance_->InitAsDefaultInstance();
-  InvitationTarget::default_instance_->InitAsDefaultInstance();
   InvitationParams::default_instance_->InitAsDefaultInstance();
-  SendInvitationRequest::default_instance_->InitAsDefaultInstance();
-  SendInvitationResponse::default_instance_->InitAsDefaultInstance();
-  UpdateInvitationRequest::default_instance_->InitAsDefaultInstance();
-  GenericInvitationRequest::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_invitation_5ftypes_2eproto);
 }
 
@@ -325,6 +154,40 @@ struct StaticDescriptorInitializer_invitation_5ftypes_2eproto {
     protobuf_AddDesc_invitation_5ftypes_2eproto();
   }
 } static_descriptor_initializer_invitation_5ftypes_2eproto_;
+const ::google::protobuf::EnumDescriptor* InvitationRemovedReason_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return InvitationRemovedReason_descriptor_;
+}
+bool InvitationRemovedReason_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* SuggestionRemovedReason_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SuggestionRemovedReason_descriptor_;
+}
+bool SuggestionRemovedReason_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
 
 // ===================================================================
 
@@ -934,822 +797,6 @@ void Invitation::Swap(Invitation* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int InvitationSuggestion::kChannelIdFieldNumber;
-const int InvitationSuggestion::kSuggesterIdFieldNumber;
-const int InvitationSuggestion::kSuggesteeIdFieldNumber;
-const int InvitationSuggestion::kSuggesterNameFieldNumber;
-const int InvitationSuggestion::kSuggesteeNameFieldNumber;
-#endif  // !_MSC_VER
-
-InvitationSuggestion::InvitationSuggestion()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.InvitationSuggestion)
-}
-
-void InvitationSuggestion::InitAsDefaultInstance() {
-  channel_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  suggester_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  suggestee_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-}
-
-InvitationSuggestion::InvitationSuggestion(const InvitationSuggestion& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.InvitationSuggestion)
-}
-
-void InvitationSuggestion::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  channel_id_ = NULL;
-  suggester_id_ = NULL;
-  suggestee_id_ = NULL;
-  suggester_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  suggestee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-InvitationSuggestion::~InvitationSuggestion() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.InvitationSuggestion)
-  SharedDtor();
-}
-
-void InvitationSuggestion::SharedDtor() {
-  if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete suggester_name_;
-  }
-  if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete suggestee_name_;
-  }
-  if (this != default_instance_) {
-    delete channel_id_;
-    delete suggester_id_;
-    delete suggestee_id_;
-  }
-}
-
-void InvitationSuggestion::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* InvitationSuggestion::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return InvitationSuggestion_descriptor_;
-}
-
-const InvitationSuggestion& InvitationSuggestion::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-InvitationSuggestion* InvitationSuggestion::default_instance_ = NULL;
-
-InvitationSuggestion* InvitationSuggestion::New() const {
-  return new InvitationSuggestion;
-}
-
-void InvitationSuggestion::Clear() {
-  if (_has_bits_[0 / 32] & 31) {
-    if (has_channel_id()) {
-      if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_suggester_id()) {
-      if (suggester_id_ != NULL) suggester_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_suggestee_id()) {
-      if (suggestee_id_ != NULL) suggestee_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_suggester_name()) {
-      if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        suggester_name_->clear();
-      }
-    }
-    if (has_suggestee_name()) {
-      if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        suggestee_name_->clear();
-      }
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool InvitationSuggestion::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.InvitationSuggestion)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId channel_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_channel_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_suggester_id;
-        break;
-      }
-
-      // required .bgs.protocol.EntityId suggester_id = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_suggester_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_suggester_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_suggestee_id;
-        break;
-      }
-
-      // required .bgs.protocol.EntityId suggestee_id = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_suggestee_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_suggestee_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_suggester_name;
-        break;
-      }
-
-      // optional string suggester_name = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_suggester_name:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_suggester_name()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->suggester_name().data(), this->suggester_name().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "suggester_name");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_suggestee_name;
-        break;
-      }
-
-      // optional string suggestee_name = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_suggestee_name:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_suggestee_name()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->suggestee_name().data(), this->suggestee_name().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "suggestee_name");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.InvitationSuggestion)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.InvitationSuggestion)
-  return false;
-#undef DO_
-}
-
-void InvitationSuggestion::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.InvitationSuggestion)
-  // optional .bgs.protocol.EntityId channel_id = 1;
-  if (has_channel_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->channel_id(), output);
-  }
-
-  // required .bgs.protocol.EntityId suggester_id = 2;
-  if (has_suggester_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->suggester_id(), output);
-  }
-
-  // required .bgs.protocol.EntityId suggestee_id = 3;
-  if (has_suggestee_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      3, this->suggestee_id(), output);
-  }
-
-  // optional string suggester_name = 4;
-  if (has_suggester_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->suggester_name().data(), this->suggester_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "suggester_name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      4, this->suggester_name(), output);
-  }
-
-  // optional string suggestee_name = 5;
-  if (has_suggestee_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->suggestee_name().data(), this->suggestee_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "suggestee_name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      5, this->suggestee_name(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.InvitationSuggestion)
-}
-
-::google::protobuf::uint8* InvitationSuggestion::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.InvitationSuggestion)
-  // optional .bgs.protocol.EntityId channel_id = 1;
-  if (has_channel_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->channel_id(), target);
-  }
-
-  // required .bgs.protocol.EntityId suggester_id = 2;
-  if (has_suggester_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->suggester_id(), target);
-  }
-
-  // required .bgs.protocol.EntityId suggestee_id = 3;
-  if (has_suggestee_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        3, this->suggestee_id(), target);
-  }
-
-  // optional string suggester_name = 4;
-  if (has_suggester_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->suggester_name().data(), this->suggester_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "suggester_name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        4, this->suggester_name(), target);
-  }
-
-  // optional string suggestee_name = 5;
-  if (has_suggestee_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->suggestee_name().data(), this->suggestee_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "suggestee_name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        5, this->suggestee_name(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.InvitationSuggestion)
-  return target;
-}
-
-int InvitationSuggestion::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId channel_id = 1;
-    if (has_channel_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->channel_id());
-    }
-
-    // required .bgs.protocol.EntityId suggester_id = 2;
-    if (has_suggester_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->suggester_id());
-    }
-
-    // required .bgs.protocol.EntityId suggestee_id = 3;
-    if (has_suggestee_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->suggestee_id());
-    }
-
-    // optional string suggester_name = 4;
-    if (has_suggester_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->suggester_name());
-    }
-
-    // optional string suggestee_name = 5;
-    if (has_suggestee_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->suggestee_name());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void InvitationSuggestion::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const InvitationSuggestion* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const InvitationSuggestion*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void InvitationSuggestion::MergeFrom(const InvitationSuggestion& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_channel_id()) {
-      mutable_channel_id()->::bgs::protocol::EntityId::MergeFrom(from.channel_id());
-    }
-    if (from.has_suggester_id()) {
-      mutable_suggester_id()->::bgs::protocol::EntityId::MergeFrom(from.suggester_id());
-    }
-    if (from.has_suggestee_id()) {
-      mutable_suggestee_id()->::bgs::protocol::EntityId::MergeFrom(from.suggestee_id());
-    }
-    if (from.has_suggester_name()) {
-      set_suggester_name(from.suggester_name());
-    }
-    if (from.has_suggestee_name()) {
-      set_suggestee_name(from.suggestee_name());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void InvitationSuggestion::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void InvitationSuggestion::CopyFrom(const InvitationSuggestion& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool InvitationSuggestion::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
-
-  if (has_channel_id()) {
-    if (!this->channel_id().IsInitialized()) return false;
-  }
-  if (has_suggester_id()) {
-    if (!this->suggester_id().IsInitialized()) return false;
-  }
-  if (has_suggestee_id()) {
-    if (!this->suggestee_id().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void InvitationSuggestion::Swap(InvitationSuggestion* other) {
-  if (other != this) {
-    std::swap(channel_id_, other->channel_id_);
-    std::swap(suggester_id_, other->suggester_id_);
-    std::swap(suggestee_id_, other->suggestee_id_);
-    std::swap(suggester_name_, other->suggester_name_);
-    std::swap(suggestee_name_, other->suggestee_name_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata InvitationSuggestion::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = InvitationSuggestion_descriptor_;
-  metadata.reflection = InvitationSuggestion_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int InvitationTarget::kIdentityFieldNumber;
-const int InvitationTarget::kEmailFieldNumber;
-const int InvitationTarget::kBattleTagFieldNumber;
-#endif  // !_MSC_VER
-
-InvitationTarget::InvitationTarget()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.InvitationTarget)
-}
-
-void InvitationTarget::InitAsDefaultInstance() {
-  identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
-}
-
-InvitationTarget::InvitationTarget(const InvitationTarget& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.InvitationTarget)
-}
-
-void InvitationTarget::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  identity_ = NULL;
-  email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-InvitationTarget::~InvitationTarget() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.InvitationTarget)
-  SharedDtor();
-}
-
-void InvitationTarget::SharedDtor() {
-  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete email_;
-  }
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (this != default_instance_) {
-    delete identity_;
-  }
-}
-
-void InvitationTarget::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* InvitationTarget::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return InvitationTarget_descriptor_;
-}
-
-const InvitationTarget& InvitationTarget::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-InvitationTarget* InvitationTarget::default_instance_ = NULL;
-
-InvitationTarget* InvitationTarget::New() const {
-  return new InvitationTarget;
-}
-
-void InvitationTarget::Clear() {
-  _extensions_.Clear();
-  if (_has_bits_[0 / 32] & 7) {
-    if (has_identity()) {
-      if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
-    }
-    if (has_email()) {
-      if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        email_->clear();
-      }
-    }
-    if (has_battle_tag()) {
-      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        battle_tag_->clear();
-      }
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool InvitationTarget::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.InvitationTarget)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.Identity identity = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_identity()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_email;
-        break;
-      }
-
-      // optional string email = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_email:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_email()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->email().data(), this->email().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "email");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_battle_tag;
-        break;
-      }
-
-      // optional string battle_tag = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_battle_tag:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_battle_tag()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->battle_tag().data(), this->battle_tag().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "battle_tag");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        if ((800u <= tag && tag < 80000u)) {
-          DO_(_extensions_.ParseField(tag, input, default_instance_,
-                                      mutable_unknown_fields()));
-          continue;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.InvitationTarget)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.InvitationTarget)
-  return false;
-#undef DO_
-}
-
-void InvitationTarget::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.InvitationTarget)
-  // optional .bgs.protocol.Identity identity = 1;
-  if (has_identity()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->identity(), output);
-  }
-
-  // optional string email = 2;
-  if (has_email()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->email().data(), this->email().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "email");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->email(), output);
-  }
-
-  // optional string battle_tag = 3;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      3, this->battle_tag(), output);
-  }
-
-  // Extension range [100, 10000)
-  _extensions_.SerializeWithCachedSizes(
-      100, 10000, output);
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.InvitationTarget)
-}
-
-::google::protobuf::uint8* InvitationTarget::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.InvitationTarget)
-  // optional .bgs.protocol.Identity identity = 1;
-  if (has_identity()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->identity(), target);
-  }
-
-  // optional string email = 2;
-  if (has_email()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->email().data(), this->email().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "email");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->email(), target);
-  }
-
-  // optional string battle_tag = 3;
-  if (has_battle_tag()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->battle_tag().data(), this->battle_tag().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "battle_tag");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        3, this->battle_tag(), target);
-  }
-
-  // Extension range [100, 10000)
-  target = _extensions_.SerializeWithCachedSizesToArray(
-      100, 10000, target);
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.InvitationTarget)
-  return target;
-}
-
-int InvitationTarget::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.Identity identity = 1;
-    if (has_identity()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->identity());
-    }
-
-    // optional string email = 2;
-    if (has_email()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->email());
-    }
-
-    // optional string battle_tag = 3;
-    if (has_battle_tag()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->battle_tag());
-    }
-
-  }
-  total_size += _extensions_.ByteSize();
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void InvitationTarget::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const InvitationTarget* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const InvitationTarget*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void InvitationTarget::MergeFrom(const InvitationTarget& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_identity()) {
-      mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity());
-    }
-    if (from.has_email()) {
-      set_email(from.email());
-    }
-    if (from.has_battle_tag()) {
-      set_battle_tag(from.battle_tag());
-    }
-  }
-  _extensions_.MergeFrom(from._extensions_);
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void InvitationTarget::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void InvitationTarget::CopyFrom(const InvitationTarget& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool InvitationTarget::IsInitialized() const {
-
-  if (has_identity()) {
-    if (!this->identity().IsInitialized()) return false;
-  }
-
-  if (!_extensions_.IsInitialized()) return false;  return true;
-}
-
-void InvitationTarget::Swap(InvitationTarget* other) {
-  if (other != this) {
-    std::swap(identity_, other->identity_);
-    std::swap(email_, other->email_);
-    std::swap(battle_tag_, other->battle_tag_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-    _extensions_.Swap(&other->_extensions_);
-  }
-}
-
-::google::protobuf::Metadata InvitationTarget::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = InvitationTarget_descriptor_;
-  metadata.reflection = InvitationTarget_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int InvitationParams::kInvitationMessageFieldNumber;
 const int InvitationParams::kExpirationTimeFieldNumber;
 #endif  // !_MSC_VER
@@ -1836,7 +883,7 @@ bool InvitationParams::MergePartialFromCodedStream(
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string invitation_message = 1;
+      // optional string invitation_message = 1 [deprecated = true];
       case 1: {
         if (tag == 10) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
@@ -1852,7 +899,7 @@ bool InvitationParams::MergePartialFromCodedStream(
         break;
       }
 
-      // optional uint64 expiration_time = 2 [default = 0];
+      // optional uint64 expiration_time = 2;
       case 2: {
         if (tag == 16) {
          parse_expiration_time:
@@ -1897,7 +944,7 @@ failure:
 void InvitationParams::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // @@protoc_insertion_point(serialize_start:bgs.protocol.InvitationParams)
-  // optional string invitation_message = 1;
+  // optional string invitation_message = 1 [deprecated = true];
   if (has_invitation_message()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
       this->invitation_message().data(), this->invitation_message().length(),
@@ -1907,7 +954,7 @@ void InvitationParams::SerializeWithCachedSizes(
       1, this->invitation_message(), output);
   }
 
-  // optional uint64 expiration_time = 2 [default = 0];
+  // optional uint64 expiration_time = 2;
   if (has_expiration_time()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->expiration_time(), output);
   }
@@ -1926,7 +973,7 @@ void InvitationParams::SerializeWithCachedSizes(
 ::google::protobuf::uint8* InvitationParams::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
   // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.InvitationParams)
-  // optional string invitation_message = 1;
+  // optional string invitation_message = 1 [deprecated = true];
   if (has_invitation_message()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
       this->invitation_message().data(), this->invitation_message().length(),
@@ -1937,7 +984,7 @@ void InvitationParams::SerializeWithCachedSizes(
         1, this->invitation_message(), target);
   }
 
-  // optional uint64 expiration_time = 2 [default = 0];
+  // optional uint64 expiration_time = 2;
   if (has_expiration_time()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->expiration_time(), target);
   }
@@ -1958,14 +1005,14 @@ int InvitationParams::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional string invitation_message = 1;
+    // optional string invitation_message = 1 [deprecated = true];
     if (has_invitation_message()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::StringSize(
           this->invitation_message());
     }
 
-    // optional uint64 expiration_time = 2 [default = 0];
+    // optional uint64 expiration_time = 2;
     if (has_expiration_time()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt64Size(
@@ -2050,1521 +1097,6 @@ void InvitationParams::Swap(InvitationParams* other) {
 }
 
 
-// ===================================================================
-
-#ifndef _MSC_VER
-const int SendInvitationRequest::kAgentIdentityFieldNumber;
-const int SendInvitationRequest::kTargetIdFieldNumber;
-const int SendInvitationRequest::kParamsFieldNumber;
-const int SendInvitationRequest::kAgentInfoFieldNumber;
-const int SendInvitationRequest::kTargetFieldNumber;
-#endif  // !_MSC_VER
-
-SendInvitationRequest::SendInvitationRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.SendInvitationRequest)
-}
-
-void SendInvitationRequest::InitAsDefaultInstance() {
-  agent_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
-  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  params_ = const_cast< ::bgs::protocol::InvitationParams*>(&::bgs::protocol::InvitationParams::default_instance());
-  agent_info_ = const_cast< ::bgs::protocol::AccountInfo*>(&::bgs::protocol::AccountInfo::default_instance());
-  target_ = const_cast< ::bgs::protocol::InvitationTarget*>(&::bgs::protocol::InvitationTarget::default_instance());
-}
-
-SendInvitationRequest::SendInvitationRequest(const SendInvitationRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.SendInvitationRequest)
-}
-
-void SendInvitationRequest::SharedCtor() {
-  _cached_size_ = 0;
-  agent_identity_ = NULL;
-  target_id_ = NULL;
-  params_ = NULL;
-  agent_info_ = NULL;
-  target_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-SendInvitationRequest::~SendInvitationRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.SendInvitationRequest)
-  SharedDtor();
-}
-
-void SendInvitationRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_identity_;
-    delete target_id_;
-    delete params_;
-    delete agent_info_;
-    delete target_;
-  }
-}
-
-void SendInvitationRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* SendInvitationRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return SendInvitationRequest_descriptor_;
-}
-
-const SendInvitationRequest& SendInvitationRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-SendInvitationRequest* SendInvitationRequest::default_instance_ = NULL;
-
-SendInvitationRequest* SendInvitationRequest::New() const {
-  return new SendInvitationRequest;
-}
-
-void SendInvitationRequest::Clear() {
-  if (_has_bits_[0 / 32] & 31) {
-    if (has_agent_identity()) {
-      if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
-    }
-    if (has_target_id()) {
-      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_params()) {
-      if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
-    }
-    if (has_agent_info()) {
-      if (agent_info_ != NULL) agent_info_->::bgs::protocol::AccountInfo::Clear();
-    }
-    if (has_target()) {
-      if (target_ != NULL) target_->::bgs::protocol::InvitationTarget::Clear();
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool SendInvitationRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.SendInvitationRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.Identity agent_identity = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_identity()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_target_id;
-        break;
-      }
-
-      // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
-      case 2: {
-        if (tag == 18) {
-         parse_target_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_target_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_params;
-        break;
-      }
-
-      // required .bgs.protocol.InvitationParams params = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_params:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_params()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_agent_info;
-        break;
-      }
-
-      // optional .bgs.protocol.AccountInfo agent_info = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_agent_info:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_info()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_target;
-        break;
-      }
-
-      // optional .bgs.protocol.InvitationTarget target = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_target:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_target()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.SendInvitationRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.SendInvitationRequest)
-  return false;
-#undef DO_
-}
-
-void SendInvitationRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.SendInvitationRequest)
-  // optional .bgs.protocol.Identity agent_identity = 1;
-  if (has_agent_identity()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_identity(), output);
-  }
-
-  // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
-  if (has_target_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->target_id(), output);
-  }
-
-  // required .bgs.protocol.InvitationParams params = 3;
-  if (has_params()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      3, this->params(), output);
-  }
-
-  // optional .bgs.protocol.AccountInfo agent_info = 4;
-  if (has_agent_info()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      4, this->agent_info(), output);
-  }
-
-  // optional .bgs.protocol.InvitationTarget target = 5;
-  if (has_target()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      5, this->target(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.SendInvitationRequest)
-}
-
-::google::protobuf::uint8* SendInvitationRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.SendInvitationRequest)
-  // optional .bgs.protocol.Identity agent_identity = 1;
-  if (has_agent_identity()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_identity(), target);
-  }
-
-  // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
-  if (has_target_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->target_id(), target);
-  }
-
-  // required .bgs.protocol.InvitationParams params = 3;
-  if (has_params()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        3, this->params(), target);
-  }
-
-  // optional .bgs.protocol.AccountInfo agent_info = 4;
-  if (has_agent_info()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        4, this->agent_info(), target);
-  }
-
-  // optional .bgs.protocol.InvitationTarget target = 5;
-  if (has_target()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        5, this->target(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.SendInvitationRequest)
-  return target;
-}
-
-int SendInvitationRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.Identity agent_identity = 1;
-    if (has_agent_identity()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_identity());
-    }
-
-    // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
-    if (has_target_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->target_id());
-    }
-
-    // required .bgs.protocol.InvitationParams params = 3;
-    if (has_params()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->params());
-    }
-
-    // optional .bgs.protocol.AccountInfo agent_info = 4;
-    if (has_agent_info()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_info());
-    }
-
-    // optional .bgs.protocol.InvitationTarget target = 5;
-    if (has_target()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->target());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void SendInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const SendInvitationRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const SendInvitationRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void SendInvitationRequest::MergeFrom(const SendInvitationRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_identity()) {
-      mutable_agent_identity()->::bgs::protocol::Identity::MergeFrom(from.agent_identity());
-    }
-    if (from.has_target_id()) {
-      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
-    }
-    if (from.has_params()) {
-      mutable_params()->::bgs::protocol::InvitationParams::MergeFrom(from.params());
-    }
-    if (from.has_agent_info()) {
-      mutable_agent_info()->::bgs::protocol::AccountInfo::MergeFrom(from.agent_info());
-    }
-    if (from.has_target()) {
-      mutable_target()->::bgs::protocol::InvitationTarget::MergeFrom(from.target());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void SendInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void SendInvitationRequest::CopyFrom(const SendInvitationRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SendInvitationRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
-
-  if (has_agent_identity()) {
-    if (!this->agent_identity().IsInitialized()) return false;
-  }
-  if (has_target_id()) {
-    if (!this->target_id().IsInitialized()) return false;
-  }
-  if (has_params()) {
-    if (!this->params().IsInitialized()) return false;
-  }
-  if (has_agent_info()) {
-    if (!this->agent_info().IsInitialized()) return false;
-  }
-  if (has_target()) {
-    if (!this->target().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void SendInvitationRequest::Swap(SendInvitationRequest* other) {
-  if (other != this) {
-    std::swap(agent_identity_, other->agent_identity_);
-    std::swap(target_id_, other->target_id_);
-    std::swap(params_, other->params_);
-    std::swap(agent_info_, other->agent_info_);
-    std::swap(target_, other->target_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata SendInvitationRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = SendInvitationRequest_descriptor_;
-  metadata.reflection = SendInvitationRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-#endif  // !_MSC_VER
-
-SendInvitationResponse::SendInvitationResponse()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.SendInvitationResponse)
-}
-
-void SendInvitationResponse::InitAsDefaultInstance() {
-}
-
-SendInvitationResponse::SendInvitationResponse(const SendInvitationResponse& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.SendInvitationResponse)
-}
-
-void SendInvitationResponse::SharedCtor() {
-  _cached_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-SendInvitationResponse::~SendInvitationResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.SendInvitationResponse)
-  SharedDtor();
-}
-
-void SendInvitationResponse::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void SendInvitationResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* SendInvitationResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return SendInvitationResponse_descriptor_;
-}
-
-const SendInvitationResponse& SendInvitationResponse::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-SendInvitationResponse* SendInvitationResponse::default_instance_ = NULL;
-
-SendInvitationResponse* SendInvitationResponse::New() const {
-  return new SendInvitationResponse;
-}
-
-void SendInvitationResponse::Clear() {
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool SendInvitationResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.SendInvitationResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-  handle_unusual:
-    if (tag == 0 ||
-        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-      goto success;
-    }
-    DO_(::google::protobuf::internal::WireFormat::SkipField(
-          input, tag, mutable_unknown_fields()));
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.SendInvitationResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.SendInvitationResponse)
-  return false;
-#undef DO_
-}
-
-void SendInvitationResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.SendInvitationResponse)
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.SendInvitationResponse)
-}
-
-::google::protobuf::uint8* SendInvitationResponse::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.SendInvitationResponse)
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.SendInvitationResponse)
-  return target;
-}
-
-int SendInvitationResponse::ByteSize() const {
-  int total_size = 0;
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void SendInvitationResponse::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const SendInvitationResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const SendInvitationResponse*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void SendInvitationResponse::MergeFrom(const SendInvitationResponse& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void SendInvitationResponse::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void SendInvitationResponse::CopyFrom(const SendInvitationResponse& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool SendInvitationResponse::IsInitialized() const {
-
-  return true;
-}
-
-void SendInvitationResponse::Swap(SendInvitationResponse* other) {
-  if (other != this) {
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata SendInvitationResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = SendInvitationResponse_descriptor_;
-  metadata.reflection = SendInvitationResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int UpdateInvitationRequest::kAgentIdentityFieldNumber;
-const int UpdateInvitationRequest::kInvitationIdFieldNumber;
-const int UpdateInvitationRequest::kParamsFieldNumber;
-#endif  // !_MSC_VER
-
-UpdateInvitationRequest::UpdateInvitationRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.UpdateInvitationRequest)
-}
-
-void UpdateInvitationRequest::InitAsDefaultInstance() {
-  agent_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
-  params_ = const_cast< ::bgs::protocol::InvitationParams*>(&::bgs::protocol::InvitationParams::default_instance());
-}
-
-UpdateInvitationRequest::UpdateInvitationRequest(const UpdateInvitationRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.UpdateInvitationRequest)
-}
-
-void UpdateInvitationRequest::SharedCtor() {
-  _cached_size_ = 0;
-  agent_identity_ = NULL;
-  invitation_id_ = GOOGLE_ULONGLONG(0);
-  params_ = NULL;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-UpdateInvitationRequest::~UpdateInvitationRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.UpdateInvitationRequest)
-  SharedDtor();
-}
-
-void UpdateInvitationRequest::SharedDtor() {
-  if (this != default_instance_) {
-    delete agent_identity_;
-    delete params_;
-  }
-}
-
-void UpdateInvitationRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* UpdateInvitationRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return UpdateInvitationRequest_descriptor_;
-}
-
-const UpdateInvitationRequest& UpdateInvitationRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-UpdateInvitationRequest* UpdateInvitationRequest::default_instance_ = NULL;
-
-UpdateInvitationRequest* UpdateInvitationRequest::New() const {
-  return new UpdateInvitationRequest;
-}
-
-void UpdateInvitationRequest::Clear() {
-  if (_has_bits_[0 / 32] & 7) {
-    if (has_agent_identity()) {
-      if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
-    }
-    invitation_id_ = GOOGLE_ULONGLONG(0);
-    if (has_params()) {
-      if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
-    }
-  }
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool UpdateInvitationRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.UpdateInvitationRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.Identity agent_identity = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_identity()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(17)) goto parse_invitation_id;
-        break;
-      }
-
-      // required fixed64 invitation_id = 2;
-      case 2: {
-        if (tag == 17) {
-         parse_invitation_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
-                 input, &invitation_id_)));
-          set_has_invitation_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(26)) goto parse_params;
-        break;
-      }
-
-      // required .bgs.protocol.InvitationParams params = 3;
-      case 3: {
-        if (tag == 26) {
-         parse_params:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_params()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.UpdateInvitationRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.UpdateInvitationRequest)
-  return false;
-#undef DO_
-}
-
-void UpdateInvitationRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.UpdateInvitationRequest)
-  // optional .bgs.protocol.Identity agent_identity = 1;
-  if (has_agent_identity()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_identity(), output);
-  }
-
-  // required fixed64 invitation_id = 2;
-  if (has_invitation_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->invitation_id(), output);
-  }
-
-  // required .bgs.protocol.InvitationParams params = 3;
-  if (has_params()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      3, this->params(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.UpdateInvitationRequest)
-}
-
-::google::protobuf::uint8* UpdateInvitationRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.UpdateInvitationRequest)
-  // optional .bgs.protocol.Identity agent_identity = 1;
-  if (has_agent_identity()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_identity(), target);
-  }
-
-  // required fixed64 invitation_id = 2;
-  if (has_invitation_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->invitation_id(), target);
-  }
-
-  // required .bgs.protocol.InvitationParams params = 3;
-  if (has_params()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        3, this->params(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.UpdateInvitationRequest)
-  return target;
-}
-
-int UpdateInvitationRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.Identity agent_identity = 1;
-    if (has_agent_identity()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_identity());
-    }
-
-    // required fixed64 invitation_id = 2;
-    if (has_invitation_id()) {
-      total_size += 1 + 8;
-    }
-
-    // required .bgs.protocol.InvitationParams params = 3;
-    if (has_params()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->params());
-    }
-
-  }
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void UpdateInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const UpdateInvitationRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateInvitationRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void UpdateInvitationRequest::MergeFrom(const UpdateInvitationRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_identity()) {
-      mutable_agent_identity()->::bgs::protocol::Identity::MergeFrom(from.agent_identity());
-    }
-    if (from.has_invitation_id()) {
-      set_invitation_id(from.invitation_id());
-    }
-    if (from.has_params()) {
-      mutable_params()->::bgs::protocol::InvitationParams::MergeFrom(from.params());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void UpdateInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void UpdateInvitationRequest::CopyFrom(const UpdateInvitationRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool UpdateInvitationRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
-
-  if (has_agent_identity()) {
-    if (!this->agent_identity().IsInitialized()) return false;
-  }
-  if (has_params()) {
-    if (!this->params().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void UpdateInvitationRequest::Swap(UpdateInvitationRequest* other) {
-  if (other != this) {
-    std::swap(agent_identity_, other->agent_identity_);
-    std::swap(invitation_id_, other->invitation_id_);
-    std::swap(params_, other->params_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata UpdateInvitationRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = UpdateInvitationRequest_descriptor_;
-  metadata.reflection = UpdateInvitationRequest_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
-const int GenericInvitationRequest::kAgentIdFieldNumber;
-const int GenericInvitationRequest::kTargetIdFieldNumber;
-const int GenericInvitationRequest::kInvitationIdFieldNumber;
-const int GenericInvitationRequest::kInviteeNameFieldNumber;
-const int GenericInvitationRequest::kInviterNameFieldNumber;
-const int GenericInvitationRequest::kPreviousRoleFieldNumber;
-const int GenericInvitationRequest::kDesiredRoleFieldNumber;
-const int GenericInvitationRequest::kReasonFieldNumber;
-#endif  // !_MSC_VER
-
-GenericInvitationRequest::GenericInvitationRequest()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.GenericInvitationRequest)
-}
-
-void GenericInvitationRequest::InitAsDefaultInstance() {
-  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
-}
-
-GenericInvitationRequest::GenericInvitationRequest(const GenericInvitationRequest& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.GenericInvitationRequest)
-}
-
-void GenericInvitationRequest::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
-  _cached_size_ = 0;
-  agent_id_ = NULL;
-  target_id_ = NULL;
-  invitation_id_ = GOOGLE_ULONGLONG(0);
-  invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  _previous_role_cached_byte_size_ = 0;
-  _desired_role_cached_byte_size_ = 0;
-  reason_ = 0u;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-GenericInvitationRequest::~GenericInvitationRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.GenericInvitationRequest)
-  SharedDtor();
-}
-
-void GenericInvitationRequest::SharedDtor() {
-  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete invitee_name_;
-  }
-  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete inviter_name_;
-  }
-  if (this != default_instance_) {
-    delete agent_id_;
-    delete target_id_;
-  }
-}
-
-void GenericInvitationRequest::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* GenericInvitationRequest::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return GenericInvitationRequest_descriptor_;
-}
-
-const GenericInvitationRequest& GenericInvitationRequest::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
-  return *default_instance_;
-}
-
-GenericInvitationRequest* GenericInvitationRequest::default_instance_ = NULL;
-
-GenericInvitationRequest* GenericInvitationRequest::New() const {
-  return new GenericInvitationRequest;
-}
-
-void GenericInvitationRequest::Clear() {
-  if (_has_bits_[0 / 32] & 159) {
-    if (has_agent_id()) {
-      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-    }
-    if (has_target_id()) {
-      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
-    }
-    invitation_id_ = GOOGLE_ULONGLONG(0);
-    if (has_invitee_name()) {
-      if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        invitee_name_->clear();
-      }
-    }
-    if (has_inviter_name()) {
-      if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        inviter_name_->clear();
-      }
-    }
-    reason_ = 0u;
-  }
-  previous_role_.Clear();
-  desired_role_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool GenericInvitationRequest::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.GenericInvitationRequest)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional .bgs.protocol.EntityId agent_id = 1;
-      case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_agent_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(18)) goto parse_target_id;
-        break;
-      }
-
-      // optional .bgs.protocol.EntityId target_id = 2;
-      case 2: {
-        if (tag == 18) {
-         parse_target_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_target_id()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(25)) goto parse_invitation_id;
-        break;
-      }
-
-      // required fixed64 invitation_id = 3;
-      case 3: {
-        if (tag == 25) {
-         parse_invitation_id:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
-                 input, &invitation_id_)));
-          set_has_invitation_id();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(34)) goto parse_invitee_name;
-        break;
-      }
-
-      // optional string invitee_name = 4;
-      case 4: {
-        if (tag == 34) {
-         parse_invitee_name:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_invitee_name()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->invitee_name().data(), this->invitee_name().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "invitee_name");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(42)) goto parse_inviter_name;
-        break;
-      }
-
-      // optional string inviter_name = 5;
-      case 5: {
-        if (tag == 42) {
-         parse_inviter_name:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_inviter_name()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->inviter_name().data(), this->inviter_name().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "inviter_name");
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(50)) goto parse_previous_role;
-        break;
-      }
-
-      // repeated uint32 previous_role = 6 [packed = true];
-      case 6: {
-        if (tag == 50) {
-         parse_previous_role:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, this->mutable_previous_role())));
-        } else if (tag == 48) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 1, 50, input, this->mutable_previous_role())));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(58)) goto parse_desired_role;
-        break;
-      }
-
-      // repeated uint32 desired_role = 7 [packed = true];
-      case 7: {
-        if (tag == 58) {
-         parse_desired_role:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, this->mutable_desired_role())));
-        } else if (tag == 56) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 1, 58, input, this->mutable_desired_role())));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(64)) goto parse_reason;
-        break;
-      }
-
-      // optional uint32 reason = 8;
-      case 8: {
-        if (tag == 64) {
-         parse_reason:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &reason_)));
-          set_has_reason();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.GenericInvitationRequest)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.GenericInvitationRequest)
-  return false;
-#undef DO_
-}
-
-void GenericInvitationRequest::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.GenericInvitationRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->agent_id(), output);
-  }
-
-  // optional .bgs.protocol.EntityId target_id = 2;
-  if (has_target_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      2, this->target_id(), output);
-  }
-
-  // required fixed64 invitation_id = 3;
-  if (has_invitation_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
-  }
-
-  // optional string invitee_name = 4;
-  if (has_invitee_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->invitee_name().data(), this->invitee_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "invitee_name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      4, this->invitee_name(), output);
-  }
-
-  // optional string inviter_name = 5;
-  if (has_inviter_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->inviter_name().data(), this->inviter_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "inviter_name");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      5, this->inviter_name(), output);
-  }
-
-  // repeated uint32 previous_role = 6 [packed = true];
-  if (this->previous_role_size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
-    output->WriteVarint32(_previous_role_cached_byte_size_);
-  }
-  for (int i = 0; i < this->previous_role_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
-      this->previous_role(i), output);
-  }
-
-  // repeated uint32 desired_role = 7 [packed = true];
-  if (this->desired_role_size() > 0) {
-    ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
-    output->WriteVarint32(_desired_role_cached_byte_size_);
-  }
-  for (int i = 0; i < this->desired_role_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
-      this->desired_role(i), output);
-  }
-
-  // optional uint32 reason = 8;
-  if (has_reason()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->reason(), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.GenericInvitationRequest)
-}
-
-::google::protobuf::uint8* GenericInvitationRequest::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.GenericInvitationRequest)
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  if (has_agent_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->agent_id(), target);
-  }
-
-  // optional .bgs.protocol.EntityId target_id = 2;
-  if (has_target_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        2, this->target_id(), target);
-  }
-
-  // required fixed64 invitation_id = 3;
-  if (has_invitation_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
-  }
-
-  // optional string invitee_name = 4;
-  if (has_invitee_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->invitee_name().data(), this->invitee_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "invitee_name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        4, this->invitee_name(), target);
-  }
-
-  // optional string inviter_name = 5;
-  if (has_inviter_name()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->inviter_name().data(), this->inviter_name().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "inviter_name");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        5, this->inviter_name(), target);
-  }
-
-  // repeated uint32 previous_role = 6 [packed = true];
-  if (this->previous_role_size() > 0) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
-      6,
-      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
-      target);
-    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
-      _previous_role_cached_byte_size_, target);
-  }
-  for (int i = 0; i < this->previous_role_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteUInt32NoTagToArray(this->previous_role(i), target);
-  }
-
-  // repeated uint32 desired_role = 7 [packed = true];
-  if (this->desired_role_size() > 0) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
-      7,
-      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
-      target);
-    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
-      _desired_role_cached_byte_size_, target);
-  }
-  for (int i = 0; i < this->desired_role_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteUInt32NoTagToArray(this->desired_role(i), target);
-  }
-
-  // optional uint32 reason = 8;
-  if (has_reason()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->reason(), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.GenericInvitationRequest)
-  return target;
-}
-
-int GenericInvitationRequest::ByteSize() const {
-  int total_size = 0;
-
-  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional .bgs.protocol.EntityId agent_id = 1;
-    if (has_agent_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->agent_id());
-    }
-
-    // optional .bgs.protocol.EntityId target_id = 2;
-    if (has_target_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->target_id());
-    }
-
-    // required fixed64 invitation_id = 3;
-    if (has_invitation_id()) {
-      total_size += 1 + 8;
-    }
-
-    // optional string invitee_name = 4;
-    if (has_invitee_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->invitee_name());
-    }
-
-    // optional string inviter_name = 5;
-    if (has_inviter_name()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->inviter_name());
-    }
-
-    // optional uint32 reason = 8;
-    if (has_reason()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->reason());
-    }
-
-  }
-  // repeated uint32 previous_role = 6 [packed = true];
-  {
-    int data_size = 0;
-    for (int i = 0; i < this->previous_role_size(); i++) {
-      data_size += ::google::protobuf::internal::WireFormatLite::
-        UInt32Size(this->previous_role(i));
-    }
-    if (data_size > 0) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
-    }
-    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-    _previous_role_cached_byte_size_ = data_size;
-    GOOGLE_SAFE_CONCURRENT_WRITES_END();
-    total_size += data_size;
-  }
-
-  // repeated uint32 desired_role = 7 [packed = true];
-  {
-    int data_size = 0;
-    for (int i = 0; i < this->desired_role_size(); i++) {
-      data_size += ::google::protobuf::internal::WireFormatLite::
-        UInt32Size(this->desired_role(i));
-    }
-    if (data_size > 0) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
-    }
-    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-    _desired_role_cached_byte_size_ = data_size;
-    GOOGLE_SAFE_CONCURRENT_WRITES_END();
-    total_size += data_size;
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void GenericInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const GenericInvitationRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const GenericInvitationRequest*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void GenericInvitationRequest::MergeFrom(const GenericInvitationRequest& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  previous_role_.MergeFrom(from.previous_role_);
-  desired_role_.MergeFrom(from.desired_role_);
-  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_agent_id()) {
-      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
-    }
-    if (from.has_target_id()) {
-      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
-    }
-    if (from.has_invitation_id()) {
-      set_invitation_id(from.invitation_id());
-    }
-    if (from.has_invitee_name()) {
-      set_invitee_name(from.invitee_name());
-    }
-    if (from.has_inviter_name()) {
-      set_inviter_name(from.inviter_name());
-    }
-    if (from.has_reason()) {
-      set_reason(from.reason());
-    }
-  }
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void GenericInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void GenericInvitationRequest::CopyFrom(const GenericInvitationRequest& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool GenericInvitationRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false;
-
-  if (has_agent_id()) {
-    if (!this->agent_id().IsInitialized()) return false;
-  }
-  if (has_target_id()) {
-    if (!this->target_id().IsInitialized()) return false;
-  }
-  return true;
-}
-
-void GenericInvitationRequest::Swap(GenericInvitationRequest* other) {
-  if (other != this) {
-    std::swap(agent_id_, other->agent_id_);
-    std::swap(target_id_, other->target_id_);
-    std::swap(invitation_id_, other->invitation_id_);
-    std::swap(invitee_name_, other->invitee_name_);
-    std::swap(inviter_name_, other->inviter_name_);
-    previous_role_.Swap(&other->previous_role_);
-    desired_role_.Swap(&other->desired_role_);
-    std::swap(reason_, other->reason_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata GenericInvitationRequest::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = GenericInvitationRequest_descriptor_;
-  metadata.reflection = GenericInvitationRequest_reflection_;
-  return metadata;
-}
-
-
 // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace protocol
diff --git a/src/server/proto/Client/invitation_types.pb.h b/src/server/proto/Client/invitation_types.pb.h
index b24816549b0..3a2837e61bc 100644
--- a/src/server/proto/Client/invitation_types.pb.h
+++ b/src/server/proto/Client/invitation_types.pb.h
@@ -23,6 +23,7 @@
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_enum_reflection.h>
 #include <google/protobuf/unknown_field_set.h>
 #include "entity_types.pb.h"
 #include "Define.h" // for TC_PROTO_API
@@ -37,14 +38,52 @@ void protobuf_AssignDesc_invitation_5ftypes_2eproto();
 void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
 
 class Invitation;
-class InvitationSuggestion;
-class InvitationTarget;
 class InvitationParams;
-class SendInvitationRequest;
-class SendInvitationResponse;
-class UpdateInvitationRequest;
-class GenericInvitationRequest;
 
+enum InvitationRemovedReason {
+  INVITATION_REMOVED_REASON_ACCEPTED = 0,
+  INVITATION_REMOVED_REASON_DECLINED = 1,
+  INVITATION_REMOVED_REASON_REVOKED = 2,
+  INVITATION_REMOVED_REASON_IGNORED = 3,
+  INVITATION_REMOVED_REASON_EXPIRED = 4,
+  INVITATION_REMOVED_REASON_CANCELED = 5
+};
+TC_PROTO_API bool InvitationRemovedReason_IsValid(int value);
+const InvitationRemovedReason InvitationRemovedReason_MIN = INVITATION_REMOVED_REASON_ACCEPTED;
+const InvitationRemovedReason InvitationRemovedReason_MAX = INVITATION_REMOVED_REASON_CANCELED;
+const int InvitationRemovedReason_ARRAYSIZE = InvitationRemovedReason_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* InvitationRemovedReason_descriptor();
+inline const ::std::string& InvitationRemovedReason_Name(InvitationRemovedReason value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    InvitationRemovedReason_descriptor(), value);
+}
+inline bool InvitationRemovedReason_Parse(
+    const ::std::string& name, InvitationRemovedReason* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<InvitationRemovedReason>(
+    InvitationRemovedReason_descriptor(), name, value);
+}
+enum SuggestionRemovedReason {
+  SUGGESTION_REMOVED_REASON_APPROVED = 0,
+  SUGGESTION_REMOVED_REASON_DECLINED = 1,
+  SUGGESTION_REMOVED_REASON_EXPIRED = 2,
+  SUGGESTION_REMOVED_REASON_CANCELED = 3
+};
+TC_PROTO_API bool SuggestionRemovedReason_IsValid(int value);
+const SuggestionRemovedReason SuggestionRemovedReason_MIN = SUGGESTION_REMOVED_REASON_APPROVED;
+const SuggestionRemovedReason SuggestionRemovedReason_MAX = SUGGESTION_REMOVED_REASON_CANCELED;
+const int SuggestionRemovedReason_ARRAYSIZE = SuggestionRemovedReason_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* SuggestionRemovedReason_descriptor();
+inline const ::std::string& SuggestionRemovedReason_Name(SuggestionRemovedReason value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SuggestionRemovedReason_descriptor(), value);
+}
+inline bool SuggestionRemovedReason_Parse(
+    const ::std::string& name, SuggestionRemovedReason* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SuggestionRemovedReason>(
+    SuggestionRemovedReason_descriptor(), name, value);
+}
 // ===================================================================
 
 class TC_PROTO_API Invitation : public ::google::protobuf::Message {
@@ -218,255 +257,6 @@ class TC_PROTO_API Invitation : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API InvitationSuggestion : public ::google::protobuf::Message {
- public:
-  InvitationSuggestion();
-  virtual ~InvitationSuggestion();
-
-  InvitationSuggestion(const InvitationSuggestion& from);
-
-  inline InvitationSuggestion& operator=(const InvitationSuggestion& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const InvitationSuggestion& default_instance();
-
-  void Swap(InvitationSuggestion* other);
-
-  // implements Message ----------------------------------------------
-
-  InvitationSuggestion* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const InvitationSuggestion& from);
-  void MergeFrom(const InvitationSuggestion& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId channel_id = 1;
-  inline bool has_channel_id() const;
-  inline void clear_channel_id();
-  static const int kChannelIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& channel_id() const;
-  inline ::bgs::protocol::EntityId* mutable_channel_id();
-  inline ::bgs::protocol::EntityId* release_channel_id();
-  inline void set_allocated_channel_id(::bgs::protocol::EntityId* channel_id);
-
-  // required .bgs.protocol.EntityId suggester_id = 2;
-  inline bool has_suggester_id() const;
-  inline void clear_suggester_id();
-  static const int kSuggesterIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& suggester_id() const;
-  inline ::bgs::protocol::EntityId* mutable_suggester_id();
-  inline ::bgs::protocol::EntityId* release_suggester_id();
-  inline void set_allocated_suggester_id(::bgs::protocol::EntityId* suggester_id);
-
-  // required .bgs.protocol.EntityId suggestee_id = 3;
-  inline bool has_suggestee_id() const;
-  inline void clear_suggestee_id();
-  static const int kSuggesteeIdFieldNumber = 3;
-  inline const ::bgs::protocol::EntityId& suggestee_id() const;
-  inline ::bgs::protocol::EntityId* mutable_suggestee_id();
-  inline ::bgs::protocol::EntityId* release_suggestee_id();
-  inline void set_allocated_suggestee_id(::bgs::protocol::EntityId* suggestee_id);
-
-  // optional string suggester_name = 4;
-  inline bool has_suggester_name() const;
-  inline void clear_suggester_name();
-  static const int kSuggesterNameFieldNumber = 4;
-  inline const ::std::string& suggester_name() const;
-  inline void set_suggester_name(const ::std::string& value);
-  inline void set_suggester_name(const char* value);
-  inline void set_suggester_name(const char* value, size_t size);
-  inline ::std::string* mutable_suggester_name();
-  inline ::std::string* release_suggester_name();
-  inline void set_allocated_suggester_name(::std::string* suggester_name);
-
-  // optional string suggestee_name = 5;
-  inline bool has_suggestee_name() const;
-  inline void clear_suggestee_name();
-  static const int kSuggesteeNameFieldNumber = 5;
-  inline const ::std::string& suggestee_name() const;
-  inline void set_suggestee_name(const ::std::string& value);
-  inline void set_suggestee_name(const char* value);
-  inline void set_suggestee_name(const char* value, size_t size);
-  inline ::std::string* mutable_suggestee_name();
-  inline ::std::string* release_suggestee_name();
-  inline void set_allocated_suggestee_name(::std::string* suggestee_name);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.InvitationSuggestion)
- private:
-  inline void set_has_channel_id();
-  inline void clear_has_channel_id();
-  inline void set_has_suggester_id();
-  inline void clear_has_suggester_id();
-  inline void set_has_suggestee_id();
-  inline void clear_has_suggestee_id();
-  inline void set_has_suggester_name();
-  inline void clear_has_suggester_name();
-  inline void set_has_suggestee_name();
-  inline void clear_has_suggestee_name();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* channel_id_;
-  ::bgs::protocol::EntityId* suggester_id_;
-  ::bgs::protocol::EntityId* suggestee_id_;
-  ::std::string* suggester_name_;
-  ::std::string* suggestee_name_;
-  friend void TC_PROTO_API protobuf_AddDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static InvitationSuggestion* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API InvitationTarget : public ::google::protobuf::Message {
- public:
-  InvitationTarget();
-  virtual ~InvitationTarget();
-
-  InvitationTarget(const InvitationTarget& from);
-
-  inline InvitationTarget& operator=(const InvitationTarget& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const InvitationTarget& default_instance();
-
-  void Swap(InvitationTarget* other);
-
-  // implements Message ----------------------------------------------
-
-  InvitationTarget* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const InvitationTarget& from);
-  void MergeFrom(const InvitationTarget& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.Identity identity = 1;
-  inline bool has_identity() const;
-  inline void clear_identity();
-  static const int kIdentityFieldNumber = 1;
-  inline const ::bgs::protocol::Identity& identity() const;
-  inline ::bgs::protocol::Identity* mutable_identity();
-  inline ::bgs::protocol::Identity* release_identity();
-  inline void set_allocated_identity(::bgs::protocol::Identity* identity);
-
-  // optional string email = 2;
-  inline bool has_email() const;
-  inline void clear_email();
-  static const int kEmailFieldNumber = 2;
-  inline const ::std::string& email() const;
-  inline void set_email(const ::std::string& value);
-  inline void set_email(const char* value);
-  inline void set_email(const char* value, size_t size);
-  inline ::std::string* mutable_email();
-  inline ::std::string* release_email();
-  inline void set_allocated_email(::std::string* email);
-
-  // optional string battle_tag = 3;
-  inline bool has_battle_tag() const;
-  inline void clear_battle_tag();
-  static const int kBattleTagFieldNumber = 3;
-  inline const ::std::string& battle_tag() const;
-  inline void set_battle_tag(const ::std::string& value);
-  inline void set_battle_tag(const char* value);
-  inline void set_battle_tag(const char* value, size_t size);
-  inline ::std::string* mutable_battle_tag();
-  inline ::std::string* release_battle_tag();
-  inline void set_allocated_battle_tag(::std::string* battle_tag);
-
-  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(InvitationTarget)
-  // @@protoc_insertion_point(class_scope:bgs.protocol.InvitationTarget)
- private:
-  inline void set_has_identity();
-  inline void clear_has_identity();
-  inline void set_has_email();
-  inline void clear_has_email();
-  inline void set_has_battle_tag();
-  inline void clear_has_battle_tag();
-
-  ::google::protobuf::internal::ExtensionSet _extensions_;
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::Identity* identity_;
-  ::std::string* email_;
-  ::std::string* battle_tag_;
-  friend void TC_PROTO_API protobuf_AddDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static InvitationTarget* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API InvitationParams : public ::google::protobuf::Message {
  public:
   InvitationParams();
@@ -520,19 +310,19 @@ class TC_PROTO_API InvitationParams : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional string invitation_message = 1;
-  inline bool has_invitation_message() const;
-  inline void clear_invitation_message();
+  // optional string invitation_message = 1 [deprecated = true];
+  inline bool has_invitation_message() const PROTOBUF_DEPRECATED;
+  inline void clear_invitation_message() PROTOBUF_DEPRECATED;
   static const int kInvitationMessageFieldNumber = 1;
-  inline const ::std::string& invitation_message() const;
-  inline void set_invitation_message(const ::std::string& value);
-  inline void set_invitation_message(const char* value);
-  inline void set_invitation_message(const char* value, size_t size);
-  inline ::std::string* mutable_invitation_message();
-  inline ::std::string* release_invitation_message();
-  inline void set_allocated_invitation_message(::std::string* invitation_message);
-
-  // optional uint64 expiration_time = 2 [default = 0];
+  inline const ::std::string& invitation_message() const PROTOBUF_DEPRECATED;
+  inline void set_invitation_message(const ::std::string& value) PROTOBUF_DEPRECATED;
+  inline void set_invitation_message(const char* value) PROTOBUF_DEPRECATED;
+  inline void set_invitation_message(const char* value, size_t size) PROTOBUF_DEPRECATED;
+  inline ::std::string* mutable_invitation_message() PROTOBUF_DEPRECATED;
+  inline ::std::string* release_invitation_message() PROTOBUF_DEPRECATED;
+  inline void set_allocated_invitation_message(::std::string* invitation_message) PROTOBUF_DEPRECATED;
+
+  // optional uint64 expiration_time = 2;
   inline bool has_expiration_time() const;
   inline void clear_expiration_time();
   static const int kExpirationTimeFieldNumber = 2;
@@ -562,478 +352,6 @@ class TC_PROTO_API InvitationParams : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static InvitationParams* default_instance_;
 };
-// -------------------------------------------------------------------
-
-class TC_PROTO_API SendInvitationRequest : public ::google::protobuf::Message {
- public:
-  SendInvitationRequest();
-  virtual ~SendInvitationRequest();
-
-  SendInvitationRequest(const SendInvitationRequest& from);
-
-  inline SendInvitationRequest& operator=(const SendInvitationRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const SendInvitationRequest& default_instance();
-
-  void Swap(SendInvitationRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  SendInvitationRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const SendInvitationRequest& from);
-  void MergeFrom(const SendInvitationRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.Identity agent_identity = 1;
-  inline bool has_agent_identity() const;
-  inline void clear_agent_identity();
-  static const int kAgentIdentityFieldNumber = 1;
-  inline const ::bgs::protocol::Identity& agent_identity() const;
-  inline ::bgs::protocol::Identity* mutable_agent_identity();
-  inline ::bgs::protocol::Identity* release_agent_identity();
-  inline void set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity);
-
-  // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
-  inline bool has_target_id() const PROTOBUF_DEPRECATED;
-  inline void clear_target_id() PROTOBUF_DEPRECATED;
-  static const int kTargetIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& target_id() const PROTOBUF_DEPRECATED;
-  inline ::bgs::protocol::EntityId* mutable_target_id() PROTOBUF_DEPRECATED;
-  inline ::bgs::protocol::EntityId* release_target_id() PROTOBUF_DEPRECATED;
-  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id) PROTOBUF_DEPRECATED;
-
-  // required .bgs.protocol.InvitationParams params = 3;
-  inline bool has_params() const;
-  inline void clear_params();
-  static const int kParamsFieldNumber = 3;
-  inline const ::bgs::protocol::InvitationParams& params() const;
-  inline ::bgs::protocol::InvitationParams* mutable_params();
-  inline ::bgs::protocol::InvitationParams* release_params();
-  inline void set_allocated_params(::bgs::protocol::InvitationParams* params);
-
-  // optional .bgs.protocol.AccountInfo agent_info = 4;
-  inline bool has_agent_info() const;
-  inline void clear_agent_info();
-  static const int kAgentInfoFieldNumber = 4;
-  inline const ::bgs::protocol::AccountInfo& agent_info() const;
-  inline ::bgs::protocol::AccountInfo* mutable_agent_info();
-  inline ::bgs::protocol::AccountInfo* release_agent_info();
-  inline void set_allocated_agent_info(::bgs::protocol::AccountInfo* agent_info);
-
-  // optional .bgs.protocol.InvitationTarget target = 5;
-  inline bool has_target() const;
-  inline void clear_target();
-  static const int kTargetFieldNumber = 5;
-  inline const ::bgs::protocol::InvitationTarget& target() const;
-  inline ::bgs::protocol::InvitationTarget* mutable_target();
-  inline ::bgs::protocol::InvitationTarget* release_target();
-  inline void set_allocated_target(::bgs::protocol::InvitationTarget* target);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.SendInvitationRequest)
- private:
-  inline void set_has_agent_identity();
-  inline void clear_has_agent_identity();
-  inline void set_has_target_id();
-  inline void clear_has_target_id();
-  inline void set_has_params();
-  inline void clear_has_params();
-  inline void set_has_agent_info();
-  inline void clear_has_agent_info();
-  inline void set_has_target();
-  inline void clear_has_target();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::Identity* agent_identity_;
-  ::bgs::protocol::EntityId* target_id_;
-  ::bgs::protocol::InvitationParams* params_;
-  ::bgs::protocol::AccountInfo* agent_info_;
-  ::bgs::protocol::InvitationTarget* target_;
-  friend void TC_PROTO_API protobuf_AddDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static SendInvitationRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API SendInvitationResponse : public ::google::protobuf::Message {
- public:
-  SendInvitationResponse();
-  virtual ~SendInvitationResponse();
-
-  SendInvitationResponse(const SendInvitationResponse& from);
-
-  inline SendInvitationResponse& operator=(const SendInvitationResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const SendInvitationResponse& default_instance();
-
-  void Swap(SendInvitationResponse* other);
-
-  // implements Message ----------------------------------------------
-
-  SendInvitationResponse* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const SendInvitationResponse& from);
-  void MergeFrom(const SendInvitationResponse& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.SendInvitationResponse)
- private:
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  friend void TC_PROTO_API protobuf_AddDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static SendInvitationResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API UpdateInvitationRequest : public ::google::protobuf::Message {
- public:
-  UpdateInvitationRequest();
-  virtual ~UpdateInvitationRequest();
-
-  UpdateInvitationRequest(const UpdateInvitationRequest& from);
-
-  inline UpdateInvitationRequest& operator=(const UpdateInvitationRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const UpdateInvitationRequest& default_instance();
-
-  void Swap(UpdateInvitationRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  UpdateInvitationRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const UpdateInvitationRequest& from);
-  void MergeFrom(const UpdateInvitationRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.Identity agent_identity = 1;
-  inline bool has_agent_identity() const;
-  inline void clear_agent_identity();
-  static const int kAgentIdentityFieldNumber = 1;
-  inline const ::bgs::protocol::Identity& agent_identity() const;
-  inline ::bgs::protocol::Identity* mutable_agent_identity();
-  inline ::bgs::protocol::Identity* release_agent_identity();
-  inline void set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity);
-
-  // required fixed64 invitation_id = 2;
-  inline bool has_invitation_id() const;
-  inline void clear_invitation_id();
-  static const int kInvitationIdFieldNumber = 2;
-  inline ::google::protobuf::uint64 invitation_id() const;
-  inline void set_invitation_id(::google::protobuf::uint64 value);
-
-  // required .bgs.protocol.InvitationParams params = 3;
-  inline bool has_params() const;
-  inline void clear_params();
-  static const int kParamsFieldNumber = 3;
-  inline const ::bgs::protocol::InvitationParams& params() const;
-  inline ::bgs::protocol::InvitationParams* mutable_params();
-  inline ::bgs::protocol::InvitationParams* release_params();
-  inline void set_allocated_params(::bgs::protocol::InvitationParams* params);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.UpdateInvitationRequest)
- private:
-  inline void set_has_agent_identity();
-  inline void clear_has_agent_identity();
-  inline void set_has_invitation_id();
-  inline void clear_has_invitation_id();
-  inline void set_has_params();
-  inline void clear_has_params();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::Identity* agent_identity_;
-  ::google::protobuf::uint64 invitation_id_;
-  ::bgs::protocol::InvitationParams* params_;
-  friend void TC_PROTO_API protobuf_AddDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static UpdateInvitationRequest* default_instance_;
-};
-// -------------------------------------------------------------------
-
-class TC_PROTO_API GenericInvitationRequest : public ::google::protobuf::Message {
- public:
-  GenericInvitationRequest();
-  virtual ~GenericInvitationRequest();
-
-  GenericInvitationRequest(const GenericInvitationRequest& from);
-
-  inline GenericInvitationRequest& operator=(const GenericInvitationRequest& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const GenericInvitationRequest& default_instance();
-
-  void Swap(GenericInvitationRequest* other);
-
-  // implements Message ----------------------------------------------
-
-  GenericInvitationRequest* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const GenericInvitationRequest& from);
-  void MergeFrom(const GenericInvitationRequest& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // optional .bgs.protocol.EntityId agent_id = 1;
-  inline bool has_agent_id() const;
-  inline void clear_agent_id();
-  static const int kAgentIdFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& agent_id() const;
-  inline ::bgs::protocol::EntityId* mutable_agent_id();
-  inline ::bgs::protocol::EntityId* release_agent_id();
-  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
-
-  // optional .bgs.protocol.EntityId target_id = 2;
-  inline bool has_target_id() const;
-  inline void clear_target_id();
-  static const int kTargetIdFieldNumber = 2;
-  inline const ::bgs::protocol::EntityId& target_id() const;
-  inline ::bgs::protocol::EntityId* mutable_target_id();
-  inline ::bgs::protocol::EntityId* release_target_id();
-  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
-
-  // required fixed64 invitation_id = 3;
-  inline bool has_invitation_id() const;
-  inline void clear_invitation_id();
-  static const int kInvitationIdFieldNumber = 3;
-  inline ::google::protobuf::uint64 invitation_id() const;
-  inline void set_invitation_id(::google::protobuf::uint64 value);
-
-  // optional string invitee_name = 4;
-  inline bool has_invitee_name() const;
-  inline void clear_invitee_name();
-  static const int kInviteeNameFieldNumber = 4;
-  inline const ::std::string& invitee_name() const;
-  inline void set_invitee_name(const ::std::string& value);
-  inline void set_invitee_name(const char* value);
-  inline void set_invitee_name(const char* value, size_t size);
-  inline ::std::string* mutable_invitee_name();
-  inline ::std::string* release_invitee_name();
-  inline void set_allocated_invitee_name(::std::string* invitee_name);
-
-  // optional string inviter_name = 5;
-  inline bool has_inviter_name() const;
-  inline void clear_inviter_name();
-  static const int kInviterNameFieldNumber = 5;
-  inline const ::std::string& inviter_name() const;
-  inline void set_inviter_name(const ::std::string& value);
-  inline void set_inviter_name(const char* value);
-  inline void set_inviter_name(const char* value, size_t size);
-  inline ::std::string* mutable_inviter_name();
-  inline ::std::string* release_inviter_name();
-  inline void set_allocated_inviter_name(::std::string* inviter_name);
-
-  // repeated uint32 previous_role = 6 [packed = true];
-  inline int previous_role_size() const;
-  inline void clear_previous_role();
-  static const int kPreviousRoleFieldNumber = 6;
-  inline ::google::protobuf::uint32 previous_role(int index) const;
-  inline void set_previous_role(int index, ::google::protobuf::uint32 value);
-  inline void add_previous_role(::google::protobuf::uint32 value);
-  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-      previous_role() const;
-  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-      mutable_previous_role();
-
-  // repeated uint32 desired_role = 7 [packed = true];
-  inline int desired_role_size() const;
-  inline void clear_desired_role();
-  static const int kDesiredRoleFieldNumber = 7;
-  inline ::google::protobuf::uint32 desired_role(int index) const;
-  inline void set_desired_role(int index, ::google::protobuf::uint32 value);
-  inline void add_desired_role(::google::protobuf::uint32 value);
-  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-      desired_role() const;
-  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-      mutable_desired_role();
-
-  // optional uint32 reason = 8;
-  inline bool has_reason() const;
-  inline void clear_reason();
-  static const int kReasonFieldNumber = 8;
-  inline ::google::protobuf::uint32 reason() const;
-  inline void set_reason(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.GenericInvitationRequest)
- private:
-  inline void set_has_agent_id();
-  inline void clear_has_agent_id();
-  inline void set_has_target_id();
-  inline void clear_has_target_id();
-  inline void set_has_invitation_id();
-  inline void clear_has_invitation_id();
-  inline void set_has_invitee_name();
-  inline void clear_has_invitee_name();
-  inline void set_has_inviter_name();
-  inline void clear_has_inviter_name();
-  inline void set_has_reason();
-  inline void clear_has_reason();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::bgs::protocol::EntityId* agent_id_;
-  ::bgs::protocol::EntityId* target_id_;
-  ::google::protobuf::uint64 invitation_id_;
-  ::std::string* invitee_name_;
-  ::std::string* inviter_name_;
-  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > previous_role_;
-  mutable int _previous_role_cached_byte_size_;
-  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > desired_role_;
-  mutable int _desired_role_cached_byte_size_;
-  ::google::protobuf::uint32 reason_;
-  friend void TC_PROTO_API protobuf_AddDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static GenericInvitationRequest* default_instance_;
-};
 // ===================================================================
 
 
@@ -1428,485 +746,9 @@ inline void Invitation::set_expiration_time(::google::protobuf::uint64 value) {
 
 // -------------------------------------------------------------------
 
-// InvitationSuggestion
-
-// optional .bgs.protocol.EntityId channel_id = 1;
-inline bool InvitationSuggestion::has_channel_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void InvitationSuggestion::set_has_channel_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void InvitationSuggestion::clear_has_channel_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void InvitationSuggestion::clear_channel_id() {
-  if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_channel_id();
-}
-inline const ::bgs::protocol::EntityId& InvitationSuggestion::channel_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.channel_id)
-  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
-}
-inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_channel_id() {
-  set_has_channel_id();
-  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.channel_id)
-  return channel_id_;
-}
-inline ::bgs::protocol::EntityId* InvitationSuggestion::release_channel_id() {
-  clear_has_channel_id();
-  ::bgs::protocol::EntityId* temp = channel_id_;
-  channel_id_ = NULL;
-  return temp;
-}
-inline void InvitationSuggestion::set_allocated_channel_id(::bgs::protocol::EntityId* channel_id) {
-  delete channel_id_;
-  channel_id_ = channel_id;
-  if (channel_id) {
-    set_has_channel_id();
-  } else {
-    clear_has_channel_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.channel_id)
-}
-
-// required .bgs.protocol.EntityId suggester_id = 2;
-inline bool InvitationSuggestion::has_suggester_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void InvitationSuggestion::set_has_suggester_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void InvitationSuggestion::clear_has_suggester_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void InvitationSuggestion::clear_suggester_id() {
-  if (suggester_id_ != NULL) suggester_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_suggester_id();
-}
-inline const ::bgs::protocol::EntityId& InvitationSuggestion::suggester_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggester_id)
-  return suggester_id_ != NULL ? *suggester_id_ : *default_instance_->suggester_id_;
-}
-inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_suggester_id() {
-  set_has_suggester_id();
-  if (suggester_id_ == NULL) suggester_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggester_id)
-  return suggester_id_;
-}
-inline ::bgs::protocol::EntityId* InvitationSuggestion::release_suggester_id() {
-  clear_has_suggester_id();
-  ::bgs::protocol::EntityId* temp = suggester_id_;
-  suggester_id_ = NULL;
-  return temp;
-}
-inline void InvitationSuggestion::set_allocated_suggester_id(::bgs::protocol::EntityId* suggester_id) {
-  delete suggester_id_;
-  suggester_id_ = suggester_id;
-  if (suggester_id) {
-    set_has_suggester_id();
-  } else {
-    clear_has_suggester_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggester_id)
-}
-
-// required .bgs.protocol.EntityId suggestee_id = 3;
-inline bool InvitationSuggestion::has_suggestee_id() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void InvitationSuggestion::set_has_suggestee_id() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void InvitationSuggestion::clear_has_suggestee_id() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void InvitationSuggestion::clear_suggestee_id() {
-  if (suggestee_id_ != NULL) suggestee_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_suggestee_id();
-}
-inline const ::bgs::protocol::EntityId& InvitationSuggestion::suggestee_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggestee_id)
-  return suggestee_id_ != NULL ? *suggestee_id_ : *default_instance_->suggestee_id_;
-}
-inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_suggestee_id() {
-  set_has_suggestee_id();
-  if (suggestee_id_ == NULL) suggestee_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggestee_id)
-  return suggestee_id_;
-}
-inline ::bgs::protocol::EntityId* InvitationSuggestion::release_suggestee_id() {
-  clear_has_suggestee_id();
-  ::bgs::protocol::EntityId* temp = suggestee_id_;
-  suggestee_id_ = NULL;
-  return temp;
-}
-inline void InvitationSuggestion::set_allocated_suggestee_id(::bgs::protocol::EntityId* suggestee_id) {
-  delete suggestee_id_;
-  suggestee_id_ = suggestee_id;
-  if (suggestee_id) {
-    set_has_suggestee_id();
-  } else {
-    clear_has_suggestee_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggestee_id)
-}
-
-// optional string suggester_name = 4;
-inline bool InvitationSuggestion::has_suggester_name() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void InvitationSuggestion::set_has_suggester_name() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void InvitationSuggestion::clear_has_suggester_name() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void InvitationSuggestion::clear_suggester_name() {
-  if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggester_name_->clear();
-  }
-  clear_has_suggester_name();
-}
-inline const ::std::string& InvitationSuggestion::suggester_name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggester_name)
-  return *suggester_name_;
-}
-inline void InvitationSuggestion::set_suggester_name(const ::std::string& value) {
-  set_has_suggester_name();
-  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggester_name_ = new ::std::string;
-  }
-  suggester_name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.InvitationSuggestion.suggester_name)
-}
-inline void InvitationSuggestion::set_suggester_name(const char* value) {
-  set_has_suggester_name();
-  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggester_name_ = new ::std::string;
-  }
-  suggester_name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationSuggestion.suggester_name)
-}
-inline void InvitationSuggestion::set_suggester_name(const char* value, size_t size) {
-  set_has_suggester_name();
-  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggester_name_ = new ::std::string;
-  }
-  suggester_name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationSuggestion.suggester_name)
-}
-inline ::std::string* InvitationSuggestion::mutable_suggester_name() {
-  set_has_suggester_name();
-  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggester_name_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggester_name)
-  return suggester_name_;
-}
-inline ::std::string* InvitationSuggestion::release_suggester_name() {
-  clear_has_suggester_name();
-  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = suggester_name_;
-    suggester_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void InvitationSuggestion::set_allocated_suggester_name(::std::string* suggester_name) {
-  if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete suggester_name_;
-  }
-  if (suggester_name) {
-    set_has_suggester_name();
-    suggester_name_ = suggester_name;
-  } else {
-    clear_has_suggester_name();
-    suggester_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggester_name)
-}
-
-// optional string suggestee_name = 5;
-inline bool InvitationSuggestion::has_suggestee_name() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void InvitationSuggestion::set_has_suggestee_name() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void InvitationSuggestion::clear_has_suggestee_name() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void InvitationSuggestion::clear_suggestee_name() {
-  if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggestee_name_->clear();
-  }
-  clear_has_suggestee_name();
-}
-inline const ::std::string& InvitationSuggestion::suggestee_name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggestee_name)
-  return *suggestee_name_;
-}
-inline void InvitationSuggestion::set_suggestee_name(const ::std::string& value) {
-  set_has_suggestee_name();
-  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggestee_name_ = new ::std::string;
-  }
-  suggestee_name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.InvitationSuggestion.suggestee_name)
-}
-inline void InvitationSuggestion::set_suggestee_name(const char* value) {
-  set_has_suggestee_name();
-  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggestee_name_ = new ::std::string;
-  }
-  suggestee_name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationSuggestion.suggestee_name)
-}
-inline void InvitationSuggestion::set_suggestee_name(const char* value, size_t size) {
-  set_has_suggestee_name();
-  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggestee_name_ = new ::std::string;
-  }
-  suggestee_name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationSuggestion.suggestee_name)
-}
-inline ::std::string* InvitationSuggestion::mutable_suggestee_name() {
-  set_has_suggestee_name();
-  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    suggestee_name_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggestee_name)
-  return suggestee_name_;
-}
-inline ::std::string* InvitationSuggestion::release_suggestee_name() {
-  clear_has_suggestee_name();
-  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = suggestee_name_;
-    suggestee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void InvitationSuggestion::set_allocated_suggestee_name(::std::string* suggestee_name) {
-  if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete suggestee_name_;
-  }
-  if (suggestee_name) {
-    set_has_suggestee_name();
-    suggestee_name_ = suggestee_name;
-  } else {
-    clear_has_suggestee_name();
-    suggestee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggestee_name)
-}
-
-// -------------------------------------------------------------------
-
-// InvitationTarget
-
-// optional .bgs.protocol.Identity identity = 1;
-inline bool InvitationTarget::has_identity() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void InvitationTarget::set_has_identity() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void InvitationTarget::clear_has_identity() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void InvitationTarget::clear_identity() {
-  if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
-  clear_has_identity();
-}
-inline const ::bgs::protocol::Identity& InvitationTarget::identity() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationTarget.identity)
-  return identity_ != NULL ? *identity_ : *default_instance_->identity_;
-}
-inline ::bgs::protocol::Identity* InvitationTarget::mutable_identity() {
-  set_has_identity();
-  if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationTarget.identity)
-  return identity_;
-}
-inline ::bgs::protocol::Identity* InvitationTarget::release_identity() {
-  clear_has_identity();
-  ::bgs::protocol::Identity* temp = identity_;
-  identity_ = NULL;
-  return temp;
-}
-inline void InvitationTarget::set_allocated_identity(::bgs::protocol::Identity* identity) {
-  delete identity_;
-  identity_ = identity;
-  if (identity) {
-    set_has_identity();
-  } else {
-    clear_has_identity();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationTarget.identity)
-}
-
-// optional string email = 2;
-inline bool InvitationTarget::has_email() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void InvitationTarget::set_has_email() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void InvitationTarget::clear_has_email() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void InvitationTarget::clear_email() {
-  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    email_->clear();
-  }
-  clear_has_email();
-}
-inline const ::std::string& InvitationTarget::email() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationTarget.email)
-  return *email_;
-}
-inline void InvitationTarget::set_email(const ::std::string& value) {
-  set_has_email();
-  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    email_ = new ::std::string;
-  }
-  email_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.InvitationTarget.email)
-}
-inline void InvitationTarget::set_email(const char* value) {
-  set_has_email();
-  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    email_ = new ::std::string;
-  }
-  email_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationTarget.email)
-}
-inline void InvitationTarget::set_email(const char* value, size_t size) {
-  set_has_email();
-  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    email_ = new ::std::string;
-  }
-  email_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationTarget.email)
-}
-inline ::std::string* InvitationTarget::mutable_email() {
-  set_has_email();
-  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    email_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationTarget.email)
-  return email_;
-}
-inline ::std::string* InvitationTarget::release_email() {
-  clear_has_email();
-  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = email_;
-    email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void InvitationTarget::set_allocated_email(::std::string* email) {
-  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete email_;
-  }
-  if (email) {
-    set_has_email();
-    email_ = email;
-  } else {
-    clear_has_email();
-    email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationTarget.email)
-}
-
-// optional string battle_tag = 3;
-inline bool InvitationTarget::has_battle_tag() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void InvitationTarget::set_has_battle_tag() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void InvitationTarget::clear_has_battle_tag() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void InvitationTarget::clear_battle_tag() {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_->clear();
-  }
-  clear_has_battle_tag();
-}
-inline const ::std::string& InvitationTarget::battle_tag() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationTarget.battle_tag)
-  return *battle_tag_;
-}
-inline void InvitationTarget::set_battle_tag(const ::std::string& value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.InvitationTarget.battle_tag)
-}
-inline void InvitationTarget::set_battle_tag(const char* value) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationTarget.battle_tag)
-}
-inline void InvitationTarget::set_battle_tag(const char* value, size_t size) {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationTarget.battle_tag)
-}
-inline ::std::string* InvitationTarget::mutable_battle_tag() {
-  set_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    battle_tag_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationTarget.battle_tag)
-  return battle_tag_;
-}
-inline ::std::string* InvitationTarget::release_battle_tag() {
-  clear_has_battle_tag();
-  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = battle_tag_;
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void InvitationTarget::set_allocated_battle_tag(::std::string* battle_tag) {
-  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete battle_tag_;
-  }
-  if (battle_tag) {
-    set_has_battle_tag();
-    battle_tag_ = battle_tag;
-  } else {
-    clear_has_battle_tag();
-    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationTarget.battle_tag)
-}
-
-// -------------------------------------------------------------------
-
 // InvitationParams
 
-// optional string invitation_message = 1;
+// optional string invitation_message = 1 [deprecated = true];
 inline bool InvitationParams::has_invitation_message() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
@@ -1982,7 +824,7 @@ inline void InvitationParams::set_allocated_invitation_message(::std::string* in
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationParams.invitation_message)
 }
 
-// optional uint64 expiration_time = 2 [default = 0];
+// optional uint64 expiration_time = 2;
 inline bool InvitationParams::has_expiration_time() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
@@ -2006,675 +848,6 @@ inline void InvitationParams::set_expiration_time(::google::protobuf::uint64 val
   // @@protoc_insertion_point(field_set:bgs.protocol.InvitationParams.expiration_time)
 }
 
-// -------------------------------------------------------------------
-
-// SendInvitationRequest
-
-// optional .bgs.protocol.Identity agent_identity = 1;
-inline bool SendInvitationRequest::has_agent_identity() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void SendInvitationRequest::set_has_agent_identity() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void SendInvitationRequest::clear_has_agent_identity() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void SendInvitationRequest::clear_agent_identity() {
-  if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
-  clear_has_agent_identity();
-}
-inline const ::bgs::protocol::Identity& SendInvitationRequest::agent_identity() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.agent_identity)
-  return agent_identity_ != NULL ? *agent_identity_ : *default_instance_->agent_identity_;
-}
-inline ::bgs::protocol::Identity* SendInvitationRequest::mutable_agent_identity() {
-  set_has_agent_identity();
-  if (agent_identity_ == NULL) agent_identity_ = new ::bgs::protocol::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.agent_identity)
-  return agent_identity_;
-}
-inline ::bgs::protocol::Identity* SendInvitationRequest::release_agent_identity() {
-  clear_has_agent_identity();
-  ::bgs::protocol::Identity* temp = agent_identity_;
-  agent_identity_ = NULL;
-  return temp;
-}
-inline void SendInvitationRequest::set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity) {
-  delete agent_identity_;
-  agent_identity_ = agent_identity;
-  if (agent_identity) {
-    set_has_agent_identity();
-  } else {
-    clear_has_agent_identity();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.agent_identity)
-}
-
-// required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
-inline bool SendInvitationRequest::has_target_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void SendInvitationRequest::set_has_target_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void SendInvitationRequest::clear_has_target_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void SendInvitationRequest::clear_target_id() {
-  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_target_id();
-}
-inline const ::bgs::protocol::EntityId& SendInvitationRequest::target_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.target_id)
-  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
-}
-inline ::bgs::protocol::EntityId* SendInvitationRequest::mutable_target_id() {
-  set_has_target_id();
-  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.target_id)
-  return target_id_;
-}
-inline ::bgs::protocol::EntityId* SendInvitationRequest::release_target_id() {
-  clear_has_target_id();
-  ::bgs::protocol::EntityId* temp = target_id_;
-  target_id_ = NULL;
-  return temp;
-}
-inline void SendInvitationRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
-  delete target_id_;
-  target_id_ = target_id;
-  if (target_id) {
-    set_has_target_id();
-  } else {
-    clear_has_target_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.target_id)
-}
-
-// required .bgs.protocol.InvitationParams params = 3;
-inline bool SendInvitationRequest::has_params() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void SendInvitationRequest::set_has_params() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void SendInvitationRequest::clear_has_params() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void SendInvitationRequest::clear_params() {
-  if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
-  clear_has_params();
-}
-inline const ::bgs::protocol::InvitationParams& SendInvitationRequest::params() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.params)
-  return params_ != NULL ? *params_ : *default_instance_->params_;
-}
-inline ::bgs::protocol::InvitationParams* SendInvitationRequest::mutable_params() {
-  set_has_params();
-  if (params_ == NULL) params_ = new ::bgs::protocol::InvitationParams;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.params)
-  return params_;
-}
-inline ::bgs::protocol::InvitationParams* SendInvitationRequest::release_params() {
-  clear_has_params();
-  ::bgs::protocol::InvitationParams* temp = params_;
-  params_ = NULL;
-  return temp;
-}
-inline void SendInvitationRequest::set_allocated_params(::bgs::protocol::InvitationParams* params) {
-  delete params_;
-  params_ = params;
-  if (params) {
-    set_has_params();
-  } else {
-    clear_has_params();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.params)
-}
-
-// optional .bgs.protocol.AccountInfo agent_info = 4;
-inline bool SendInvitationRequest::has_agent_info() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void SendInvitationRequest::set_has_agent_info() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void SendInvitationRequest::clear_has_agent_info() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void SendInvitationRequest::clear_agent_info() {
-  if (agent_info_ != NULL) agent_info_->::bgs::protocol::AccountInfo::Clear();
-  clear_has_agent_info();
-}
-inline const ::bgs::protocol::AccountInfo& SendInvitationRequest::agent_info() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.agent_info)
-  return agent_info_ != NULL ? *agent_info_ : *default_instance_->agent_info_;
-}
-inline ::bgs::protocol::AccountInfo* SendInvitationRequest::mutable_agent_info() {
-  set_has_agent_info();
-  if (agent_info_ == NULL) agent_info_ = new ::bgs::protocol::AccountInfo;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.agent_info)
-  return agent_info_;
-}
-inline ::bgs::protocol::AccountInfo* SendInvitationRequest::release_agent_info() {
-  clear_has_agent_info();
-  ::bgs::protocol::AccountInfo* temp = agent_info_;
-  agent_info_ = NULL;
-  return temp;
-}
-inline void SendInvitationRequest::set_allocated_agent_info(::bgs::protocol::AccountInfo* agent_info) {
-  delete agent_info_;
-  agent_info_ = agent_info;
-  if (agent_info) {
-    set_has_agent_info();
-  } else {
-    clear_has_agent_info();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.agent_info)
-}
-
-// optional .bgs.protocol.InvitationTarget target = 5;
-inline bool SendInvitationRequest::has_target() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void SendInvitationRequest::set_has_target() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void SendInvitationRequest::clear_has_target() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void SendInvitationRequest::clear_target() {
-  if (target_ != NULL) target_->::bgs::protocol::InvitationTarget::Clear();
-  clear_has_target();
-}
-inline const ::bgs::protocol::InvitationTarget& SendInvitationRequest::target() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.target)
-  return target_ != NULL ? *target_ : *default_instance_->target_;
-}
-inline ::bgs::protocol::InvitationTarget* SendInvitationRequest::mutable_target() {
-  set_has_target();
-  if (target_ == NULL) target_ = new ::bgs::protocol::InvitationTarget;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.target)
-  return target_;
-}
-inline ::bgs::protocol::InvitationTarget* SendInvitationRequest::release_target() {
-  clear_has_target();
-  ::bgs::protocol::InvitationTarget* temp = target_;
-  target_ = NULL;
-  return temp;
-}
-inline void SendInvitationRequest::set_allocated_target(::bgs::protocol::InvitationTarget* target) {
-  delete target_;
-  target_ = target;
-  if (target) {
-    set_has_target();
-  } else {
-    clear_has_target();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.target)
-}
-
-// -------------------------------------------------------------------
-
-// SendInvitationResponse
-
-// -------------------------------------------------------------------
-
-// UpdateInvitationRequest
-
-// optional .bgs.protocol.Identity agent_identity = 1;
-inline bool UpdateInvitationRequest::has_agent_identity() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void UpdateInvitationRequest::set_has_agent_identity() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void UpdateInvitationRequest::clear_has_agent_identity() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void UpdateInvitationRequest::clear_agent_identity() {
-  if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
-  clear_has_agent_identity();
-}
-inline const ::bgs::protocol::Identity& UpdateInvitationRequest::agent_identity() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.UpdateInvitationRequest.agent_identity)
-  return agent_identity_ != NULL ? *agent_identity_ : *default_instance_->agent_identity_;
-}
-inline ::bgs::protocol::Identity* UpdateInvitationRequest::mutable_agent_identity() {
-  set_has_agent_identity();
-  if (agent_identity_ == NULL) agent_identity_ = new ::bgs::protocol::Identity;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.UpdateInvitationRequest.agent_identity)
-  return agent_identity_;
-}
-inline ::bgs::protocol::Identity* UpdateInvitationRequest::release_agent_identity() {
-  clear_has_agent_identity();
-  ::bgs::protocol::Identity* temp = agent_identity_;
-  agent_identity_ = NULL;
-  return temp;
-}
-inline void UpdateInvitationRequest::set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity) {
-  delete agent_identity_;
-  agent_identity_ = agent_identity;
-  if (agent_identity) {
-    set_has_agent_identity();
-  } else {
-    clear_has_agent_identity();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.UpdateInvitationRequest.agent_identity)
-}
-
-// required fixed64 invitation_id = 2;
-inline bool UpdateInvitationRequest::has_invitation_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void UpdateInvitationRequest::set_has_invitation_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void UpdateInvitationRequest::clear_has_invitation_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void UpdateInvitationRequest::clear_invitation_id() {
-  invitation_id_ = GOOGLE_ULONGLONG(0);
-  clear_has_invitation_id();
-}
-inline ::google::protobuf::uint64 UpdateInvitationRequest::invitation_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.UpdateInvitationRequest.invitation_id)
-  return invitation_id_;
-}
-inline void UpdateInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
-  set_has_invitation_id();
-  invitation_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.UpdateInvitationRequest.invitation_id)
-}
-
-// required .bgs.protocol.InvitationParams params = 3;
-inline bool UpdateInvitationRequest::has_params() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void UpdateInvitationRequest::set_has_params() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void UpdateInvitationRequest::clear_has_params() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void UpdateInvitationRequest::clear_params() {
-  if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
-  clear_has_params();
-}
-inline const ::bgs::protocol::InvitationParams& UpdateInvitationRequest::params() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.UpdateInvitationRequest.params)
-  return params_ != NULL ? *params_ : *default_instance_->params_;
-}
-inline ::bgs::protocol::InvitationParams* UpdateInvitationRequest::mutable_params() {
-  set_has_params();
-  if (params_ == NULL) params_ = new ::bgs::protocol::InvitationParams;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.UpdateInvitationRequest.params)
-  return params_;
-}
-inline ::bgs::protocol::InvitationParams* UpdateInvitationRequest::release_params() {
-  clear_has_params();
-  ::bgs::protocol::InvitationParams* temp = params_;
-  params_ = NULL;
-  return temp;
-}
-inline void UpdateInvitationRequest::set_allocated_params(::bgs::protocol::InvitationParams* params) {
-  delete params_;
-  params_ = params;
-  if (params) {
-    set_has_params();
-  } else {
-    clear_has_params();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.UpdateInvitationRequest.params)
-}
-
-// -------------------------------------------------------------------
-
-// GenericInvitationRequest
-
-// optional .bgs.protocol.EntityId agent_id = 1;
-inline bool GenericInvitationRequest::has_agent_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void GenericInvitationRequest::set_has_agent_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void GenericInvitationRequest::clear_has_agent_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void GenericInvitationRequest::clear_agent_id() {
-  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_agent_id();
-}
-inline const ::bgs::protocol::EntityId& GenericInvitationRequest::agent_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.agent_id)
-  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
-}
-inline ::bgs::protocol::EntityId* GenericInvitationRequest::mutable_agent_id() {
-  set_has_agent_id();
-  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.agent_id)
-  return agent_id_;
-}
-inline ::bgs::protocol::EntityId* GenericInvitationRequest::release_agent_id() {
-  clear_has_agent_id();
-  ::bgs::protocol::EntityId* temp = agent_id_;
-  agent_id_ = NULL;
-  return temp;
-}
-inline void GenericInvitationRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
-  delete agent_id_;
-  agent_id_ = agent_id;
-  if (agent_id) {
-    set_has_agent_id();
-  } else {
-    clear_has_agent_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.agent_id)
-}
-
-// optional .bgs.protocol.EntityId target_id = 2;
-inline bool GenericInvitationRequest::has_target_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void GenericInvitationRequest::set_has_target_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void GenericInvitationRequest::clear_has_target_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void GenericInvitationRequest::clear_target_id() {
-  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
-  clear_has_target_id();
-}
-inline const ::bgs::protocol::EntityId& GenericInvitationRequest::target_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.target_id)
-  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
-}
-inline ::bgs::protocol::EntityId* GenericInvitationRequest::mutable_target_id() {
-  set_has_target_id();
-  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.target_id)
-  return target_id_;
-}
-inline ::bgs::protocol::EntityId* GenericInvitationRequest::release_target_id() {
-  clear_has_target_id();
-  ::bgs::protocol::EntityId* temp = target_id_;
-  target_id_ = NULL;
-  return temp;
-}
-inline void GenericInvitationRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
-  delete target_id_;
-  target_id_ = target_id;
-  if (target_id) {
-    set_has_target_id();
-  } else {
-    clear_has_target_id();
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.target_id)
-}
-
-// required fixed64 invitation_id = 3;
-inline bool GenericInvitationRequest::has_invitation_id() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void GenericInvitationRequest::set_has_invitation_id() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void GenericInvitationRequest::clear_has_invitation_id() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void GenericInvitationRequest::clear_invitation_id() {
-  invitation_id_ = GOOGLE_ULONGLONG(0);
-  clear_has_invitation_id();
-}
-inline ::google::protobuf::uint64 GenericInvitationRequest::invitation_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.invitation_id)
-  return invitation_id_;
-}
-inline void GenericInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
-  set_has_invitation_id();
-  invitation_id_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.invitation_id)
-}
-
-// optional string invitee_name = 4;
-inline bool GenericInvitationRequest::has_invitee_name() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void GenericInvitationRequest::set_has_invitee_name() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void GenericInvitationRequest::clear_has_invitee_name() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void GenericInvitationRequest::clear_invitee_name() {
-  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_name_->clear();
-  }
-  clear_has_invitee_name();
-}
-inline const ::std::string& GenericInvitationRequest::invitee_name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.invitee_name)
-  return *invitee_name_;
-}
-inline void GenericInvitationRequest::set_invitee_name(const ::std::string& value) {
-  set_has_invitee_name();
-  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_name_ = new ::std::string;
-  }
-  invitee_name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.invitee_name)
-}
-inline void GenericInvitationRequest::set_invitee_name(const char* value) {
-  set_has_invitee_name();
-  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_name_ = new ::std::string;
-  }
-  invitee_name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.GenericInvitationRequest.invitee_name)
-}
-inline void GenericInvitationRequest::set_invitee_name(const char* value, size_t size) {
-  set_has_invitee_name();
-  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_name_ = new ::std::string;
-  }
-  invitee_name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.GenericInvitationRequest.invitee_name)
-}
-inline ::std::string* GenericInvitationRequest::mutable_invitee_name() {
-  set_has_invitee_name();
-  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    invitee_name_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.invitee_name)
-  return invitee_name_;
-}
-inline ::std::string* GenericInvitationRequest::release_invitee_name() {
-  clear_has_invitee_name();
-  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = invitee_name_;
-    invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void GenericInvitationRequest::set_allocated_invitee_name(::std::string* invitee_name) {
-  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete invitee_name_;
-  }
-  if (invitee_name) {
-    set_has_invitee_name();
-    invitee_name_ = invitee_name;
-  } else {
-    clear_has_invitee_name();
-    invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.invitee_name)
-}
-
-// optional string inviter_name = 5;
-inline bool GenericInvitationRequest::has_inviter_name() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void GenericInvitationRequest::set_has_inviter_name() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void GenericInvitationRequest::clear_has_inviter_name() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void GenericInvitationRequest::clear_inviter_name() {
-  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_name_->clear();
-  }
-  clear_has_inviter_name();
-}
-inline const ::std::string& GenericInvitationRequest::inviter_name() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.inviter_name)
-  return *inviter_name_;
-}
-inline void GenericInvitationRequest::set_inviter_name(const ::std::string& value) {
-  set_has_inviter_name();
-  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_name_ = new ::std::string;
-  }
-  inviter_name_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.inviter_name)
-}
-inline void GenericInvitationRequest::set_inviter_name(const char* value) {
-  set_has_inviter_name();
-  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_name_ = new ::std::string;
-  }
-  inviter_name_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.GenericInvitationRequest.inviter_name)
-}
-inline void GenericInvitationRequest::set_inviter_name(const char* value, size_t size) {
-  set_has_inviter_name();
-  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_name_ = new ::std::string;
-  }
-  inviter_name_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.GenericInvitationRequest.inviter_name)
-}
-inline ::std::string* GenericInvitationRequest::mutable_inviter_name() {
-  set_has_inviter_name();
-  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    inviter_name_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.inviter_name)
-  return inviter_name_;
-}
-inline ::std::string* GenericInvitationRequest::release_inviter_name() {
-  clear_has_inviter_name();
-  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = inviter_name_;
-    inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void GenericInvitationRequest::set_allocated_inviter_name(::std::string* inviter_name) {
-  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete inviter_name_;
-  }
-  if (inviter_name) {
-    set_has_inviter_name();
-    inviter_name_ = inviter_name;
-  } else {
-    clear_has_inviter_name();
-    inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.inviter_name)
-}
-
-// repeated uint32 previous_role = 6 [packed = true];
-inline int GenericInvitationRequest::previous_role_size() const {
-  return previous_role_.size();
-}
-inline void GenericInvitationRequest::clear_previous_role() {
-  previous_role_.Clear();
-}
-inline ::google::protobuf::uint32 GenericInvitationRequest::previous_role(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.previous_role)
-  return previous_role_.Get(index);
-}
-inline void GenericInvitationRequest::set_previous_role(int index, ::google::protobuf::uint32 value) {
-  previous_role_.Set(index, value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.previous_role)
-}
-inline void GenericInvitationRequest::add_previous_role(::google::protobuf::uint32 value) {
-  previous_role_.Add(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.GenericInvitationRequest.previous_role)
-}
-inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-GenericInvitationRequest::previous_role() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.GenericInvitationRequest.previous_role)
-  return previous_role_;
-}
-inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-GenericInvitationRequest::mutable_previous_role() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.GenericInvitationRequest.previous_role)
-  return &previous_role_;
-}
-
-// repeated uint32 desired_role = 7 [packed = true];
-inline int GenericInvitationRequest::desired_role_size() const {
-  return desired_role_.size();
-}
-inline void GenericInvitationRequest::clear_desired_role() {
-  desired_role_.Clear();
-}
-inline ::google::protobuf::uint32 GenericInvitationRequest::desired_role(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.desired_role)
-  return desired_role_.Get(index);
-}
-inline void GenericInvitationRequest::set_desired_role(int index, ::google::protobuf::uint32 value) {
-  desired_role_.Set(index, value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.desired_role)
-}
-inline void GenericInvitationRequest::add_desired_role(::google::protobuf::uint32 value) {
-  desired_role_.Add(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.GenericInvitationRequest.desired_role)
-}
-inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-GenericInvitationRequest::desired_role() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.GenericInvitationRequest.desired_role)
-  return desired_role_;
-}
-inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-GenericInvitationRequest::mutable_desired_role() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.GenericInvitationRequest.desired_role)
-  return &desired_role_;
-}
-
-// optional uint32 reason = 8;
-inline bool GenericInvitationRequest::has_reason() const {
-  return (_has_bits_[0] & 0x00000080u) != 0;
-}
-inline void GenericInvitationRequest::set_has_reason() {
-  _has_bits_[0] |= 0x00000080u;
-}
-inline void GenericInvitationRequest::clear_has_reason() {
-  _has_bits_[0] &= ~0x00000080u;
-}
-inline void GenericInvitationRequest::clear_reason() {
-  reason_ = 0u;
-  clear_has_reason();
-}
-inline ::google::protobuf::uint32 GenericInvitationRequest::reason() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.reason)
-  return reason_;
-}
-inline void GenericInvitationRequest::set_reason(::google::protobuf::uint32 value) {
-  set_has_reason();
-  reason_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.reason)
-}
-
 
 // @@protoc_insertion_point(namespace_scope)
 
@@ -2685,6 +858,16 @@ inline void GenericInvitationRequest::set_reason(::google::protobuf::uint32 valu
 namespace google {
 namespace protobuf {
 
+template <> struct is_proto_enum< ::bgs::protocol::InvitationRemovedReason> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::InvitationRemovedReason>() {
+  return ::bgs::protocol::InvitationRemovedReason_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::SuggestionRemovedReason> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::SuggestionRemovedReason>() {
+  return ::bgs::protocol::SuggestionRemovedReason_descriptor();
+}
 
 }  // namespace google
 }  // namespace protobuf
diff --git a/src/server/proto/Client/message_types.pb.cc b/src/server/proto/Client/message_types.pb.cc
new file mode 100644
index 00000000000..051b087b60d
--- /dev/null
+++ b/src/server/proto/Client/message_types.pb.cc
@@ -0,0 +1,398 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: message_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "message_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* MessageId_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MessageId_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* TypingIndicator_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_message_5ftypes_2eproto() {
+  protobuf_AddDesc_message_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "message_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  MessageId_descriptor_ = file->message_type(0);
+  static const int MessageId_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageId, epoch_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageId, position_),
+  };
+  MessageId_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MessageId_descriptor_,
+      MessageId::default_instance_,
+      MessageId_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageId, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageId, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MessageId));
+  TypingIndicator_descriptor_ = file->enum_type(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_message_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MessageId_descriptor_, &MessageId::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_message_5ftypes_2eproto() {
+  delete MessageId::default_instance_;
+  delete MessageId_reflection_;
+}
+
+void protobuf_AddDesc_message_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\023message_types.proto\022\014bgs.protocol\",\n\tM"
+    "essageId\022\r\n\005epoch\030\001 \001(\004\022\020\n\010position\030\002 \001("
+    "\004*4\n\017TypingIndicator\022\020\n\014TYPING_START\020\000\022\017"
+    "\n\013TYPING_STOP\020\001B\002H\001", 139);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "message_types.proto", &protobuf_RegisterTypes);
+  MessageId::default_instance_ = new MessageId();
+  MessageId::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_message_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_message_5ftypes_2eproto {
+  StaticDescriptorInitializer_message_5ftypes_2eproto() {
+    protobuf_AddDesc_message_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_message_5ftypes_2eproto_;
+const ::google::protobuf::EnumDescriptor* TypingIndicator_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return TypingIndicator_descriptor_;
+}
+bool TypingIndicator_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MessageId::kEpochFieldNumber;
+const int MessageId::kPositionFieldNumber;
+#endif  // !_MSC_VER
+
+MessageId::MessageId()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.MessageId)
+}
+
+void MessageId::InitAsDefaultInstance() {
+}
+
+MessageId::MessageId(const MessageId& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.MessageId)
+}
+
+void MessageId::SharedCtor() {
+  _cached_size_ = 0;
+  epoch_ = GOOGLE_ULONGLONG(0);
+  position_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MessageId::~MessageId() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.MessageId)
+  SharedDtor();
+}
+
+void MessageId::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void MessageId::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MessageId::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MessageId_descriptor_;
+}
+
+const MessageId& MessageId::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_message_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+MessageId* MessageId::default_instance_ = NULL;
+
+MessageId* MessageId::New() const {
+  return new MessageId;
+}
+
+void MessageId::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<MessageId*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(epoch_, position_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MessageId::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.MessageId)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 epoch = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &epoch_)));
+          set_has_epoch();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_position;
+        break;
+      }
+
+      // optional uint64 position = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_position:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &position_)));
+          set_has_position();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.MessageId)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.MessageId)
+  return false;
+#undef DO_
+}
+
+void MessageId::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.MessageId)
+  // optional uint64 epoch = 1;
+  if (has_epoch()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->epoch(), output);
+  }
+
+  // optional uint64 position = 2;
+  if (has_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->position(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.MessageId)
+}
+
+::google::protobuf::uint8* MessageId::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.MessageId)
+  // optional uint64 epoch = 1;
+  if (has_epoch()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->epoch(), target);
+  }
+
+  // optional uint64 position = 2;
+  if (has_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->position(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.MessageId)
+  return target;
+}
+
+int MessageId::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 epoch = 1;
+    if (has_epoch()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->epoch());
+    }
+
+    // optional uint64 position = 2;
+    if (has_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->position());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MessageId::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MessageId* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MessageId*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MessageId::MergeFrom(const MessageId& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_epoch()) {
+      set_epoch(from.epoch());
+    }
+    if (from.has_position()) {
+      set_position(from.position());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MessageId::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MessageId::CopyFrom(const MessageId& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MessageId::IsInitialized() const {
+
+  return true;
+}
+
+void MessageId::Swap(MessageId* other) {
+  if (other != this) {
+    std::swap(epoch_, other->epoch_);
+    std::swap(position_, other->position_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MessageId::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MessageId_descriptor_;
+  metadata.reflection = MessageId_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/message_types.pb.h b/src/server/proto/Client/message_types.pb.h
new file mode 100644
index 00000000000..877202a114f
--- /dev/null
+++ b/src/server/proto/Client/message_types.pb.h
@@ -0,0 +1,229 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: message_types.proto
+
+#ifndef PROTOBUF_message_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_message_5ftypes_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_message_5ftypes_2eproto();
+void protobuf_AssignDesc_message_5ftypes_2eproto();
+void protobuf_ShutdownFile_message_5ftypes_2eproto();
+
+class MessageId;
+
+enum TypingIndicator {
+  TYPING_START = 0,
+  TYPING_STOP = 1
+};
+TC_PROTO_API bool TypingIndicator_IsValid(int value);
+const TypingIndicator TypingIndicator_MIN = TYPING_START;
+const TypingIndicator TypingIndicator_MAX = TYPING_STOP;
+const int TypingIndicator_ARRAYSIZE = TypingIndicator_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* TypingIndicator_descriptor();
+inline const ::std::string& TypingIndicator_Name(TypingIndicator value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    TypingIndicator_descriptor(), value);
+}
+inline bool TypingIndicator_Parse(
+    const ::std::string& name, TypingIndicator* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<TypingIndicator>(
+    TypingIndicator_descriptor(), name, value);
+}
+// ===================================================================
+
+class TC_PROTO_API MessageId : public ::google::protobuf::Message {
+ public:
+  MessageId();
+  virtual ~MessageId();
+
+  MessageId(const MessageId& from);
+
+  inline MessageId& operator=(const MessageId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MessageId& default_instance();
+
+  void Swap(MessageId* other);
+
+  // implements Message ----------------------------------------------
+
+  MessageId* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MessageId& from);
+  void MergeFrom(const MessageId& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 epoch = 1;
+  inline bool has_epoch() const;
+  inline void clear_epoch();
+  static const int kEpochFieldNumber = 1;
+  inline ::google::protobuf::uint64 epoch() const;
+  inline void set_epoch(::google::protobuf::uint64 value);
+
+  // optional uint64 position = 2;
+  inline bool has_position() const;
+  inline void clear_position();
+  static const int kPositionFieldNumber = 2;
+  inline ::google::protobuf::uint64 position() const;
+  inline void set_position(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.MessageId)
+ private:
+  inline void set_has_epoch();
+  inline void clear_has_epoch();
+  inline void set_has_position();
+  inline void clear_has_position();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 epoch_;
+  ::google::protobuf::uint64 position_;
+  friend void TC_PROTO_API protobuf_AddDesc_message_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_message_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_message_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static MessageId* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// MessageId
+
+// optional uint64 epoch = 1;
+inline bool MessageId::has_epoch() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MessageId::set_has_epoch() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MessageId::clear_has_epoch() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MessageId::clear_epoch() {
+  epoch_ = GOOGLE_ULONGLONG(0);
+  clear_has_epoch();
+}
+inline ::google::protobuf::uint64 MessageId::epoch() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.MessageId.epoch)
+  return epoch_;
+}
+inline void MessageId::set_epoch(::google::protobuf::uint64 value) {
+  set_has_epoch();
+  epoch_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.MessageId.epoch)
+}
+
+// optional uint64 position = 2;
+inline bool MessageId::has_position() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MessageId::set_has_position() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MessageId::clear_has_position() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MessageId::clear_position() {
+  position_ = GOOGLE_ULONGLONG(0);
+  clear_has_position();
+}
+inline ::google::protobuf::uint64 MessageId::position() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.MessageId.position)
+  return position_;
+}
+inline void MessageId::set_position(::google::protobuf::uint64 value) {
+  set_has_position();
+  position_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.MessageId.position)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::TypingIndicator> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::TypingIndicator>() {
+  return ::bgs::protocol::TypingIndicator_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_message_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/presence_listener.pb.cc b/src/server/proto/Client/presence_listener.pb.cc
new file mode 100644
index 00000000000..f26505ede53
--- /dev/null
+++ b/src/server/proto/Client/presence_listener.pb.cc
@@ -0,0 +1,773 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: presence_listener.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "presence_listener.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "Errors.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace presence {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* SubscribeNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StateChangedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StateChangedNotification_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* PresenceListener_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_presence_5flistener_2eproto() {
+  protobuf_AddDesc_presence_5flistener_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "presence_listener.proto");
+  GOOGLE_CHECK(file != NULL);
+  SubscribeNotification_descriptor_ = file->message_type(0);
+  static const int SubscribeNotification_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, state_),
+  };
+  SubscribeNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeNotification_descriptor_,
+      SubscribeNotification::default_instance_,
+      SubscribeNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeNotification));
+  StateChangedNotification_descriptor_ = file->message_type(1);
+  static const int StateChangedNotification_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, state_),
+  };
+  StateChangedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StateChangedNotification_descriptor_,
+      StateChangedNotification::default_instance_,
+      StateChangedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StateChangedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StateChangedNotification));
+  PresenceListener_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_presence_5flistener_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeNotification_descriptor_, &SubscribeNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StateChangedNotification_descriptor_, &StateChangedNotification::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_presence_5flistener_2eproto() {
+  delete SubscribeNotification::default_instance_;
+  delete SubscribeNotification_reflection_;
+  delete StateChangedNotification::default_instance_;
+  delete StateChangedNotification_reflection_;
+}
+
+void protobuf_AddDesc_presence_5flistener_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::presence::v1::protobuf_AddDesc_presence_5ftypes_2eproto();
+  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\027presence_listener.proto\022\030bgs.protocol."
+    "presence.v1\032\024presence_types.proto\032\023accou"
+    "nt_types.proto\032\017rpc_types.proto\"\212\001\n\025Subs"
+    "cribeNotification\0229\n\rsubscriber_id\030\001 \001(\013"
+    "2\".bgs.protocol.account.v1.AccountId\0226\n\005"
+    "state\030\002 \003(\0132\'.bgs.protocol.presence.v1.P"
+    "resenceState\"\215\001\n\030StateChangedNotificatio"
+    "n\0229\n\rsubscriber_id\030\001 \001(\0132\".bgs.protocol."
+    "account.v1.AccountId\0226\n\005state\030\002 \003(\0132\'.bg"
+    "s.protocol.presence.v1.PresenceState2\226\002\n"
+    "\020PresenceListener\022a\n\013OnSubscribe\022/.bgs.p"
+    "rotocol.presence.v1.SubscribeNotificatio"
+    "n\032\031.bgs.protocol.NO_RESPONSE\"\006\202\371+\002\010\001\022g\n\016"
+    "OnStateChanged\0222.bgs.protocol.presence.v"
+    "1.StateChangedNotification\032\031.bgs.protoco"
+    "l.NO_RESPONSE\"\006\202\371+\002\010\002\0326\202\371+,\n*bnet.protoc"
+    "ol.presence.v1.PresenceListener\212\371+\002\010\001B\002H"
+    "\001", 681);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "presence_listener.proto", &protobuf_RegisterTypes);
+  SubscribeNotification::default_instance_ = new SubscribeNotification();
+  StateChangedNotification::default_instance_ = new StateChangedNotification();
+  SubscribeNotification::default_instance_->InitAsDefaultInstance();
+  StateChangedNotification::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_presence_5flistener_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_presence_5flistener_2eproto {
+  StaticDescriptorInitializer_presence_5flistener_2eproto() {
+    protobuf_AddDesc_presence_5flistener_2eproto();
+  }
+} static_descriptor_initializer_presence_5flistener_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeNotification::kSubscriberIdFieldNumber;
+const int SubscribeNotification::kStateFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeNotification::SubscribeNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.SubscribeNotification)
+}
+
+void SubscribeNotification::InitAsDefaultInstance() {
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+SubscribeNotification::SubscribeNotification(const SubscribeNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.SubscribeNotification)
+}
+
+void SubscribeNotification::SharedCtor() {
+  _cached_size_ = 0;
+  subscriber_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeNotification::~SubscribeNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.SubscribeNotification)
+  SharedDtor();
+}
+
+void SubscribeNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete subscriber_id_;
+  }
+}
+
+void SubscribeNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeNotification_descriptor_;
+}
+
+const SubscribeNotification& SubscribeNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5flistener_2eproto();
+  return *default_instance_;
+}
+
+SubscribeNotification* SubscribeNotification::default_instance_ = NULL;
+
+SubscribeNotification* SubscribeNotification::New() const {
+  return new SubscribeNotification;
+}
+
+void SubscribeNotification::Clear() {
+  if (has_subscriber_id()) {
+    if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  }
+  state_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.SubscribeNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state;
+        break;
+      }
+
+      // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.SubscribeNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.SubscribeNotification)
+  return false;
+#undef DO_
+}
+
+void SubscribeNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.SubscribeNotification)
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->subscriber_id(), output);
+  }
+
+  // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+  for (int i = 0; i < this->state_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->state(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.SubscribeNotification)
+}
+
+::google::protobuf::uint8* SubscribeNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.SubscribeNotification)
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->subscriber_id(), target);
+  }
+
+  // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+  for (int i = 0; i < this->state_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->state(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.SubscribeNotification)
+  return target;
+}
+
+int SubscribeNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+  }
+  // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+  total_size += 1 * this->state_size();
+  for (int i = 0; i < this->state_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->state(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeNotification::MergeFrom(const SubscribeNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  state_.MergeFrom(from.state_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeNotification::CopyFrom(const SubscribeNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeNotification::IsInitialized() const {
+
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->state())) return false;
+  return true;
+}
+
+void SubscribeNotification::Swap(SubscribeNotification* other) {
+  if (other != this) {
+    std::swap(subscriber_id_, other->subscriber_id_);
+    state_.Swap(&other->state_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeNotification_descriptor_;
+  metadata.reflection = SubscribeNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int StateChangedNotification::kSubscriberIdFieldNumber;
+const int StateChangedNotification::kStateFieldNumber;
+#endif  // !_MSC_VER
+
+StateChangedNotification::StateChangedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.StateChangedNotification)
+}
+
+void StateChangedNotification::InitAsDefaultInstance() {
+  subscriber_id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+StateChangedNotification::StateChangedNotification(const StateChangedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.StateChangedNotification)
+}
+
+void StateChangedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  subscriber_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StateChangedNotification::~StateChangedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.StateChangedNotification)
+  SharedDtor();
+}
+
+void StateChangedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete subscriber_id_;
+  }
+}
+
+void StateChangedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StateChangedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StateChangedNotification_descriptor_;
+}
+
+const StateChangedNotification& StateChangedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5flistener_2eproto();
+  return *default_instance_;
+}
+
+StateChangedNotification* StateChangedNotification::default_instance_ = NULL;
+
+StateChangedNotification* StateChangedNotification::New() const {
+  return new StateChangedNotification;
+}
+
+void StateChangedNotification::Clear() {
+  if (has_subscriber_id()) {
+    if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  }
+  state_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StateChangedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.StateChangedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state;
+        break;
+      }
+
+      // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.StateChangedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.StateChangedNotification)
+  return false;
+#undef DO_
+}
+
+void StateChangedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.StateChangedNotification)
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->subscriber_id(), output);
+  }
+
+  // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+  for (int i = 0; i < this->state_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->state(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.StateChangedNotification)
+}
+
+::google::protobuf::uint8* StateChangedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.StateChangedNotification)
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->subscriber_id(), target);
+  }
+
+  // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+  for (int i = 0; i < this->state_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->state(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.StateChangedNotification)
+  return target;
+}
+
+int StateChangedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber_id());
+    }
+
+  }
+  // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+  total_size += 1 * this->state_size();
+  for (int i = 0; i < this->state_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->state(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StateChangedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StateChangedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StateChangedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StateChangedNotification::MergeFrom(const StateChangedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  state_.MergeFrom(from.state_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_subscriber_id()) {
+      mutable_subscriber_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.subscriber_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StateChangedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StateChangedNotification::CopyFrom(const StateChangedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StateChangedNotification::IsInitialized() const {
+
+  if (has_subscriber_id()) {
+    if (!this->subscriber_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->state())) return false;
+  return true;
+}
+
+void StateChangedNotification::Swap(StateChangedNotification* other) {
+  if (other != this) {
+    std::swap(subscriber_id_, other->subscriber_id_);
+    state_.Swap(&other->state_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StateChangedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StateChangedNotification_descriptor_;
+  metadata.reflection = StateChangedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+PresenceListener::PresenceListener(bool use_original_hash) : service_hash_(use_original_hash ? OriginalHash::value : NameHash::value) {
+}
+
+PresenceListener::~PresenceListener() {
+}
+
+google::protobuf::ServiceDescriptor const* PresenceListener::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PresenceListener_descriptor_;
+}
+
+void PresenceListener::OnSubscribe(::bgs::protocol::presence::v1::SubscribeNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceListener.OnSubscribe(bgs.protocol.presence.v1.SubscribeNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request);
+}
+
+void PresenceListener::OnStateChanged(::bgs::protocol::presence::v1::StateChangedNotification const* request) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceListener.OnStateChanged(bgs.protocol.presence.v1.StateChangedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request);
+}
+
+void PresenceListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::presence::v1::SubscribeNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceListener.OnSubscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnSubscribe(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceListener.OnSubscribe(bgs.protocol.presence.v1.SubscribeNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::presence::v1::StateChangedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceListener.OnStateChanged server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      uint32 status = HandleOnStateChanged(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceListener.OnStateChanged(bgs.protocol.presence.v1.StateChangedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 PresenceListener::HandleOnSubscribe(::bgs::protocol::presence::v1::SubscribeNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceListener.OnSubscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 PresenceListener::HandleOnStateChanged(::bgs::protocol::presence::v1::StateChangedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceListener.OnStateChanged({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace presence
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/presence_listener.pb.h b/src/server/proto/Client/presence_listener.pb.h
new file mode 100644
index 00000000000..c26ce820f77
--- /dev/null
+++ b/src/server/proto/Client/presence_listener.pb.h
@@ -0,0 +1,441 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: presence_listener.proto
+
+#ifndef PROTOBUF_presence_5flistener_2eproto__INCLUDED
+#define PROTOBUF_presence_5flistener_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "presence_types.pb.h"
+#include "account_types.pb.h"
+#include "rpc_types.pb.h"
+#include "ServiceBase.h"
+#include "MessageBuffer.h"
+#include <functional>
+#include <type_traits>
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace presence {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_presence_5flistener_2eproto();
+void protobuf_AssignDesc_presence_5flistener_2eproto();
+void protobuf_ShutdownFile_presence_5flistener_2eproto();
+
+class SubscribeNotification;
+class StateChangedNotification;
+
+// ===================================================================
+
+class TC_PROTO_API SubscribeNotification : public ::google::protobuf::Message {
+ public:
+  SubscribeNotification();
+  virtual ~SubscribeNotification();
+
+  SubscribeNotification(const SubscribeNotification& from);
+
+  inline SubscribeNotification& operator=(const SubscribeNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SubscribeNotification& default_instance();
+
+  void Swap(SubscribeNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeNotification& from);
+  void MergeFrom(const SubscribeNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+  inline int state_size() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 2;
+  inline const ::bgs::protocol::presence::v1::PresenceState& state(int index) const;
+  inline ::bgs::protocol::presence::v1::PresenceState* mutable_state(int index);
+  inline ::bgs::protocol::presence::v1::PresenceState* add_state();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState >&
+      state() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState >*
+      mutable_state();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.SubscribeNotification)
+ private:
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState > state_;
+  friend void TC_PROTO_API protobuf_AddDesc_presence_5flistener_2eproto();
+  friend void protobuf_AssignDesc_presence_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_presence_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API StateChangedNotification : public ::google::protobuf::Message {
+ public:
+  StateChangedNotification();
+  virtual ~StateChangedNotification();
+
+  StateChangedNotification(const StateChangedNotification& from);
+
+  inline StateChangedNotification& operator=(const StateChangedNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StateChangedNotification& default_instance();
+
+  void Swap(StateChangedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  StateChangedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StateChangedNotification& from);
+  void MergeFrom(const StateChangedNotification& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& subscriber_id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_subscriber_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_subscriber_id();
+  inline void set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id);
+
+  // repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+  inline int state_size() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 2;
+  inline const ::bgs::protocol::presence::v1::PresenceState& state(int index) const;
+  inline ::bgs::protocol::presence::v1::PresenceState* mutable_state(int index);
+  inline ::bgs::protocol::presence::v1::PresenceState* add_state();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState >&
+      state() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState >*
+      mutable_state();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.StateChangedNotification)
+ private:
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* subscriber_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState > state_;
+  friend void TC_PROTO_API protobuf_AddDesc_presence_5flistener_2eproto();
+  friend void protobuf_AssignDesc_presence_5flistener_2eproto();
+  friend void protobuf_ShutdownFile_presence_5flistener_2eproto();
+
+  void InitAsDefaultInstance();
+  static StateChangedNotification* default_instance_;
+};
+// ===================================================================
+
+class TC_PROTO_API PresenceListener : public ServiceBase
+{
+ public:
+
+  explicit PresenceListener(bool use_original_hash);
+  virtual ~PresenceListener();
+
+  typedef std::integral_constant<uint32, 0x890AB85Fu> OriginalHash;
+  typedef std::integral_constant<uint32, 0xE8836F50u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void OnSubscribe(::bgs::protocol::presence::v1::SubscribeNotification const* request);
+  void OnStateChanged(::bgs::protocol::presence::v1::StateChangedNotification const* request);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleOnSubscribe(::bgs::protocol::presence::v1::SubscribeNotification const* request);
+  virtual uint32 HandleOnStateChanged(::bgs::protocol::presence::v1::StateChangedNotification const* request);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PresenceListener);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// SubscribeNotification
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+inline bool SubscribeNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& SubscribeNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SubscribeNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* SubscribeNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void SubscribeNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.SubscribeNotification.subscriber_id)
+}
+
+// repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+inline int SubscribeNotification::state_size() const {
+  return state_.size();
+}
+inline void SubscribeNotification::clear_state() {
+  state_.Clear();
+}
+inline const ::bgs::protocol::presence::v1::PresenceState& SubscribeNotification::state(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeNotification.state)
+  return state_.Get(index);
+}
+inline ::bgs::protocol::presence::v1::PresenceState* SubscribeNotification::mutable_state(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeNotification.state)
+  return state_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::PresenceState* SubscribeNotification::add_state() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.SubscribeNotification.state)
+  return state_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState >&
+SubscribeNotification::state() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.SubscribeNotification.state)
+  return state_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState >*
+SubscribeNotification::mutable_state() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.SubscribeNotification.state)
+  return &state_;
+}
+
+// -------------------------------------------------------------------
+
+// StateChangedNotification
+
+// optional .bgs.protocol.account.v1.AccountId subscriber_id = 1;
+inline bool StateChangedNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StateChangedNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StateChangedNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StateChangedNotification::clear_subscriber_id() {
+  if (subscriber_id_ != NULL) subscriber_id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_subscriber_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& StateChangedNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.StateChangedNotification.subscriber_id)
+  return subscriber_id_ != NULL ? *subscriber_id_ : *default_instance_->subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StateChangedNotification::mutable_subscriber_id() {
+  set_has_subscriber_id();
+  if (subscriber_id_ == NULL) subscriber_id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.StateChangedNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* StateChangedNotification::release_subscriber_id() {
+  clear_has_subscriber_id();
+  ::bgs::protocol::account::v1::AccountId* temp = subscriber_id_;
+  subscriber_id_ = NULL;
+  return temp;
+}
+inline void StateChangedNotification::set_allocated_subscriber_id(::bgs::protocol::account::v1::AccountId* subscriber_id) {
+  delete subscriber_id_;
+  subscriber_id_ = subscriber_id;
+  if (subscriber_id) {
+    set_has_subscriber_id();
+  } else {
+    clear_has_subscriber_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.StateChangedNotification.subscriber_id)
+}
+
+// repeated .bgs.protocol.presence.v1.PresenceState state = 2;
+inline int StateChangedNotification::state_size() const {
+  return state_.size();
+}
+inline void StateChangedNotification::clear_state() {
+  state_.Clear();
+}
+inline const ::bgs::protocol::presence::v1::PresenceState& StateChangedNotification::state(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.StateChangedNotification.state)
+  return state_.Get(index);
+}
+inline ::bgs::protocol::presence::v1::PresenceState* StateChangedNotification::mutable_state(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.StateChangedNotification.state)
+  return state_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::PresenceState* StateChangedNotification::add_state() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.StateChangedNotification.state)
+  return state_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState >&
+StateChangedNotification::state() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.StateChangedNotification.state)
+  return state_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::PresenceState >*
+StateChangedNotification::mutable_state() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.StateChangedNotification.state)
+  return &state_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace presence
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_presence_5flistener_2eproto__INCLUDED
diff --git a/src/server/proto/Client/presence_service.pb.cc b/src/server/proto/Client/presence_service.pb.cc
index 15cd49ec612..0eb0d475ae9 100644
--- a/src/server/proto/Client/presence_service.pb.cc
+++ b/src/server/proto/Client/presence_service.pb.cc
@@ -48,12 +48,18 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* OwnershipRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   OwnershipRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* MigrateOlympusCustomMessageRequest_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* BatchSubscribeRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
-  MigrateOlympusCustomMessageRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* MigrateOlympusCustomMessageResponse_descriptor_ = NULL;
+  BatchSubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscribeResult_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
-  MigrateOlympusCustomMessageResponse_reflection_ = NULL;
+  SubscribeResult_reflection_ = NULL;
+const ::google::protobuf::Descriptor* BatchSubscribeResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BatchSubscribeResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* BatchUnsubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BatchUnsubscribeRequest_reflection_ = NULL;
 const ::google::protobuf::ServiceDescriptor* PresenceService_descriptor_ = NULL;
 
 }  // namespace
@@ -71,7 +77,7 @@ void protobuf_AssignDesc_presence_5fservice_2eproto() {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, entity_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, object_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, program_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, flag_public_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, key_),
   };
   SubscribeRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -182,37 +188,73 @@ void protobuf_AssignDesc_presence_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(OwnershipRequest));
-  MigrateOlympusCustomMessageRequest_descriptor_ = file->message_type(7);
-  static const int MigrateOlympusCustomMessageRequest_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MigrateOlympusCustomMessageRequest, account_),
+  BatchSubscribeRequest_descriptor_ = file->message_type(7);
+  static const int BatchSubscribeRequest_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeRequest, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeRequest, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeRequest, key_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeRequest, object_id_),
   };
-  MigrateOlympusCustomMessageRequest_reflection_ =
+  BatchSubscribeRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
-      MigrateOlympusCustomMessageRequest_descriptor_,
-      MigrateOlympusCustomMessageRequest::default_instance_,
-      MigrateOlympusCustomMessageRequest_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MigrateOlympusCustomMessageRequest, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MigrateOlympusCustomMessageRequest, _unknown_fields_),
+      BatchSubscribeRequest_descriptor_,
+      BatchSubscribeRequest::default_instance_,
+      BatchSubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeRequest, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(MigrateOlympusCustomMessageRequest));
-  MigrateOlympusCustomMessageResponse_descriptor_ = file->message_type(8);
-  static const int MigrateOlympusCustomMessageResponse_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MigrateOlympusCustomMessageResponse, custom_message_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MigrateOlympusCustomMessageResponse, custom_message_time_epoch_),
+      sizeof(BatchSubscribeRequest));
+  SubscribeResult_descriptor_ = file->message_type(8);
+  static const int SubscribeResult_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResult, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResult, result_),
   };
-  MigrateOlympusCustomMessageResponse_reflection_ =
+  SubscribeResult_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
-      MigrateOlympusCustomMessageResponse_descriptor_,
-      MigrateOlympusCustomMessageResponse::default_instance_,
-      MigrateOlympusCustomMessageResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MigrateOlympusCustomMessageResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MigrateOlympusCustomMessageResponse, _unknown_fields_),
+      SubscribeResult_descriptor_,
+      SubscribeResult::default_instance_,
+      SubscribeResult_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResult, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResult, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(MigrateOlympusCustomMessageResponse));
+      sizeof(SubscribeResult));
+  BatchSubscribeResponse_descriptor_ = file->message_type(9);
+  static const int BatchSubscribeResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeResponse, subscribe_failed_),
+  };
+  BatchSubscribeResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BatchSubscribeResponse_descriptor_,
+      BatchSubscribeResponse::default_instance_,
+      BatchSubscribeResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchSubscribeResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BatchSubscribeResponse));
+  BatchUnsubscribeRequest_descriptor_ = file->message_type(10);
+  static const int BatchUnsubscribeRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchUnsubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchUnsubscribeRequest, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchUnsubscribeRequest, object_id_),
+  };
+  BatchUnsubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BatchUnsubscribeRequest_descriptor_,
+      BatchUnsubscribeRequest::default_instance_,
+      BatchUnsubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchUnsubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BatchUnsubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BatchUnsubscribeRequest));
   PresenceService_descriptor_ = file->service(0);
 }
 
@@ -241,9 +283,13 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     OwnershipRequest_descriptor_, &OwnershipRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    MigrateOlympusCustomMessageRequest_descriptor_, &MigrateOlympusCustomMessageRequest::default_instance());
+    BatchSubscribeRequest_descriptor_, &BatchSubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeResult_descriptor_, &SubscribeResult::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BatchSubscribeResponse_descriptor_, &BatchSubscribeResponse::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    MigrateOlympusCustomMessageResponse_descriptor_, &MigrateOlympusCustomMessageResponse::default_instance());
+    BatchUnsubscribeRequest_descriptor_, &BatchUnsubscribeRequest::default_instance());
 }
 
 }  // namespace
@@ -263,10 +309,14 @@ void protobuf_ShutdownFile_presence_5fservice_2eproto() {
   delete QueryResponse_reflection_;
   delete OwnershipRequest::default_instance_;
   delete OwnershipRequest_reflection_;
-  delete MigrateOlympusCustomMessageRequest::default_instance_;
-  delete MigrateOlympusCustomMessageRequest_reflection_;
-  delete MigrateOlympusCustomMessageResponse::default_instance_;
-  delete MigrateOlympusCustomMessageResponse_reflection_;
+  delete BatchSubscribeRequest::default_instance_;
+  delete BatchSubscribeRequest_reflection_;
+  delete SubscribeResult::default_instance_;
+  delete SubscribeResult_reflection_;
+  delete BatchSubscribeResponse::default_instance_;
+  delete BatchSubscribeResponse_reflection_;
+  delete BatchUnsubscribeRequest::default_instance_;
+  delete BatchUnsubscribeRequest_reflection_;
 }
 
 void protobuf_AddDesc_presence_5fservice_2eproto() {
@@ -281,53 +331,66 @@ void protobuf_AddDesc_presence_5fservice_2eproto() {
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\026presence_service.proto\022\030bgs.protocol.p"
     "resence.v1\032\022entity_types.proto\032\024presence"
-    "_types.proto\032\017rpc_types.proto\"\252\001\n\020Subscr"
+    "_types.proto\032\017rpc_types.proto\"\331\001\n\020Subscr"
     "ibeRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.proto"
     "col.EntityId\022)\n\tentity_id\030\002 \002(\0132\026.bgs.pr"
-    "otocol.EntityId\022\021\n\tobject_id\030\003 \002(\004\022\017\n\007pr"
-    "ogram\030\004 \003(\007\022\035\n\013flag_public\030\005 \001(\010:\004trueB\002"
-    "\030\001\"I\n\034SubscribeNotificationRequest\022)\n\ten"
-    "tity_id\030\001 \002(\0132\026.bgs.protocol.EntityId\"|\n"
-    "\022UnsubscribeRequest\022(\n\010agent_id\030\001 \001(\0132\026."
-    "bgs.protocol.EntityId\022)\n\tentity_id\030\002 \002(\013"
-    "2\026.bgs.protocol.EntityId\022\021\n\tobject_id\030\003 "
-    "\001(\004\"\301\001\n\rUpdateRequest\022)\n\tentity_id\030\001 \002(\013"
-    "2\026.bgs.protocol.EntityId\022A\n\017field_operat"
-    "ion\030\002 \003(\0132(.bgs.protocol.presence.v1.Fie"
-    "ldOperation\022\030\n\tno_create\030\003 \001(\010:\005false\022(\n"
+    "otocol.EntityId\022\021\n\tobject_id\030\003 \002(\004\022\035\n\007pr"
+    "ogram\030\004 \003(\007B\014\212\371+\010*\006\n\004\010\001\020d\022>\n\003key\030\006 \003(\0132\""
+    ".bgs.protocol.presence.v1.FieldKeyB\r\212\371+\t"
+    "*\007\n\005\010\001\020\364\003\"I\n\034SubscribeNotificationReques"
+    "t\022)\n\tentity_id\030\001 \002(\0132\026.bgs.protocol.Enti"
+    "tyId\"|\n\022UnsubscribeRequest\022(\n\010agent_id\030\001"
+    " \001(\0132\026.bgs.protocol.EntityId\022)\n\tentity_i"
+    "d\030\002 \002(\0132\026.bgs.protocol.EntityId\022\021\n\tobjec"
+    "t_id\030\003 \001(\004\"\272\001\n\rUpdateRequest\022)\n\tentity_i"
+    "d\030\001 \002(\0132\026.bgs.protocol.EntityId\022A\n\017field"
+    "_operation\030\002 \003(\0132(.bgs.protocol.presence"
+    ".v1.FieldOperation\022\021\n\tno_create\030\003 \001(\010\022(\n"
     "\010agent_id\030\004 \001(\0132\026.bgs.protocol.EntityId\""
     "\224\001\n\014QueryRequest\022)\n\tentity_id\030\001 \002(\0132\026.bg"
     "s.protocol.EntityId\022/\n\003key\030\002 \003(\0132\".bgs.p"
     "rotocol.presence.v1.FieldKey\022(\n\010agent_id"
     "\030\003 \001(\0132\026.bgs.protocol.EntityId\"\?\n\rQueryR"
     "esponse\022.\n\005field\030\002 \003(\0132\037.bgs.protocol.pr"
-    "esence.v1.Field\"_\n\020OwnershipRequest\022)\n\te"
-    "ntity_id\030\001 \002(\0132\026.bgs.protocol.EntityId\022 "
-    "\n\021release_ownership\030\002 \001(\010:\005false\"M\n\"Migr"
-    "ateOlympusCustomMessageRequest\022\'\n\007accoun"
-    "t\030\001 \002(\0132\026.bgs.protocol.EntityId\"`\n#Migra"
-    "teOlympusCustomMessageResponse\022\026\n\016custom"
-    "_message\030\001 \001(\t\022!\n\031custom_message_time_ep"
-    "och\030\002 \001(\r2\376\005\n\017PresenceService\022S\n\tSubscri"
-    "be\022*.bgs.protocol.presence.v1.SubscribeR"
-    "equest\032\024.bgs.protocol.NoData\"\004\200\265\030\001\022W\n\013Un"
-    "subscribe\022,.bgs.protocol.presence.v1.Uns"
-    "ubscribeRequest\032\024.bgs.protocol.NoData\"\004\200"
-    "\265\030\002\022M\n\006Update\022\'.bgs.protocol.presence.v1"
-    ".UpdateRequest\032\024.bgs.protocol.NoData\"\004\200\265"
-    "\030\003\022^\n\005Query\022&.bgs.protocol.presence.v1.Q"
-    "ueryRequest\032\'.bgs.protocol.presence.v1.Q"
-    "ueryResponse\"\004\200\265\030\004\022S\n\tOwnership\022*.bgs.pr"
-    "otocol.presence.v1.OwnershipRequest\032\024.bg"
-    "s.protocol.NoData\"\004\200\265\030\005\022k\n\025SubscribeNoti"
-    "fication\0226.bgs.protocol.presence.v1.Subs"
-    "cribeNotificationRequest\032\024.bgs.protocol."
-    "NoData\"\004\200\265\030\007\022\240\001\n\033MigrateOlympusCustomMes"
-    "sage\022<.bgs.protocol.presence.v1.MigrateO"
-    "lympusCustomMessageRequest\032=.bgs.protoco"
-    "l.presence.v1.MigrateOlympusCustomMessag"
-    "eResponse\"\004\200\265\030\010\032)\312>&bnet.protocol.presen"
-    "ce.PresenceServiceB\005H\001\200\001\000", 1945);
+    "esence.v1.Field\"X\n\020OwnershipRequest\022)\n\te"
+    "ntity_id\030\001 \002(\0132\026.bgs.protocol.EntityId\022\031"
+    "\n\021release_ownership\030\002 \001(\010\"\355\001\n\025BatchSubsc"
+    "ribeRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.prot"
+    "ocol.EntityId\0228\n\tentity_id\030\002 \003(\0132\026.bgs.p"
+    "rotocol.EntityIdB\r\212\371+\t*\007\n\005\010\001\020\372\001\022\035\n\007progr"
+    "am\030\003 \003(\007B\014\212\371+\010*\006\n\004\010\001\020d\022>\n\003key\030\004 \003(\0132\".bg"
+    "s.protocol.presence.v1.FieldKeyB\r\212\371+\t*\007\n"
+    "\005\010\001\020\364\003\022\021\n\tobject_id\030\005 \001(\004\"L\n\017SubscribeRe"
+    "sult\022)\n\tentity_id\030\001 \001(\0132\026.bgs.protocol.E"
+    "ntityId\022\016\n\006result\030\002 \001(\r\"]\n\026BatchSubscrib"
+    "eResponse\022C\n\020subscribe_failed\030\001 \003(\0132).bg"
+    "s.protocol.presence.v1.SubscribeResult\"\220"
+    "\001\n\027BatchUnsubscribeRequest\022(\n\010agent_id\030\001"
+    " \001(\0132\026.bgs.protocol.EntityId\0228\n\tentity_i"
+    "d\030\002 \003(\0132\026.bgs.protocol.EntityIdB\r\212\371+\t*\007\n"
+    "\005\010\001\020\372\001\022\021\n\tobject_id\030\003 \001(\0042\334\006\n\017PresenceSe"
+    "rvice\022U\n\tSubscribe\022*.bgs.protocol.presen"
+    "ce.v1.SubscribeRequest\032\024.bgs.protocol.No"
+    "Data\"\006\202\371+\002\010\001\022Y\n\013Unsubscribe\022,.bgs.protoc"
+    "ol.presence.v1.UnsubscribeRequest\032\024.bgs."
+    "protocol.NoData\"\006\202\371+\002\010\002\022O\n\006Update\022\'.bgs."
+    "protocol.presence.v1.UpdateRequest\032\024.bgs"
+    ".protocol.NoData\"\006\202\371+\002\010\003\022`\n\005Query\022&.bgs."
+    "protocol.presence.v1.QueryRequest\032\'.bgs."
+    "protocol.presence.v1.QueryResponse\"\006\202\371+\002"
+    "\010\004\022U\n\tOwnership\022*.bgs.protocol.presence."
+    "v1.OwnershipRequest\032\024.bgs.protocol.NoDat"
+    "a\"\006\202\371+\002\010\005\022m\n\025SubscribeNotification\0226.bgs"
+    ".protocol.presence.v1.SubscribeNotificat"
+    "ionRequest\032\024.bgs.protocol.NoData\"\006\202\371+\002\010\007"
+    "\022{\n\016BatchSubscribe\022/.bgs.protocol.presen"
+    "ce.v1.BatchSubscribeRequest\0320.bgs.protoc"
+    "ol.presence.v1.BatchSubscribeResponse\"\006\202"
+    "\371+\002\010\010\022c\n\020BatchUnsubscribe\0221.bgs.protocol"
+    ".presence.v1.BatchUnsubscribeRequest\032\024.b"
+    "gs.protocol.NoData\"\006\202\371+\002\010\t\032<\202\371+2\n&bnet.p"
+    "rotocol.presence.PresenceService*\010presen"
+    "ce\212\371+\002\020\001B\005H\001\200\001\000", 2455);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "presence_service.proto", &protobuf_RegisterTypes);
   SubscribeRequest::default_instance_ = new SubscribeRequest();
@@ -337,8 +400,10 @@ void protobuf_AddDesc_presence_5fservice_2eproto() {
   QueryRequest::default_instance_ = new QueryRequest();
   QueryResponse::default_instance_ = new QueryResponse();
   OwnershipRequest::default_instance_ = new OwnershipRequest();
-  MigrateOlympusCustomMessageRequest::default_instance_ = new MigrateOlympusCustomMessageRequest();
-  MigrateOlympusCustomMessageResponse::default_instance_ = new MigrateOlympusCustomMessageResponse();
+  BatchSubscribeRequest::default_instance_ = new BatchSubscribeRequest();
+  SubscribeResult::default_instance_ = new SubscribeResult();
+  BatchSubscribeResponse::default_instance_ = new BatchSubscribeResponse();
+  BatchUnsubscribeRequest::default_instance_ = new BatchUnsubscribeRequest();
   SubscribeRequest::default_instance_->InitAsDefaultInstance();
   SubscribeNotificationRequest::default_instance_->InitAsDefaultInstance();
   UnsubscribeRequest::default_instance_->InitAsDefaultInstance();
@@ -346,8 +411,10 @@ void protobuf_AddDesc_presence_5fservice_2eproto() {
   QueryRequest::default_instance_->InitAsDefaultInstance();
   QueryResponse::default_instance_->InitAsDefaultInstance();
   OwnershipRequest::default_instance_->InitAsDefaultInstance();
-  MigrateOlympusCustomMessageRequest::default_instance_->InitAsDefaultInstance();
-  MigrateOlympusCustomMessageResponse::default_instance_->InitAsDefaultInstance();
+  BatchSubscribeRequest::default_instance_->InitAsDefaultInstance();
+  SubscribeResult::default_instance_->InitAsDefaultInstance();
+  BatchSubscribeResponse::default_instance_->InitAsDefaultInstance();
+  BatchUnsubscribeRequest::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_presence_5fservice_2eproto);
 }
 
@@ -365,7 +432,7 @@ const int SubscribeRequest::kAgentIdFieldNumber;
 const int SubscribeRequest::kEntityIdFieldNumber;
 const int SubscribeRequest::kObjectIdFieldNumber;
 const int SubscribeRequest::kProgramFieldNumber;
-const int SubscribeRequest::kFlagPublicFieldNumber;
+const int SubscribeRequest::kKeyFieldNumber;
 #endif  // !_MSC_VER
 
 SubscribeRequest::SubscribeRequest()
@@ -391,7 +458,6 @@ void SubscribeRequest::SharedCtor() {
   agent_id_ = NULL;
   entity_id_ = NULL;
   object_id_ = GOOGLE_ULONGLONG(0);
-  flag_public_ = true;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -429,7 +495,7 @@ SubscribeRequest* SubscribeRequest::New() const {
 }
 
 void SubscribeRequest::Clear() {
-  if (_has_bits_[0 / 32] & 23) {
+  if (_has_bits_[0 / 32] & 7) {
     if (has_agent_id()) {
       if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
     }
@@ -437,9 +503,9 @@ void SubscribeRequest::Clear() {
       if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
     }
     object_id_ = GOOGLE_ULONGLONG(0);
-    flag_public_ = true;
   }
   program_.Clear();
+  key_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
@@ -509,21 +575,20 @@ bool SubscribeRequest::MergePartialFromCodedStream(
           goto handle_unusual;
         }
         if (input->ExpectTag(37)) goto parse_program;
-        if (input->ExpectTag(40)) goto parse_flag_public;
+        if (input->ExpectTag(50)) goto parse_key;
         break;
       }
 
-      // optional bool flag_public = 5 [default = true, deprecated = true];
-      case 5: {
-        if (tag == 40) {
-         parse_flag_public:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &flag_public_)));
-          set_has_flag_public();
+      // repeated .bgs.protocol.presence.v1.FieldKey key = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_key:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_key()));
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(50)) goto parse_key;
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -576,9 +641,10 @@ void SubscribeRequest::SerializeWithCachedSizes(
       4, this->program(i), output);
   }
 
-  // optional bool flag_public = 5 [default = true, deprecated = true];
-  if (has_flag_public()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->flag_public(), output);
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 6;
+  for (int i = 0; i < this->key_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->key(i), output);
   }
 
   if (!unknown_fields().empty()) {
@@ -616,9 +682,11 @@ void SubscribeRequest::SerializeWithCachedSizes(
       WriteFixed32ToArray(4, this->program(i), target);
   }
 
-  // optional bool flag_public = 5 [default = true, deprecated = true];
-  if (has_flag_public()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->flag_public(), target);
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 6;
+  for (int i = 0; i < this->key_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->key(i), target);
   }
 
   if (!unknown_fields().empty()) {
@@ -654,11 +722,6 @@ int SubscribeRequest::ByteSize() const {
           this->object_id());
     }
 
-    // optional bool flag_public = 5 [default = true, deprecated = true];
-    if (has_flag_public()) {
-      total_size += 1 + 1;
-    }
-
   }
   // repeated fixed32 program = 4;
   {
@@ -667,6 +730,14 @@ int SubscribeRequest::ByteSize() const {
     total_size += 1 * this->program_size() + data_size;
   }
 
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 6;
+  total_size += 1 * this->key_size();
+  for (int i = 0; i < this->key_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->key(i));
+  }
+
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -693,6 +764,7 @@ void SubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
 void SubscribeRequest::MergeFrom(const SubscribeRequest& from) {
   GOOGLE_CHECK_NE(&from, this);
   program_.MergeFrom(from.program_);
+  key_.MergeFrom(from.key_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
     if (from.has_agent_id()) {
       mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
@@ -703,9 +775,6 @@ void SubscribeRequest::MergeFrom(const SubscribeRequest& from) {
     if (from.has_object_id()) {
       set_object_id(from.object_id());
     }
-    if (from.has_flag_public()) {
-      set_flag_public(from.flag_public());
-    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -731,6 +800,7 @@ bool SubscribeRequest::IsInitialized() const {
   if (has_entity_id()) {
     if (!this->entity_id().IsInitialized()) return false;
   }
+  if (!::google::protobuf::internal::AllAreInitialized(this->key())) return false;
   return true;
 }
 
@@ -740,7 +810,7 @@ void SubscribeRequest::Swap(SubscribeRequest* other) {
     std::swap(entity_id_, other->entity_id_);
     std::swap(object_id_, other->object_id_);
     program_.Swap(&other->program_);
-    std::swap(flag_public_, other->flag_public_);
+    key_.Swap(&other->key_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -1425,7 +1495,7 @@ bool UpdateRequest::MergePartialFromCodedStream(
         break;
       }
 
-      // optional bool no_create = 3 [default = false];
+      // optional bool no_create = 3;
       case 3: {
         if (tag == 24) {
          parse_no_create:
@@ -1490,7 +1560,7 @@ void UpdateRequest::SerializeWithCachedSizes(
       2, this->field_operation(i), output);
   }
 
-  // optional bool no_create = 3 [default = false];
+  // optional bool no_create = 3;
   if (has_no_create()) {
     ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->no_create(), output);
   }
@@ -1525,7 +1595,7 @@ void UpdateRequest::SerializeWithCachedSizes(
         2, this->field_operation(i), target);
   }
 
-  // optional bool no_create = 3 [default = false];
+  // optional bool no_create = 3;
   if (has_no_create()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->no_create(), target);
   }
@@ -1556,7 +1626,7 @@ int UpdateRequest::ByteSize() const {
           this->entity_id());
     }
 
-    // optional bool no_create = 3 [default = false];
+    // optional bool no_create = 3;
     if (has_no_create()) {
       total_size += 1 + 1;
     }
@@ -2299,7 +2369,7 @@ bool OwnershipRequest::MergePartialFromCodedStream(
         break;
       }
 
-      // optional bool release_ownership = 2 [default = false];
+      // optional bool release_ownership = 2;
       case 2: {
         if (tag == 16) {
          parse_release_ownership:
@@ -2345,7 +2415,7 @@ void OwnershipRequest::SerializeWithCachedSizes(
       1, this->entity_id(), output);
   }
 
-  // optional bool release_ownership = 2 [default = false];
+  // optional bool release_ownership = 2;
   if (has_release_ownership()) {
     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->release_ownership(), output);
   }
@@ -2367,7 +2437,7 @@ void OwnershipRequest::SerializeWithCachedSizes(
         1, this->entity_id(), target);
   }
 
-  // optional bool release_ownership = 2 [default = false];
+  // optional bool release_ownership = 2;
   if (has_release_ownership()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->release_ownership(), target);
   }
@@ -2391,7 +2461,7 @@ int OwnershipRequest::ByteSize() const {
           this->entity_id());
     }
 
-    // optional bool release_ownership = 2 [default = false];
+    // optional bool release_ownership = 2;
     if (has_release_ownership()) {
       total_size += 1 + 1;
     }
@@ -2476,87 +2546,160 @@ void OwnershipRequest::Swap(OwnershipRequest* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int MigrateOlympusCustomMessageRequest::kAccountFieldNumber;
+const int BatchSubscribeRequest::kAgentIdFieldNumber;
+const int BatchSubscribeRequest::kEntityIdFieldNumber;
+const int BatchSubscribeRequest::kProgramFieldNumber;
+const int BatchSubscribeRequest::kKeyFieldNumber;
+const int BatchSubscribeRequest::kObjectIdFieldNumber;
 #endif  // !_MSC_VER
 
-MigrateOlympusCustomMessageRequest::MigrateOlympusCustomMessageRequest()
+BatchSubscribeRequest::BatchSubscribeRequest()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.BatchSubscribeRequest)
 }
 
-void MigrateOlympusCustomMessageRequest::InitAsDefaultInstance() {
-  account_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+void BatchSubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
 }
 
-MigrateOlympusCustomMessageRequest::MigrateOlympusCustomMessageRequest(const MigrateOlympusCustomMessageRequest& from)
+BatchSubscribeRequest::BatchSubscribeRequest(const BatchSubscribeRequest& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.BatchSubscribeRequest)
 }
 
-void MigrateOlympusCustomMessageRequest::SharedCtor() {
+void BatchSubscribeRequest::SharedCtor() {
   _cached_size_ = 0;
-  account_ = NULL;
+  agent_id_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-MigrateOlympusCustomMessageRequest::~MigrateOlympusCustomMessageRequest() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
+BatchSubscribeRequest::~BatchSubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.BatchSubscribeRequest)
   SharedDtor();
 }
 
-void MigrateOlympusCustomMessageRequest::SharedDtor() {
+void BatchSubscribeRequest::SharedDtor() {
   if (this != default_instance_) {
-    delete account_;
+    delete agent_id_;
   }
 }
 
-void MigrateOlympusCustomMessageRequest::SetCachedSize(int size) const {
+void BatchSubscribeRequest::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* MigrateOlympusCustomMessageRequest::descriptor() {
+const ::google::protobuf::Descriptor* BatchSubscribeRequest::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return MigrateOlympusCustomMessageRequest_descriptor_;
+  return BatchSubscribeRequest_descriptor_;
 }
 
-const MigrateOlympusCustomMessageRequest& MigrateOlympusCustomMessageRequest::default_instance() {
+const BatchSubscribeRequest& BatchSubscribeRequest::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
   return *default_instance_;
 }
 
-MigrateOlympusCustomMessageRequest* MigrateOlympusCustomMessageRequest::default_instance_ = NULL;
+BatchSubscribeRequest* BatchSubscribeRequest::default_instance_ = NULL;
 
-MigrateOlympusCustomMessageRequest* MigrateOlympusCustomMessageRequest::New() const {
-  return new MigrateOlympusCustomMessageRequest;
+BatchSubscribeRequest* BatchSubscribeRequest::New() const {
+  return new BatchSubscribeRequest;
 }
 
-void MigrateOlympusCustomMessageRequest::Clear() {
-  if (has_account()) {
-    if (account_ != NULL) account_->::bgs::protocol::EntityId::Clear();
+void BatchSubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 17) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
   }
+  entity_id_.Clear();
+  program_.Clear();
+  key_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool MigrateOlympusCustomMessageRequest::MergePartialFromCodedStream(
+bool BatchSubscribeRequest::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.BatchSubscribeRequest)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required .bgs.protocol.EntityId account = 1;
+      // optional .bgs.protocol.EntityId agent_id = 1;
       case 1: {
         if (tag == 10) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_account()));
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_entity_id;
+        break;
+      }
+
+      // repeated .bgs.protocol.EntityId entity_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_entity_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_entity_id;
+        if (input->ExpectTag(29)) goto parse_program;
+        break;
+      }
+
+      // repeated fixed32 program = 3;
+      case 3: {
+        if (tag == 29) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 1, 29, input, this->mutable_program())));
+        } else if (tag == 26) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, this->mutable_program())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(29)) goto parse_program;
+        if (input->ExpectTag(34)) goto parse_key;
+        break;
+      }
+
+      // repeated .bgs.protocol.presence.v1.FieldKey key = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_key:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_key;
+        if (input->ExpectTag(40)) goto parse_object_id;
+        break;
+      }
+
+      // optional uint64 object_id = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
         } else {
           goto handle_unusual;
         }
@@ -2578,60 +2721,138 @@ bool MigrateOlympusCustomMessageRequest::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.BatchSubscribeRequest)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.BatchSubscribeRequest)
   return false;
 #undef DO_
 }
 
-void MigrateOlympusCustomMessageRequest::SerializeWithCachedSizes(
+void BatchSubscribeRequest::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
-  // required .bgs.protocol.EntityId account = 1;
-  if (has_account()) {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.BatchSubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // repeated .bgs.protocol.EntityId entity_id = 2;
+  for (int i = 0; i < this->entity_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->entity_id(i), output);
+  }
+
+  // repeated fixed32 program = 3;
+  for (int i = 0; i < this->program_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(
+      3, this->program(i), output);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 4;
+  for (int i = 0; i < this->key_size(); i++) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->account(), output);
+      4, this->key(i), output);
+  }
+
+  // optional uint64 object_id = 5;
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->object_id(), output);
   }
 
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.BatchSubscribeRequest)
 }
 
-::google::protobuf::uint8* MigrateOlympusCustomMessageRequest::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* BatchSubscribeRequest::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
-  // required .bgs.protocol.EntityId account = 1;
-  if (has_account()) {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.BatchSubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        1, this->account(), target);
+        1, this->agent_id(), target);
+  }
+
+  // repeated .bgs.protocol.EntityId entity_id = 2;
+  for (int i = 0; i < this->entity_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->entity_id(i), target);
+  }
+
+  // repeated fixed32 program = 3;
+  for (int i = 0; i < this->program_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteFixed32ToArray(3, this->program(i), target);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 4;
+  for (int i = 0; i < this->key_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->key(i), target);
+  }
+
+  // optional uint64 object_id = 5;
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->object_id(), target);
   }
 
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.BatchSubscribeRequest)
   return target;
 }
 
-int MigrateOlympusCustomMessageRequest::ByteSize() const {
+int BatchSubscribeRequest::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required .bgs.protocol.EntityId account = 1;
-    if (has_account()) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->account());
+          this->agent_id());
+    }
+
+    // optional uint64 object_id = 5;
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
     }
 
   }
+  // repeated .bgs.protocol.EntityId entity_id = 2;
+  total_size += 1 * this->entity_id_size();
+  for (int i = 0; i < this->entity_id_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->entity_id(i));
+  }
+
+  // repeated fixed32 program = 3;
+  {
+    int data_size = 0;
+    data_size = 4 * this->program_size();
+    total_size += 1 * this->program_size() + data_size;
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 4;
+  total_size += 1 * this->key_size();
+  for (int i = 0; i < this->key_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->key(i));
+  }
+
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -2643,10 +2864,10 @@ int MigrateOlympusCustomMessageRequest::ByteSize() const {
   return total_size;
 }
 
-void MigrateOlympusCustomMessageRequest::MergeFrom(const ::google::protobuf::Message& from) {
+void BatchSubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const MigrateOlympusCustomMessageRequest* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const MigrateOlympusCustomMessageRequest*>(
+  const BatchSubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BatchSubscribeRequest*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -2655,51 +2876,62 @@ void MigrateOlympusCustomMessageRequest::MergeFrom(const ::google::protobuf::Mes
   }
 }
 
-void MigrateOlympusCustomMessageRequest::MergeFrom(const MigrateOlympusCustomMessageRequest& from) {
+void BatchSubscribeRequest::MergeFrom(const BatchSubscribeRequest& from) {
   GOOGLE_CHECK_NE(&from, this);
+  entity_id_.MergeFrom(from.entity_id_);
+  program_.MergeFrom(from.program_);
+  key_.MergeFrom(from.key_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_account()) {
-      mutable_account()->::bgs::protocol::EntityId::MergeFrom(from.account());
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void MigrateOlympusCustomMessageRequest::CopyFrom(const ::google::protobuf::Message& from) {
+void BatchSubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void MigrateOlympusCustomMessageRequest::CopyFrom(const MigrateOlympusCustomMessageRequest& from) {
+void BatchSubscribeRequest::CopyFrom(const BatchSubscribeRequest& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool MigrateOlympusCustomMessageRequest::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+bool BatchSubscribeRequest::IsInitialized() const {
 
-  if (has_account()) {
-    if (!this->account().IsInitialized()) return false;
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
   }
+  if (!::google::protobuf::internal::AllAreInitialized(this->entity_id())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->key())) return false;
   return true;
 }
 
-void MigrateOlympusCustomMessageRequest::Swap(MigrateOlympusCustomMessageRequest* other) {
+void BatchSubscribeRequest::Swap(BatchSubscribeRequest* other) {
   if (other != this) {
-    std::swap(account_, other->account_);
+    std::swap(agent_id_, other->agent_id_);
+    entity_id_.Swap(&other->entity_id_);
+    program_.Swap(&other->program_);
+    key_.Swap(&other->key_);
+    std::swap(object_id_, other->object_id_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata MigrateOlympusCustomMessageRequest::GetMetadata() const {
+::google::protobuf::Metadata BatchSubscribeRequest::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = MigrateOlympusCustomMessageRequest_descriptor_;
-  metadata.reflection = MigrateOlympusCustomMessageRequest_reflection_;
+  metadata.descriptor = BatchSubscribeRequest_descriptor_;
+  metadata.reflection = BatchSubscribeRequest_reflection_;
   return metadata;
 }
 
@@ -2707,115 +2939,107 @@ void MigrateOlympusCustomMessageRequest::Swap(MigrateOlympusCustomMessageRequest
 // ===================================================================
 
 #ifndef _MSC_VER
-const int MigrateOlympusCustomMessageResponse::kCustomMessageFieldNumber;
-const int MigrateOlympusCustomMessageResponse::kCustomMessageTimeEpochFieldNumber;
+const int SubscribeResult::kEntityIdFieldNumber;
+const int SubscribeResult::kResultFieldNumber;
 #endif  // !_MSC_VER
 
-MigrateOlympusCustomMessageResponse::MigrateOlympusCustomMessageResponse()
+SubscribeResult::SubscribeResult()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.SubscribeResult)
 }
 
-void MigrateOlympusCustomMessageResponse::InitAsDefaultInstance() {
+void SubscribeResult::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
 }
 
-MigrateOlympusCustomMessageResponse::MigrateOlympusCustomMessageResponse(const MigrateOlympusCustomMessageResponse& from)
+SubscribeResult::SubscribeResult(const SubscribeResult& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.SubscribeResult)
 }
 
-void MigrateOlympusCustomMessageResponse::SharedCtor() {
-  ::google::protobuf::internal::GetEmptyString();
+void SubscribeResult::SharedCtor() {
   _cached_size_ = 0;
-  custom_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  custom_message_time_epoch_ = 0u;
+  entity_id_ = NULL;
+  result_ = 0u;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-MigrateOlympusCustomMessageResponse::~MigrateOlympusCustomMessageResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
+SubscribeResult::~SubscribeResult() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.SubscribeResult)
   SharedDtor();
 }
 
-void MigrateOlympusCustomMessageResponse::SharedDtor() {
-  if (custom_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete custom_message_;
-  }
+void SubscribeResult::SharedDtor() {
   if (this != default_instance_) {
+    delete entity_id_;
   }
 }
 
-void MigrateOlympusCustomMessageResponse::SetCachedSize(int size) const {
+void SubscribeResult::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* MigrateOlympusCustomMessageResponse::descriptor() {
+const ::google::protobuf::Descriptor* SubscribeResult::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return MigrateOlympusCustomMessageResponse_descriptor_;
+  return SubscribeResult_descriptor_;
 }
 
-const MigrateOlympusCustomMessageResponse& MigrateOlympusCustomMessageResponse::default_instance() {
+const SubscribeResult& SubscribeResult::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
   return *default_instance_;
 }
 
-MigrateOlympusCustomMessageResponse* MigrateOlympusCustomMessageResponse::default_instance_ = NULL;
+SubscribeResult* SubscribeResult::default_instance_ = NULL;
 
-MigrateOlympusCustomMessageResponse* MigrateOlympusCustomMessageResponse::New() const {
-  return new MigrateOlympusCustomMessageResponse;
+SubscribeResult* SubscribeResult::New() const {
+  return new SubscribeResult;
 }
 
-void MigrateOlympusCustomMessageResponse::Clear() {
+void SubscribeResult::Clear() {
   if (_has_bits_[0 / 32] & 3) {
-    if (has_custom_message()) {
-      if (custom_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        custom_message_->clear();
-      }
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
     }
-    custom_message_time_epoch_ = 0u;
+    result_ = 0u;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool MigrateOlympusCustomMessageResponse::MergePartialFromCodedStream(
+bool SubscribeResult::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.SubscribeResult)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string custom_message = 1;
+      // optional .bgs.protocol.EntityId entity_id = 1;
       case 1: {
         if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_custom_message()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->custom_message().data(), this->custom_message().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "custom_message");
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(16)) goto parse_custom_message_time_epoch;
+        if (input->ExpectTag(16)) goto parse_result;
         break;
       }
 
-      // optional uint32 custom_message_time_epoch = 2;
+      // optional uint32 result = 2;
       case 2: {
         if (tag == 16) {
-         parse_custom_message_time_epoch:
+         parse_result:
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &custom_message_time_epoch_)));
-          set_has_custom_message_time_epoch();
+                 input, &result_)));
+          set_has_result();
         } else {
           goto handle_unusual;
         }
@@ -2837,82 +3061,74 @@ bool MigrateOlympusCustomMessageResponse::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.SubscribeResult)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.SubscribeResult)
   return false;
 #undef DO_
 }
 
-void MigrateOlympusCustomMessageResponse::SerializeWithCachedSizes(
+void SubscribeResult::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
-  // optional string custom_message = 1;
-  if (has_custom_message()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->custom_message().data(), this->custom_message().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "custom_message");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->custom_message(), output);
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.SubscribeResult)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
   }
 
-  // optional uint32 custom_message_time_epoch = 2;
-  if (has_custom_message_time_epoch()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->custom_message_time_epoch(), output);
+  // optional uint32 result = 2;
+  if (has_result()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->result(), output);
   }
 
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.SubscribeResult)
 }
 
-::google::protobuf::uint8* MigrateOlympusCustomMessageResponse::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* SubscribeResult::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
-  // optional string custom_message = 1;
-  if (has_custom_message()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->custom_message().data(), this->custom_message().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "custom_message");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->custom_message(), target);
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.SubscribeResult)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
   }
 
-  // optional uint32 custom_message_time_epoch = 2;
-  if (has_custom_message_time_epoch()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->custom_message_time_epoch(), target);
+  // optional uint32 result = 2;
+  if (has_result()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->result(), target);
   }
 
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.SubscribeResult)
   return target;
 }
 
-int MigrateOlympusCustomMessageResponse::ByteSize() const {
+int SubscribeResult::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional string custom_message = 1;
-    if (has_custom_message()) {
+    // optional .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->custom_message());
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
     }
 
-    // optional uint32 custom_message_time_epoch = 2;
-    if (has_custom_message_time_epoch()) {
+    // optional uint32 result = 2;
+    if (has_result()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->custom_message_time_epoch());
+          this->result());
     }
 
   }
@@ -2927,10 +3143,10 @@ int MigrateOlympusCustomMessageResponse::ByteSize() const {
   return total_size;
 }
 
-void MigrateOlympusCustomMessageResponse::MergeFrom(const ::google::protobuf::Message& from) {
+void SubscribeResult::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const MigrateOlympusCustomMessageResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const MigrateOlympusCustomMessageResponse*>(
+  const SubscribeResult* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeResult*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -2939,51 +3155,585 @@ void MigrateOlympusCustomMessageResponse::MergeFrom(const ::google::protobuf::Me
   }
 }
 
-void MigrateOlympusCustomMessageResponse::MergeFrom(const MigrateOlympusCustomMessageResponse& from) {
+void SubscribeResult::MergeFrom(const SubscribeResult& from) {
   GOOGLE_CHECK_NE(&from, this);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_custom_message()) {
-      set_custom_message(from.custom_message());
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
     }
-    if (from.has_custom_message_time_epoch()) {
-      set_custom_message_time_epoch(from.custom_message_time_epoch());
+    if (from.has_result()) {
+      set_result(from.result());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void MigrateOlympusCustomMessageResponse::CopyFrom(const ::google::protobuf::Message& from) {
+void SubscribeResult::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void MigrateOlympusCustomMessageResponse::CopyFrom(const MigrateOlympusCustomMessageResponse& from) {
+void SubscribeResult::CopyFrom(const SubscribeResult& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool MigrateOlympusCustomMessageResponse::IsInitialized() const {
+bool SubscribeResult::IsInitialized() const {
 
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
   return true;
 }
 
-void MigrateOlympusCustomMessageResponse::Swap(MigrateOlympusCustomMessageResponse* other) {
+void SubscribeResult::Swap(SubscribeResult* other) {
   if (other != this) {
-    std::swap(custom_message_, other->custom_message_);
-    std::swap(custom_message_time_epoch_, other->custom_message_time_epoch_);
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(result_, other->result_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata MigrateOlympusCustomMessageResponse::GetMetadata() const {
+::google::protobuf::Metadata SubscribeResult::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = MigrateOlympusCustomMessageResponse_descriptor_;
-  metadata.reflection = MigrateOlympusCustomMessageResponse_reflection_;
+  metadata.descriptor = SubscribeResult_descriptor_;
+  metadata.reflection = SubscribeResult_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BatchSubscribeResponse::kSubscribeFailedFieldNumber;
+#endif  // !_MSC_VER
+
+BatchSubscribeResponse::BatchSubscribeResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.BatchSubscribeResponse)
+}
+
+void BatchSubscribeResponse::InitAsDefaultInstance() {
+}
+
+BatchSubscribeResponse::BatchSubscribeResponse(const BatchSubscribeResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.BatchSubscribeResponse)
+}
+
+void BatchSubscribeResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BatchSubscribeResponse::~BatchSubscribeResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.BatchSubscribeResponse)
+  SharedDtor();
+}
+
+void BatchSubscribeResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void BatchSubscribeResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BatchSubscribeResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BatchSubscribeResponse_descriptor_;
+}
+
+const BatchSubscribeResponse& BatchSubscribeResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
+  return *default_instance_;
+}
+
+BatchSubscribeResponse* BatchSubscribeResponse::default_instance_ = NULL;
+
+BatchSubscribeResponse* BatchSubscribeResponse::New() const {
+  return new BatchSubscribeResponse;
+}
+
+void BatchSubscribeResponse::Clear() {
+  subscribe_failed_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BatchSubscribeResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.BatchSubscribeResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.presence.v1.SubscribeResult subscribe_failed = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_subscribe_failed:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_subscribe_failed()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_subscribe_failed;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.BatchSubscribeResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.BatchSubscribeResponse)
+  return false;
+#undef DO_
+}
+
+void BatchSubscribeResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.BatchSubscribeResponse)
+  // repeated .bgs.protocol.presence.v1.SubscribeResult subscribe_failed = 1;
+  for (int i = 0; i < this->subscribe_failed_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->subscribe_failed(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.BatchSubscribeResponse)
+}
+
+::google::protobuf::uint8* BatchSubscribeResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.BatchSubscribeResponse)
+  // repeated .bgs.protocol.presence.v1.SubscribeResult subscribe_failed = 1;
+  for (int i = 0; i < this->subscribe_failed_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->subscribe_failed(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.BatchSubscribeResponse)
+  return target;
+}
+
+int BatchSubscribeResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.presence.v1.SubscribeResult subscribe_failed = 1;
+  total_size += 1 * this->subscribe_failed_size();
+  for (int i = 0; i < this->subscribe_failed_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->subscribe_failed(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BatchSubscribeResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BatchSubscribeResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BatchSubscribeResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BatchSubscribeResponse::MergeFrom(const BatchSubscribeResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  subscribe_failed_.MergeFrom(from.subscribe_failed_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BatchSubscribeResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BatchSubscribeResponse::CopyFrom(const BatchSubscribeResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BatchSubscribeResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->subscribe_failed())) return false;
+  return true;
+}
+
+void BatchSubscribeResponse::Swap(BatchSubscribeResponse* other) {
+  if (other != this) {
+    subscribe_failed_.Swap(&other->subscribe_failed_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BatchSubscribeResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BatchSubscribeResponse_descriptor_;
+  metadata.reflection = BatchSubscribeResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BatchUnsubscribeRequest::kAgentIdFieldNumber;
+const int BatchUnsubscribeRequest::kEntityIdFieldNumber;
+const int BatchUnsubscribeRequest::kObjectIdFieldNumber;
+#endif  // !_MSC_VER
+
+BatchUnsubscribeRequest::BatchUnsubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+}
+
+void BatchUnsubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+BatchUnsubscribeRequest::BatchUnsubscribeRequest(const BatchUnsubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+}
+
+void BatchUnsubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BatchUnsubscribeRequest::~BatchUnsubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+  SharedDtor();
+}
+
+void BatchUnsubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void BatchUnsubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BatchUnsubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BatchUnsubscribeRequest_descriptor_;
+}
+
+const BatchUnsubscribeRequest& BatchUnsubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
+  return *default_instance_;
+}
+
+BatchUnsubscribeRequest* BatchUnsubscribeRequest::default_instance_ = NULL;
+
+BatchUnsubscribeRequest* BatchUnsubscribeRequest::New() const {
+  return new BatchUnsubscribeRequest;
+}
+
+void BatchUnsubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 5) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
+  }
+  entity_id_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BatchUnsubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_entity_id;
+        break;
+      }
+
+      // repeated .bgs.protocol.EntityId entity_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_entity_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_entity_id;
+        if (input->ExpectTag(24)) goto parse_object_id;
+        break;
+      }
+
+      // optional uint64 object_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void BatchUnsubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // repeated .bgs.protocol.EntityId entity_id = 2;
+  for (int i = 0; i < this->entity_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->entity_id(i), output);
+  }
+
+  // optional uint64 object_id = 3;
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->object_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+}
+
+::google::protobuf::uint8* BatchUnsubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // repeated .bgs.protocol.EntityId entity_id = 2;
+  for (int i = 0; i < this->entity_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->entity_id(i), target);
+  }
+
+  // optional uint64 object_id = 3;
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->object_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+  return target;
+}
+
+int BatchUnsubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 object_id = 3;
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+  }
+  // repeated .bgs.protocol.EntityId entity_id = 2;
+  total_size += 1 * this->entity_id_size();
+  for (int i = 0; i < this->entity_id_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->entity_id(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BatchUnsubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BatchUnsubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BatchUnsubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BatchUnsubscribeRequest::MergeFrom(const BatchUnsubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  entity_id_.MergeFrom(from.entity_id_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BatchUnsubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BatchUnsubscribeRequest::CopyFrom(const BatchUnsubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BatchUnsubscribeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->entity_id())) return false;
+  return true;
+}
+
+void BatchUnsubscribeRequest::Swap(BatchUnsubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    entity_id_.Swap(&other->entity_id_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BatchUnsubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BatchUnsubscribeRequest_descriptor_;
+  metadata.reflection = BatchUnsubscribeRequest_reflection_;
   return metadata;
 }
 
@@ -3067,17 +3817,28 @@ void PresenceService::SubscribeNotification(::bgs::protocol::presence::v1::Subsc
   SendRequest(service_hash_, 7, request, std::move(callback));
 }
 
-void PresenceService::MigrateOlympusCustomMessage(::bgs::protocol::presence::v1::MigrateOlympusCustomMessageRequest const* request, std::function<void(::bgs::protocol::presence::v1::MigrateOlympusCustomMessageResponse const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.MigrateOlympusCustomMessage(bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest{ %s })",
+void PresenceService::BatchSubscribe(::bgs::protocol::presence::v1::BatchSubscribeRequest const* request, std::function<void(::bgs::protocol::presence::v1::BatchSubscribeResponse const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.BatchSubscribe(bgs.protocol.presence.v1.BatchSubscribeRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::presence::v1::MigrateOlympusCustomMessageResponse response;
+    ::bgs::protocol::presence::v1::BatchSubscribeResponse response;
     if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
       responseCallback(&response);
   };
   SendRequest(service_hash_, 8, request, std::move(callback));
 }
 
+void PresenceService::BatchUnsubscribe(::bgs::protocol::presence::v1::BatchUnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.BatchUnsubscribe(bgs.protocol.presence.v1.BatchUnsubscribeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      responseCallback(&response);
+  };
+  SendRequest(service_hash_, 9, request, std::move(callback));
+}
+
 void PresenceService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
   switch(methodId) {
     case 1: {
@@ -3237,27 +3998,53 @@ void PresenceService::CallServerMethod(uint32 token, uint32 methodId, MessageBuf
       break;
     }
     case 8: {
-      ::bgs::protocol::presence::v1::MigrateOlympusCustomMessageRequest request;
+      ::bgs::protocol::presence::v1::BatchSubscribeRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.MigrateOlympusCustomMessage server method call.", GetCallerInfo().c_str());
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.BatchSubscribe server method call.", GetCallerInfo().c_str());
         SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST);
         return;
       }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.MigrateOlympusCustomMessage(bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest{ %s }).",
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.BatchSubscribe(bgs.protocol.presence.v1.BatchSubscribeRequest{ %s }).",
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::presence::v1::MigrateOlympusCustomMessageResponse::descriptor());
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::presence::v1::BatchSubscribeResponse::descriptor());
         PresenceService* self = static_cast<PresenceService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.MigrateOlympusCustomMessage() returned bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse{ %s } status %u.",
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.BatchSubscribe() returned bgs.protocol.presence.v1.BatchSubscribeResponse{ %s } status %u.",
           self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
         if (!status)
           self->SendResponse(self->service_hash_, 8, token, response);
         else
           self->SendResponse(self->service_hash_, 8, token, status);
       };
-      ::bgs::protocol::presence::v1::MigrateOlympusCustomMessageResponse response;
-      uint32 status = HandleMigrateOlympusCustomMessage(&request, &response, continuation);
+      ::bgs::protocol::presence::v1::BatchSubscribeResponse response;
+      uint32 status = HandleBatchSubscribe(&request, &response, continuation);
+      if (continuation)
+        continuation(this, status, &response);
+      break;
+    }
+    case 9: {
+      ::bgs::protocol::presence::v1::BatchUnsubscribeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.BatchUnsubscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 9, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.BatchUnsubscribe(bgs.protocol.presence.v1.BatchUnsubscribeRequest{ %s }).",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
+      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
+      {
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
+        PresenceService* self = static_cast<PresenceService*>(service);
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.BatchUnsubscribe() returned bgs.protocol.NoData{ %s } status %u.",
+          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
+        if (!status)
+          self->SendResponse(self->service_hash_, 9, token, response);
+        else
+          self->SendResponse(self->service_hash_, 9, token, status);
+      };
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleBatchUnsubscribe(&request, &response, continuation);
       if (continuation)
         continuation(this, status, &response);
       break;
@@ -3305,8 +4092,14 @@ uint32 PresenceService::HandleSubscribeNotification(::bgs::protocol::presence::v
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 PresenceService::HandleMigrateOlympusCustomMessage(::bgs::protocol::presence::v1::MigrateOlympusCustomMessageRequest const* request, ::bgs::protocol::presence::v1::MigrateOlympusCustomMessageResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.MigrateOlympusCustomMessage({ %s })",
+uint32 PresenceService::HandleBatchSubscribe(::bgs::protocol::presence::v1::BatchSubscribeRequest const* request, ::bgs::protocol::presence::v1::BatchSubscribeResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.BatchSubscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 PresenceService::HandleBatchUnsubscribe(::bgs::protocol::presence::v1::BatchUnsubscribeRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.BatchUnsubscribe({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
diff --git a/src/server/proto/Client/presence_service.pb.h b/src/server/proto/Client/presence_service.pb.h
index 861103f133b..c402f97665c 100644
--- a/src/server/proto/Client/presence_service.pb.h
+++ b/src/server/proto/Client/presence_service.pb.h
@@ -50,8 +50,10 @@ class UpdateRequest;
 class QueryRequest;
 class QueryResponse;
 class OwnershipRequest;
-class MigrateOlympusCustomMessageRequest;
-class MigrateOlympusCustomMessageResponse;
+class BatchSubscribeRequest;
+class SubscribeResult;
+class BatchSubscribeResponse;
+class BatchUnsubscribeRequest;
 
 // ===================================================================
 
@@ -145,12 +147,17 @@ class TC_PROTO_API SubscribeRequest : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
       mutable_program();
 
-  // optional bool flag_public = 5 [default = true, deprecated = true];
-  inline bool has_flag_public() const PROTOBUF_DEPRECATED;
-  inline void clear_flag_public() PROTOBUF_DEPRECATED;
-  static const int kFlagPublicFieldNumber = 5;
-  inline bool flag_public() const PROTOBUF_DEPRECATED;
-  inline void set_flag_public(bool value) PROTOBUF_DEPRECATED;
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 6;
+  inline int key_size() const;
+  inline void clear_key();
+  static const int kKeyFieldNumber = 6;
+  inline const ::bgs::protocol::presence::v1::FieldKey& key(int index) const;
+  inline ::bgs::protocol::presence::v1::FieldKey* mutable_key(int index);
+  inline ::bgs::protocol::presence::v1::FieldKey* add_key();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >&
+      key() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >*
+      mutable_key();
 
   // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.SubscribeRequest)
  private:
@@ -160,8 +167,6 @@ class TC_PROTO_API SubscribeRequest : public ::google::protobuf::Message {
   inline void clear_has_entity_id();
   inline void set_has_object_id();
   inline void clear_has_object_id();
-  inline void set_has_flag_public();
-  inline void clear_has_flag_public();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -171,7 +176,7 @@ class TC_PROTO_API SubscribeRequest : public ::google::protobuf::Message {
   ::bgs::protocol::EntityId* entity_id_;
   ::google::protobuf::uint64 object_id_;
   ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > program_;
-  bool flag_public_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey > key_;
   friend void TC_PROTO_API protobuf_AddDesc_presence_5fservice_2eproto();
   friend void protobuf_AssignDesc_presence_5fservice_2eproto();
   friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
@@ -439,7 +444,7 @@ class TC_PROTO_API UpdateRequest : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >*
       mutable_field_operation();
 
-  // optional bool no_create = 3 [default = false];
+  // optional bool no_create = 3;
   inline bool has_no_create() const;
   inline void clear_no_create();
   static const int kNoCreateFieldNumber = 3;
@@ -731,7 +736,7 @@ class TC_PROTO_API OwnershipRequest : public ::google::protobuf::Message {
   inline ::bgs::protocol::EntityId* release_entity_id();
   inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
 
-  // optional bool release_ownership = 2 [default = false];
+  // optional bool release_ownership = 2;
   inline bool has_release_ownership() const;
   inline void clear_release_ownership();
   static const int kReleaseOwnershipFieldNumber = 2;
@@ -760,14 +765,144 @@ class TC_PROTO_API OwnershipRequest : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API MigrateOlympusCustomMessageRequest : public ::google::protobuf::Message {
+class TC_PROTO_API BatchSubscribeRequest : public ::google::protobuf::Message {
+ public:
+  BatchSubscribeRequest();
+  virtual ~BatchSubscribeRequest();
+
+  BatchSubscribeRequest(const BatchSubscribeRequest& from);
+
+  inline BatchSubscribeRequest& operator=(const BatchSubscribeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BatchSubscribeRequest& default_instance();
+
+  void Swap(BatchSubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  BatchSubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BatchSubscribeRequest& from);
+  void MergeFrom(const BatchSubscribeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // repeated .bgs.protocol.EntityId entity_id = 2;
+  inline int entity_id_size() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& entity_id(int index) const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id(int index);
+  inline ::bgs::protocol::EntityId* add_entity_id();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >&
+      entity_id() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >*
+      mutable_entity_id();
+
+  // repeated fixed32 program = 3;
+  inline int program_size() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 3;
+  inline ::google::protobuf::uint32 program(int index) const;
+  inline void set_program(int index, ::google::protobuf::uint32 value);
+  inline void add_program(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      program() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_program();
+
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 4;
+  inline int key_size() const;
+  inline void clear_key();
+  static const int kKeyFieldNumber = 4;
+  inline const ::bgs::protocol::presence::v1::FieldKey& key(int index) const;
+  inline ::bgs::protocol::presence::v1::FieldKey* mutable_key(int index);
+  inline ::bgs::protocol::presence::v1::FieldKey* add_key();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >&
+      key() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >*
+      mutable_key();
+
+  // optional uint64 object_id = 5;
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 5;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.BatchSubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId > entity_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > program_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey > key_;
+  ::google::protobuf::uint64 object_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_presence_5fservice_2eproto();
+  friend void protobuf_AssignDesc_presence_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static BatchSubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API SubscribeResult : public ::google::protobuf::Message {
  public:
-  MigrateOlympusCustomMessageRequest();
-  virtual ~MigrateOlympusCustomMessageRequest();
+  SubscribeResult();
+  virtual ~SubscribeResult();
 
-  MigrateOlympusCustomMessageRequest(const MigrateOlympusCustomMessageRequest& from);
+  SubscribeResult(const SubscribeResult& from);
 
-  inline MigrateOlympusCustomMessageRequest& operator=(const MigrateOlympusCustomMessageRequest& from) {
+  inline SubscribeResult& operator=(const SubscribeResult& from) {
     CopyFrom(from);
     return *this;
   }
@@ -781,17 +916,17 @@ class TC_PROTO_API MigrateOlympusCustomMessageRequest : public ::google::protobu
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const MigrateOlympusCustomMessageRequest& default_instance();
+  static const SubscribeResult& default_instance();
 
-  void Swap(MigrateOlympusCustomMessageRequest* other);
+  void Swap(SubscribeResult* other);
 
   // implements Message ----------------------------------------------
 
-  MigrateOlympusCustomMessageRequest* New() const;
+  SubscribeResult* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const MigrateOlympusCustomMessageRequest& from);
-  void MergeFrom(const MigrateOlympusCustomMessageRequest& from);
+  void CopyFrom(const SubscribeResult& from);
+  void MergeFrom(const SubscribeResult& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -813,42 +948,52 @@ class TC_PROTO_API MigrateOlympusCustomMessageRequest : public ::google::protobu
 
   // accessors -------------------------------------------------------
 
-  // required .bgs.protocol.EntityId account = 1;
-  inline bool has_account() const;
-  inline void clear_account();
-  static const int kAccountFieldNumber = 1;
-  inline const ::bgs::protocol::EntityId& account() const;
-  inline ::bgs::protocol::EntityId* mutable_account();
-  inline ::bgs::protocol::EntityId* release_account();
-  inline void set_allocated_account(::bgs::protocol::EntityId* account);
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // optional uint32 result = 2;
+  inline bool has_result() const;
+  inline void clear_result();
+  static const int kResultFieldNumber = 2;
+  inline ::google::protobuf::uint32 result() const;
+  inline void set_result(::google::protobuf::uint32 value);
 
-  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.SubscribeResult)
  private:
-  inline void set_has_account();
-  inline void clear_has_account();
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_result();
+  inline void clear_has_result();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::bgs::protocol::EntityId* account_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::uint32 result_;
   friend void TC_PROTO_API protobuf_AddDesc_presence_5fservice_2eproto();
   friend void protobuf_AssignDesc_presence_5fservice_2eproto();
   friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static MigrateOlympusCustomMessageRequest* default_instance_;
+  static SubscribeResult* default_instance_;
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API MigrateOlympusCustomMessageResponse : public ::google::protobuf::Message {
+class TC_PROTO_API BatchSubscribeResponse : public ::google::protobuf::Message {
  public:
-  MigrateOlympusCustomMessageResponse();
-  virtual ~MigrateOlympusCustomMessageResponse();
+  BatchSubscribeResponse();
+  virtual ~BatchSubscribeResponse();
 
-  MigrateOlympusCustomMessageResponse(const MigrateOlympusCustomMessageResponse& from);
+  BatchSubscribeResponse(const BatchSubscribeResponse& from);
 
-  inline MigrateOlympusCustomMessageResponse& operator=(const MigrateOlympusCustomMessageResponse& from) {
+  inline BatchSubscribeResponse& operator=(const BatchSubscribeResponse& from) {
     CopyFrom(from);
     return *this;
   }
@@ -862,17 +1007,17 @@ class TC_PROTO_API MigrateOlympusCustomMessageResponse : public ::google::protob
   }
 
   static const ::google::protobuf::Descriptor* descriptor();
-  static const MigrateOlympusCustomMessageResponse& default_instance();
+  static const BatchSubscribeResponse& default_instance();
 
-  void Swap(MigrateOlympusCustomMessageResponse* other);
+  void Swap(BatchSubscribeResponse* other);
 
   // implements Message ----------------------------------------------
 
-  MigrateOlympusCustomMessageResponse* New() const;
+  BatchSubscribeResponse* New() const;
   void CopyFrom(const ::google::protobuf::Message& from);
   void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const MigrateOlympusCustomMessageResponse& from);
-  void MergeFrom(const MigrateOlympusCustomMessageResponse& from);
+  void CopyFrom(const BatchSubscribeResponse& from);
+  void MergeFrom(const BatchSubscribeResponse& from);
   void Clear();
   bool IsInitialized() const;
 
@@ -894,44 +1039,136 @@ class TC_PROTO_API MigrateOlympusCustomMessageResponse : public ::google::protob
 
   // accessors -------------------------------------------------------
 
-  // optional string custom_message = 1;
-  inline bool has_custom_message() const;
-  inline void clear_custom_message();
-  static const int kCustomMessageFieldNumber = 1;
-  inline const ::std::string& custom_message() const;
-  inline void set_custom_message(const ::std::string& value);
-  inline void set_custom_message(const char* value);
-  inline void set_custom_message(const char* value, size_t size);
-  inline ::std::string* mutable_custom_message();
-  inline ::std::string* release_custom_message();
-  inline void set_allocated_custom_message(::std::string* custom_message);
-
-  // optional uint32 custom_message_time_epoch = 2;
-  inline bool has_custom_message_time_epoch() const;
-  inline void clear_custom_message_time_epoch();
-  static const int kCustomMessageTimeEpochFieldNumber = 2;
-  inline ::google::protobuf::uint32 custom_message_time_epoch() const;
-  inline void set_custom_message_time_epoch(::google::protobuf::uint32 value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse)
+  // repeated .bgs.protocol.presence.v1.SubscribeResult subscribe_failed = 1;
+  inline int subscribe_failed_size() const;
+  inline void clear_subscribe_failed();
+  static const int kSubscribeFailedFieldNumber = 1;
+  inline const ::bgs::protocol::presence::v1::SubscribeResult& subscribe_failed(int index) const;
+  inline ::bgs::protocol::presence::v1::SubscribeResult* mutable_subscribe_failed(int index);
+  inline ::bgs::protocol::presence::v1::SubscribeResult* add_subscribe_failed();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::SubscribeResult >&
+      subscribe_failed() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::SubscribeResult >*
+      mutable_subscribe_failed();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.BatchSubscribeResponse)
  private:
-  inline void set_has_custom_message();
-  inline void clear_has_custom_message();
-  inline void set_has_custom_message_time_epoch();
-  inline void clear_has_custom_message_time_epoch();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::std::string* custom_message_;
-  ::google::protobuf::uint32 custom_message_time_epoch_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::SubscribeResult > subscribe_failed_;
   friend void TC_PROTO_API protobuf_AddDesc_presence_5fservice_2eproto();
   friend void protobuf_AssignDesc_presence_5fservice_2eproto();
   friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
 
   void InitAsDefaultInstance();
-  static MigrateOlympusCustomMessageResponse* default_instance_;
+  static BatchSubscribeResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_PROTO_API BatchUnsubscribeRequest : public ::google::protobuf::Message {
+ public:
+  BatchUnsubscribeRequest();
+  virtual ~BatchUnsubscribeRequest();
+
+  BatchUnsubscribeRequest(const BatchUnsubscribeRequest& from);
+
+  inline BatchUnsubscribeRequest& operator=(const BatchUnsubscribeRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BatchUnsubscribeRequest& default_instance();
+
+  void Swap(BatchUnsubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  BatchUnsubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BatchUnsubscribeRequest& from);
+  void MergeFrom(const BatchUnsubscribeRequest& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // repeated .bgs.protocol.EntityId entity_id = 2;
+  inline int entity_id_size() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& entity_id(int index) const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id(int index);
+  inline ::bgs::protocol::EntityId* add_entity_id();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >&
+      entity_id() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >*
+      mutable_entity_id();
+
+  // optional uint64 object_id = 3;
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.BatchUnsubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId > entity_id_;
+  ::google::protobuf::uint64 object_id_;
+  friend void TC_PROTO_API protobuf_AddDesc_presence_5fservice_2eproto();
+  friend void protobuf_AssignDesc_presence_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static BatchUnsubscribeRequest* default_instance_;
 };
 // ===================================================================
 
@@ -955,7 +1192,8 @@ class TC_PROTO_API PresenceService : public ServiceBase
   void Query(::bgs::protocol::presence::v1::QueryRequest const* request, std::function<void(::bgs::protocol::presence::v1::QueryResponse const*)> responseCallback);
   void Ownership(::bgs::protocol::presence::v1::OwnershipRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void SubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void MigrateOlympusCustomMessage(::bgs::protocol::presence::v1::MigrateOlympusCustomMessageRequest const* request, std::function<void(::bgs::protocol::presence::v1::MigrateOlympusCustomMessageResponse const*)> responseCallback);
+  void BatchSubscribe(::bgs::protocol::presence::v1::BatchSubscribeRequest const* request, std::function<void(::bgs::protocol::presence::v1::BatchSubscribeResponse const*)> responseCallback);
+  void BatchUnsubscribe(::bgs::protocol::presence::v1::BatchUnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   // server methods --------------------------------------------------
 
   void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
@@ -967,7 +1205,8 @@ class TC_PROTO_API PresenceService : public ServiceBase
   virtual uint32 HandleQuery(::bgs::protocol::presence::v1::QueryRequest const* request, ::bgs::protocol::presence::v1::QueryResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleOwnership(::bgs::protocol::presence::v1::OwnershipRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleSubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleMigrateOlympusCustomMessage(::bgs::protocol::presence::v1::MigrateOlympusCustomMessageRequest const* request, ::bgs::protocol::presence::v1::MigrateOlympusCustomMessageResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleBatchSubscribe(::bgs::protocol::presence::v1::BatchSubscribeRequest const* request, ::bgs::protocol::presence::v1::BatchSubscribeResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleBatchUnsubscribe(::bgs::protocol::presence::v1::BatchUnsubscribeRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
 
  private:
   uint32 service_hash_;
@@ -1118,28 +1357,34 @@ SubscribeRequest::mutable_program() {
   return &program_;
 }
 
-// optional bool flag_public = 5 [default = true, deprecated = true];
-inline bool SubscribeRequest::has_flag_public() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
+// repeated .bgs.protocol.presence.v1.FieldKey key = 6;
+inline int SubscribeRequest::key_size() const {
+  return key_.size();
 }
-inline void SubscribeRequest::set_has_flag_public() {
-  _has_bits_[0] |= 0x00000010u;
+inline void SubscribeRequest::clear_key() {
+  key_.Clear();
 }
-inline void SubscribeRequest::clear_has_flag_public() {
-  _has_bits_[0] &= ~0x00000010u;
+inline const ::bgs::protocol::presence::v1::FieldKey& SubscribeRequest::key(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.key)
+  return key_.Get(index);
 }
-inline void SubscribeRequest::clear_flag_public() {
-  flag_public_ = true;
-  clear_has_flag_public();
+inline ::bgs::protocol::presence::v1::FieldKey* SubscribeRequest::mutable_key(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeRequest.key)
+  return key_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::FieldKey* SubscribeRequest::add_key() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.SubscribeRequest.key)
+  return key_.Add();
 }
-inline bool SubscribeRequest::flag_public() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.flag_public)
-  return flag_public_;
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >&
+SubscribeRequest::key() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.SubscribeRequest.key)
+  return key_;
 }
-inline void SubscribeRequest::set_flag_public(bool value) {
-  set_has_flag_public();
-  flag_public_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.SubscribeRequest.flag_public)
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >*
+SubscribeRequest::mutable_key() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.SubscribeRequest.key)
+  return &key_;
 }
 
 // -------------------------------------------------------------------
@@ -1372,7 +1617,7 @@ UpdateRequest::mutable_field_operation() {
   return &field_operation_;
 }
 
-// optional bool no_create = 3 [default = false];
+// optional bool no_create = 3;
 inline bool UpdateRequest::has_no_create() const {
   return (_has_bits_[0] & 0x00000004u) != 0;
 }
@@ -1632,7 +1877,7 @@ inline void OwnershipRequest::set_allocated_entity_id(::bgs::protocol::EntityId*
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.OwnershipRequest.entity_id)
 }
 
-// optional bool release_ownership = 2 [default = false];
+// optional bool release_ownership = 2;
 inline bool OwnershipRequest::has_release_ownership() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
@@ -1658,151 +1903,363 @@ inline void OwnershipRequest::set_release_ownership(bool value) {
 
 // -------------------------------------------------------------------
 
-// MigrateOlympusCustomMessageRequest
+// BatchSubscribeRequest
 
-// required .bgs.protocol.EntityId account = 1;
-inline bool MigrateOlympusCustomMessageRequest::has_account() const {
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool BatchSubscribeRequest::has_agent_id() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void MigrateOlympusCustomMessageRequest::set_has_account() {
+inline void BatchSubscribeRequest::set_has_agent_id() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void MigrateOlympusCustomMessageRequest::clear_has_account() {
+inline void BatchSubscribeRequest::clear_has_agent_id() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void MigrateOlympusCustomMessageRequest::clear_account() {
-  if (account_ != NULL) account_->::bgs::protocol::EntityId::Clear();
-  clear_has_account();
+inline void BatchSubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
 }
-inline const ::bgs::protocol::EntityId& MigrateOlympusCustomMessageRequest::account() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest.account)
-  return account_ != NULL ? *account_ : *default_instance_->account_;
+inline const ::bgs::protocol::EntityId& BatchSubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.BatchSubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
 }
-inline ::bgs::protocol::EntityId* MigrateOlympusCustomMessageRequest::mutable_account() {
-  set_has_account();
-  if (account_ == NULL) account_ = new ::bgs::protocol::EntityId;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest.account)
-  return account_;
+inline ::bgs::protocol::EntityId* BatchSubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.BatchSubscribeRequest.agent_id)
+  return agent_id_;
 }
-inline ::bgs::protocol::EntityId* MigrateOlympusCustomMessageRequest::release_account() {
-  clear_has_account();
-  ::bgs::protocol::EntityId* temp = account_;
-  account_ = NULL;
+inline ::bgs::protocol::EntityId* BatchSubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
   return temp;
 }
-inline void MigrateOlympusCustomMessageRequest::set_allocated_account(::bgs::protocol::EntityId* account) {
-  delete account_;
-  account_ = account;
-  if (account) {
-    set_has_account();
+inline void BatchSubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
   } else {
-    clear_has_account();
+    clear_has_agent_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.MigrateOlympusCustomMessageRequest.account)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.BatchSubscribeRequest.agent_id)
+}
+
+// repeated .bgs.protocol.EntityId entity_id = 2;
+inline int BatchSubscribeRequest::entity_id_size() const {
+  return entity_id_.size();
+}
+inline void BatchSubscribeRequest::clear_entity_id() {
+  entity_id_.Clear();
+}
+inline const ::bgs::protocol::EntityId& BatchSubscribeRequest::entity_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.BatchSubscribeRequest.entity_id)
+  return entity_id_.Get(index);
+}
+inline ::bgs::protocol::EntityId* BatchSubscribeRequest::mutable_entity_id(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.BatchSubscribeRequest.entity_id)
+  return entity_id_.Mutable(index);
+}
+inline ::bgs::protocol::EntityId* BatchSubscribeRequest::add_entity_id() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.BatchSubscribeRequest.entity_id)
+  return entity_id_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >&
+BatchSubscribeRequest::entity_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.BatchSubscribeRequest.entity_id)
+  return entity_id_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >*
+BatchSubscribeRequest::mutable_entity_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.BatchSubscribeRequest.entity_id)
+  return &entity_id_;
+}
+
+// repeated fixed32 program = 3;
+inline int BatchSubscribeRequest::program_size() const {
+  return program_.size();
+}
+inline void BatchSubscribeRequest::clear_program() {
+  program_.Clear();
+}
+inline ::google::protobuf::uint32 BatchSubscribeRequest::program(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.BatchSubscribeRequest.program)
+  return program_.Get(index);
+}
+inline void BatchSubscribeRequest::set_program(int index, ::google::protobuf::uint32 value) {
+  program_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.BatchSubscribeRequest.program)
+}
+inline void BatchSubscribeRequest::add_program(::google::protobuf::uint32 value) {
+  program_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.BatchSubscribeRequest.program)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+BatchSubscribeRequest::program() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.BatchSubscribeRequest.program)
+  return program_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+BatchSubscribeRequest::mutable_program() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.BatchSubscribeRequest.program)
+  return &program_;
+}
+
+// repeated .bgs.protocol.presence.v1.FieldKey key = 4;
+inline int BatchSubscribeRequest::key_size() const {
+  return key_.size();
+}
+inline void BatchSubscribeRequest::clear_key() {
+  key_.Clear();
+}
+inline const ::bgs::protocol::presence::v1::FieldKey& BatchSubscribeRequest::key(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.BatchSubscribeRequest.key)
+  return key_.Get(index);
+}
+inline ::bgs::protocol::presence::v1::FieldKey* BatchSubscribeRequest::mutable_key(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.BatchSubscribeRequest.key)
+  return key_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::FieldKey* BatchSubscribeRequest::add_key() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.BatchSubscribeRequest.key)
+  return key_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >&
+BatchSubscribeRequest::key() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.BatchSubscribeRequest.key)
+  return key_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >*
+BatchSubscribeRequest::mutable_key() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.BatchSubscribeRequest.key)
+  return &key_;
+}
+
+// optional uint64 object_id = 5;
+inline bool BatchSubscribeRequest::has_object_id() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void BatchSubscribeRequest::set_has_object_id() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void BatchSubscribeRequest::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void BatchSubscribeRequest::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 BatchSubscribeRequest::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.BatchSubscribeRequest.object_id)
+  return object_id_;
+}
+inline void BatchSubscribeRequest::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.BatchSubscribeRequest.object_id)
 }
 
 // -------------------------------------------------------------------
 
-// MigrateOlympusCustomMessageResponse
+// SubscribeResult
 
-// optional string custom_message = 1;
-inline bool MigrateOlympusCustomMessageResponse::has_custom_message() const {
+// optional .bgs.protocol.EntityId entity_id = 1;
+inline bool SubscribeResult::has_entity_id() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void MigrateOlympusCustomMessageResponse::set_has_custom_message() {
+inline void SubscribeResult::set_has_entity_id() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void MigrateOlympusCustomMessageResponse::clear_has_custom_message() {
+inline void SubscribeResult::clear_has_entity_id() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void MigrateOlympusCustomMessageResponse::clear_custom_message() {
-  if (custom_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    custom_message_->clear();
-  }
-  clear_has_custom_message();
+inline void SubscribeResult::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
 }
-inline const ::std::string& MigrateOlympusCustomMessageResponse::custom_message() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse.custom_message)
-  return *custom_message_;
+inline const ::bgs::protocol::EntityId& SubscribeResult::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeResult.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
 }
-inline void MigrateOlympusCustomMessageResponse::set_custom_message(const ::std::string& value) {
-  set_has_custom_message();
-  if (custom_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    custom_message_ = new ::std::string;
-  }
-  custom_message_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse.custom_message)
+inline ::bgs::protocol::EntityId* SubscribeResult::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeResult.entity_id)
+  return entity_id_;
 }
-inline void MigrateOlympusCustomMessageResponse::set_custom_message(const char* value) {
-  set_has_custom_message();
-  if (custom_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    custom_message_ = new ::std::string;
-  }
-  custom_message_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse.custom_message)
+inline ::bgs::protocol::EntityId* SubscribeResult::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
 }
-inline void MigrateOlympusCustomMessageResponse::set_custom_message(const char* value, size_t size) {
-  set_has_custom_message();
-  if (custom_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    custom_message_ = new ::std::string;
+inline void SubscribeResult::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
   }
-  custom_message_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse.custom_message)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.SubscribeResult.entity_id)
 }
-inline ::std::string* MigrateOlympusCustomMessageResponse::mutable_custom_message() {
-  set_has_custom_message();
-  if (custom_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    custom_message_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse.custom_message)
-  return custom_message_;
+
+// optional uint32 result = 2;
+inline bool SubscribeResult::has_result() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline ::std::string* MigrateOlympusCustomMessageResponse::release_custom_message() {
-  clear_has_custom_message();
-  if (custom_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = custom_message_;
-    custom_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
+inline void SubscribeResult::set_has_result() {
+  _has_bits_[0] |= 0x00000002u;
 }
-inline void MigrateOlympusCustomMessageResponse::set_allocated_custom_message(::std::string* custom_message) {
-  if (custom_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete custom_message_;
-  }
-  if (custom_message) {
-    set_has_custom_message();
-    custom_message_ = custom_message;
+inline void SubscribeResult::clear_has_result() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscribeResult::clear_result() {
+  result_ = 0u;
+  clear_has_result();
+}
+inline ::google::protobuf::uint32 SubscribeResult::result() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeResult.result)
+  return result_;
+}
+inline void SubscribeResult::set_result(::google::protobuf::uint32 value) {
+  set_has_result();
+  result_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.SubscribeResult.result)
+}
+
+// -------------------------------------------------------------------
+
+// BatchSubscribeResponse
+
+// repeated .bgs.protocol.presence.v1.SubscribeResult subscribe_failed = 1;
+inline int BatchSubscribeResponse::subscribe_failed_size() const {
+  return subscribe_failed_.size();
+}
+inline void BatchSubscribeResponse::clear_subscribe_failed() {
+  subscribe_failed_.Clear();
+}
+inline const ::bgs::protocol::presence::v1::SubscribeResult& BatchSubscribeResponse::subscribe_failed(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.BatchSubscribeResponse.subscribe_failed)
+  return subscribe_failed_.Get(index);
+}
+inline ::bgs::protocol::presence::v1::SubscribeResult* BatchSubscribeResponse::mutable_subscribe_failed(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.BatchSubscribeResponse.subscribe_failed)
+  return subscribe_failed_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::SubscribeResult* BatchSubscribeResponse::add_subscribe_failed() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.BatchSubscribeResponse.subscribe_failed)
+  return subscribe_failed_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::SubscribeResult >&
+BatchSubscribeResponse::subscribe_failed() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.BatchSubscribeResponse.subscribe_failed)
+  return subscribe_failed_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::SubscribeResult >*
+BatchSubscribeResponse::mutable_subscribe_failed() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.BatchSubscribeResponse.subscribe_failed)
+  return &subscribe_failed_;
+}
+
+// -------------------------------------------------------------------
+
+// BatchUnsubscribeRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool BatchUnsubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BatchUnsubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BatchUnsubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BatchUnsubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& BatchUnsubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.BatchUnsubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* BatchUnsubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.BatchUnsubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* BatchUnsubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void BatchUnsubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
   } else {
-    clear_has_custom_message();
-    custom_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    clear_has_agent_id();
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse.custom_message)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.BatchUnsubscribeRequest.agent_id)
 }
 
-// optional uint32 custom_message_time_epoch = 2;
-inline bool MigrateOlympusCustomMessageResponse::has_custom_message_time_epoch() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
+// repeated .bgs.protocol.EntityId entity_id = 2;
+inline int BatchUnsubscribeRequest::entity_id_size() const {
+  return entity_id_.size();
 }
-inline void MigrateOlympusCustomMessageResponse::set_has_custom_message_time_epoch() {
-  _has_bits_[0] |= 0x00000002u;
+inline void BatchUnsubscribeRequest::clear_entity_id() {
+  entity_id_.Clear();
 }
-inline void MigrateOlympusCustomMessageResponse::clear_has_custom_message_time_epoch() {
-  _has_bits_[0] &= ~0x00000002u;
+inline const ::bgs::protocol::EntityId& BatchUnsubscribeRequest::entity_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.BatchUnsubscribeRequest.entity_id)
+  return entity_id_.Get(index);
+}
+inline ::bgs::protocol::EntityId* BatchUnsubscribeRequest::mutable_entity_id(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.BatchUnsubscribeRequest.entity_id)
+  return entity_id_.Mutable(index);
 }
-inline void MigrateOlympusCustomMessageResponse::clear_custom_message_time_epoch() {
-  custom_message_time_epoch_ = 0u;
-  clear_has_custom_message_time_epoch();
+inline ::bgs::protocol::EntityId* BatchUnsubscribeRequest::add_entity_id() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.BatchUnsubscribeRequest.entity_id)
+  return entity_id_.Add();
 }
-inline ::google::protobuf::uint32 MigrateOlympusCustomMessageResponse::custom_message_time_epoch() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse.custom_message_time_epoch)
-  return custom_message_time_epoch_;
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >&
+BatchUnsubscribeRequest::entity_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.BatchUnsubscribeRequest.entity_id)
+  return entity_id_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >*
+BatchUnsubscribeRequest::mutable_entity_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.BatchUnsubscribeRequest.entity_id)
+  return &entity_id_;
+}
+
+// optional uint64 object_id = 3;
+inline bool BatchUnsubscribeRequest::has_object_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
 }
-inline void MigrateOlympusCustomMessageResponse::set_custom_message_time_epoch(::google::protobuf::uint32 value) {
-  set_has_custom_message_time_epoch();
-  custom_message_time_epoch_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.MigrateOlympusCustomMessageResponse.custom_message_time_epoch)
+inline void BatchUnsubscribeRequest::set_has_object_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void BatchUnsubscribeRequest::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void BatchUnsubscribeRequest::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 BatchUnsubscribeRequest::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.BatchUnsubscribeRequest.object_id)
+  return object_id_;
+}
+inline void BatchUnsubscribeRequest::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.BatchUnsubscribeRequest.object_id)
 }
 
 
diff --git a/src/server/proto/Client/presence_types.pb.cc b/src/server/proto/Client/presence_types.pb.cc
index a94381dce57..216928ea145 100644
--- a/src/server/proto/Client/presence_types.pb.cc
+++ b/src/server/proto/Client/presence_types.pb.cc
@@ -38,6 +38,9 @@ const ::google::protobuf::Descriptor* FieldOperation_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   FieldOperation_reflection_ = NULL;
 const ::google::protobuf::EnumDescriptor* FieldOperation_OperationType_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* PresenceState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PresenceState_reflection_ = NULL;
 const ::google::protobuf::Descriptor* ChannelState_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   ChannelState_reflection_ = NULL;
@@ -119,7 +122,23 @@ void protobuf_AssignDesc_presence_5ftypes_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(FieldOperation));
   FieldOperation_OperationType_descriptor_ = FieldOperation_descriptor_->enum_type(0);
-  ChannelState_descriptor_ = file->message_type(4);
+  PresenceState_descriptor_ = file->message_type(4);
+  static const int PresenceState_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceState, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceState, field_operation_),
+  };
+  PresenceState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PresenceState_descriptor_,
+      PresenceState::default_instance_,
+      PresenceState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceState, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PresenceState));
+  ChannelState_descriptor_ = file->message_type(5);
   static const int ChannelState_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, entity_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, field_operation_),
@@ -157,6 +176,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     FieldOperation_descriptor_, &FieldOperation::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PresenceState_descriptor_, &PresenceState::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     ChannelState_descriptor_, &ChannelState::default_instance());
 }
 
@@ -171,6 +192,8 @@ void protobuf_ShutdownFile_presence_5ftypes_2eproto() {
   delete Field_reflection_;
   delete FieldOperation::default_instance_;
   delete FieldOperation_reflection_;
+  delete PresenceState::default_instance_;
+  delete PresenceState_reflection_;
   delete ChannelState::default_instance_;
   delete ChannelState_reflection_;
 }
@@ -199,24 +222,29 @@ void protobuf_AddDesc_presence_5ftypes_2eproto() {
     "Field\022N\n\toperation\030\002 \001(\01626.bgs.protocol."
     "presence.v1.FieldOperation.OperationType"
     ":\003SET\"#\n\rOperationType\022\007\n\003SET\020\000\022\t\n\005CLEAR"
-    "\020\001\"\365\001\n\014ChannelState\022)\n\tentity_id\030\001 \001(\0132\026"
+    "\020\001\"}\n\rPresenceState\022)\n\tentity_id\030\001 \001(\0132\026"
     ".bgs.protocol.EntityId\022A\n\017field_operatio"
     "n\030\002 \003(\0132(.bgs.protocol.presence.v1.Field"
-    "Operation\022\026\n\007healing\030\003 \001(\010:\005false2_\n\010pre"
-    "sence\022%.bgs.protocol.channel.v1.ChannelS"
-    "tate\030e \001(\0132&.bgs.protocol.presence.v1.Ch"
-    "annelStateB\002H\001", 814);
+    "Operation\"\365\001\n\014ChannelState\022)\n\tentity_id\030"
+    "\001 \001(\0132\026.bgs.protocol.EntityId\022A\n\017field_o"
+    "peration\030\002 \003(\0132(.bgs.protocol.presence.v"
+    "1.FieldOperation\022\026\n\007healing\030\003 \001(\010:\005false"
+    "2_\n\010presence\022%.bgs.protocol.channel.v1.C"
+    "hannelState\030e \001(\0132&.bgs.protocol.presenc"
+    "e.v1.ChannelStateB\002H\001", 941);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "presence_types.proto", &protobuf_RegisterTypes);
   RichPresenceLocalizationKey::default_instance_ = new RichPresenceLocalizationKey();
   FieldKey::default_instance_ = new FieldKey();
   Field::default_instance_ = new Field();
   FieldOperation::default_instance_ = new FieldOperation();
+  PresenceState::default_instance_ = new PresenceState();
   ChannelState::default_instance_ = new ChannelState();
   RichPresenceLocalizationKey::default_instance_->InitAsDefaultInstance();
   FieldKey::default_instance_->InitAsDefaultInstance();
   Field::default_instance_->InitAsDefaultInstance();
   FieldOperation::default_instance_->InitAsDefaultInstance();
+  PresenceState::default_instance_->InitAsDefaultInstance();
   ChannelState::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
     &::bgs::protocol::channel::v1::ChannelState::default_instance(),
@@ -1474,6 +1502,276 @@ void FieldOperation::Swap(FieldOperation* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
+const int PresenceState::kEntityIdFieldNumber;
+const int PresenceState::kFieldOperationFieldNumber;
+#endif  // !_MSC_VER
+
+PresenceState::PresenceState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.PresenceState)
+}
+
+void PresenceState::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+PresenceState::PresenceState(const PresenceState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.PresenceState)
+}
+
+void PresenceState::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PresenceState::~PresenceState() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.PresenceState)
+  SharedDtor();
+}
+
+void PresenceState::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+  }
+}
+
+void PresenceState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PresenceState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PresenceState_descriptor_;
+}
+
+const PresenceState& PresenceState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+PresenceState* PresenceState::default_instance_ = NULL;
+
+PresenceState* PresenceState::New() const {
+  return new PresenceState;
+}
+
+void PresenceState::Clear() {
+  if (has_entity_id()) {
+    if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  }
+  field_operation_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PresenceState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.PresenceState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_field_operation;
+        break;
+      }
+
+      // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_field_operation:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_field_operation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_field_operation;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.PresenceState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.PresenceState)
+  return false;
+#undef DO_
+}
+
+void PresenceState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.PresenceState)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  for (int i = 0; i < this->field_operation_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->field_operation(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.PresenceState)
+}
+
+::google::protobuf::uint8* PresenceState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.PresenceState)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  for (int i = 0; i < this->field_operation_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->field_operation(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.PresenceState)
+  return target;
+}
+
+int PresenceState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+  }
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  total_size += 1 * this->field_operation_size();
+  for (int i = 0; i < this->field_operation_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->field_operation(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PresenceState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PresenceState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PresenceState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PresenceState::MergeFrom(const PresenceState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  field_operation_.MergeFrom(from.field_operation_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PresenceState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PresenceState::CopyFrom(const PresenceState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PresenceState::IsInitialized() const {
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->field_operation())) return false;
+  return true;
+}
+
+void PresenceState::Swap(PresenceState* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    field_operation_.Swap(&other->field_operation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PresenceState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PresenceState_descriptor_;
+  metadata.reflection = PresenceState_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
 const int ChannelState::kEntityIdFieldNumber;
 const int ChannelState::kFieldOperationFieldNumber;
 const int ChannelState::kHealingFieldNumber;
diff --git a/src/server/proto/Client/presence_types.pb.h b/src/server/proto/Client/presence_types.pb.h
index 180792d978d..d7c8457bea9 100644
--- a/src/server/proto/Client/presence_types.pb.h
+++ b/src/server/proto/Client/presence_types.pb.h
@@ -45,6 +45,7 @@ class RichPresenceLocalizationKey;
 class FieldKey;
 class Field;
 class FieldOperation;
+class PresenceState;
 class ChannelState;
 
 enum FieldOperation_OperationType {
@@ -484,6 +485,100 @@ class TC_PROTO_API FieldOperation : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
+class TC_PROTO_API PresenceState : public ::google::protobuf::Message {
+ public:
+  PresenceState();
+  virtual ~PresenceState();
+
+  PresenceState(const PresenceState& from);
+
+  inline PresenceState& operator=(const PresenceState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PresenceState& default_instance();
+
+  void Swap(PresenceState* other);
+
+  // implements Message ----------------------------------------------
+
+  PresenceState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PresenceState& from);
+  void MergeFrom(const PresenceState& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  inline int field_operation_size() const;
+  inline void clear_field_operation();
+  static const int kFieldOperationFieldNumber = 2;
+  inline const ::bgs::protocol::presence::v1::FieldOperation& field_operation(int index) const;
+  inline ::bgs::protocol::presence::v1::FieldOperation* mutable_field_operation(int index);
+  inline ::bgs::protocol::presence::v1::FieldOperation* add_field_operation();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >&
+      field_operation() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >*
+      mutable_field_operation();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.PresenceState)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation > field_operation_;
+  friend void TC_PROTO_API protobuf_AddDesc_presence_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_presence_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_presence_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static PresenceState* default_instance_;
+};
+// -------------------------------------------------------------------
+
 class TC_PROTO_API ChannelState : public ::google::protobuf::Message {
  public:
   ChannelState();
@@ -930,6 +1025,81 @@ inline void FieldOperation::set_operation(::bgs::protocol::presence::v1::FieldOp
 
 // -------------------------------------------------------------------
 
+// PresenceState
+
+// optional .bgs.protocol.EntityId entity_id = 1;
+inline bool PresenceState::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PresenceState::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PresenceState::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PresenceState::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& PresenceState::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.PresenceState.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* PresenceState::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.PresenceState.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* PresenceState::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void PresenceState::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.PresenceState.entity_id)
+}
+
+// repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+inline int PresenceState::field_operation_size() const {
+  return field_operation_.size();
+}
+inline void PresenceState::clear_field_operation() {
+  field_operation_.Clear();
+}
+inline const ::bgs::protocol::presence::v1::FieldOperation& PresenceState::field_operation(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.PresenceState.field_operation)
+  return field_operation_.Get(index);
+}
+inline ::bgs::protocol::presence::v1::FieldOperation* PresenceState::mutable_field_operation(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.PresenceState.field_operation)
+  return field_operation_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::FieldOperation* PresenceState::add_field_operation() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.PresenceState.field_operation)
+  return field_operation_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >&
+PresenceState::field_operation() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.PresenceState.field_operation)
+  return field_operation_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >*
+PresenceState::mutable_field_operation() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.PresenceState.field_operation)
+  return &field_operation_;
+}
+
+// -------------------------------------------------------------------
+
 // ChannelState
 
 // optional .bgs.protocol.EntityId entity_id = 1;
diff --git a/src/server/proto/Client/report_service.pb.cc b/src/server/proto/Client/report_service.pb.cc
index 8d14de09c83..7a32bfbff79 100644
--- a/src/server/proto/Client/report_service.pb.cc
+++ b/src/server/proto/Client/report_service.pb.cc
@@ -45,8 +45,9 @@ void protobuf_AssignDesc_report_5fservice_2eproto() {
       "report_service.proto");
   GOOGLE_CHECK(file != NULL);
   SendReportRequest_descriptor_ = file->message_type(0);
-  static const int SendReportRequest_offsets_[1] = {
+  static const int SendReportRequest_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendReportRequest, report_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendReportRequest, program_),
   };
   SendReportRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -60,9 +61,10 @@ void protobuf_AssignDesc_report_5fservice_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(SendReportRequest));
   SubmitReportRequest_descriptor_ = file->message_type(1);
-  static const int SubmitReportRequest_offsets_[2] = {
+  static const int SubmitReportRequest_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, agent_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, report_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubmitReportRequest, program_),
   };
   SubmitReportRequest_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -115,18 +117,20 @@ void protobuf_AddDesc_report_5fservice_2eproto() {
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\024report_service.proto\022\026bgs.protocol.rep"
     "ort.v1\032\023account_types.proto\032\022report_type"
-    "s.proto\032\017rpc_types.proto\"C\n\021SendReportRe"
+    "s.proto\032\017rpc_types.proto\"T\n\021SendReportRe"
     "quest\022.\n\006report\030\001 \002(\0132\036.bgs.protocol.rep"
-    "ort.v1.Report\"\214\001\n\023SubmitReportRequest\022<\n"
-    "\010agent_id\030\001 \001(\0132*.bgs.protocol.account.v"
-    "1.GameAccountHandle\0227\n\013report_type\030\002 \001(\013"
-    "2\".bgs.protocol.report.v1.ReportType2\344\001\n"
-    "\rReportService\022S\n\nSendReport\022).bgs.proto"
-    "col.report.v1.SendReportRequest\032\024.bgs.pr"
-    "otocol.NoData\"\004\200\265\030\001\022W\n\014SubmitReport\022+.bg"
-    "s.protocol.report.v1.SubmitReportRequest"
-    "\032\024.bgs.protocol.NoData\"\004\200\265\030\002\032%\312>\"bnet.pr"
-    "otocol.report.ReportServiceB\005H\001\200\001\000", 554);
+    "ort.v1.Report\022\017\n\007program\030\002 \001(\r\"\235\001\n\023Submi"
+    "tReportRequest\022<\n\010agent_id\030\001 \001(\0132*.bgs.p"
+    "rotocol.account.v1.GameAccountHandle\0227\n\013"
+    "report_type\030\002 \001(\0132\".bgs.protocol.report."
+    "v1.ReportType\022\017\n\007program\030\003 \001(\r2\371\001\n\rRepor"
+    "tService\022U\n\nSendReport\022).bgs.protocol.re"
+    "port.v1.SendReportRequest\032\024.bgs.protocol"
+    ".NoData\"\006\202\371+\002\010\001\022Y\n\014SubmitReport\022+.bgs.pr"
+    "otocol.report.v1.SubmitReportRequest\032\024.b"
+    "gs.protocol.NoData\"\006\202\371+\002\010\002\0326\202\371+,\n\"bnet.p"
+    "rotocol.report.ReportService*\006report\212\371+\002"
+    "\020\001B\005H\001\200\001\000", 609);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "report_service.proto", &protobuf_RegisterTypes);
   SendReportRequest::default_instance_ = new SendReportRequest();
@@ -147,6 +151,7 @@ struct StaticDescriptorInitializer_report_5fservice_2eproto {
 
 #ifndef _MSC_VER
 const int SendReportRequest::kReportFieldNumber;
+const int SendReportRequest::kProgramFieldNumber;
 #endif  // !_MSC_VER
 
 SendReportRequest::SendReportRequest()
@@ -169,6 +174,7 @@ SendReportRequest::SendReportRequest(const SendReportRequest& from)
 void SendReportRequest::SharedCtor() {
   _cached_size_ = 0;
   report_ = NULL;
+  program_ = 0u;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -205,8 +211,11 @@ SendReportRequest* SendReportRequest::New() const {
 }
 
 void SendReportRequest::Clear() {
-  if (has_report()) {
-    if (report_ != NULL) report_->::bgs::protocol::report::v1::Report::Clear();
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_report()) {
+      if (report_ != NULL) report_->::bgs::protocol::report::v1::Report::Clear();
+    }
+    program_ = 0u;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -230,6 +239,21 @@ bool SendReportRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(16)) goto parse_program;
+        break;
+      }
+
+      // optional uint32 program = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -265,6 +289,11 @@ void SendReportRequest::SerializeWithCachedSizes(
       1, this->report(), output);
   }
 
+  // optional uint32 program = 2;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->program(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -282,6 +311,11 @@ void SendReportRequest::SerializeWithCachedSizes(
         1, this->report(), target);
   }
 
+  // optional uint32 program = 2;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->program(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -301,6 +335,13 @@ int SendReportRequest::ByteSize() const {
           this->report());
     }
 
+    // optional uint32 program = 2;
+    if (has_program()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->program());
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -331,6 +372,9 @@ void SendReportRequest::MergeFrom(const SendReportRequest& from) {
     if (from.has_report()) {
       mutable_report()->::bgs::protocol::report::v1::Report::MergeFrom(from.report());
     }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -359,6 +403,7 @@ bool SendReportRequest::IsInitialized() const {
 void SendReportRequest::Swap(SendReportRequest* other) {
   if (other != this) {
     std::swap(report_, other->report_);
+    std::swap(program_, other->program_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
@@ -379,6 +424,7 @@ void SendReportRequest::Swap(SendReportRequest* other) {
 #ifndef _MSC_VER
 const int SubmitReportRequest::kAgentIdFieldNumber;
 const int SubmitReportRequest::kReportTypeFieldNumber;
+const int SubmitReportRequest::kProgramFieldNumber;
 #endif  // !_MSC_VER
 
 SubmitReportRequest::SubmitReportRequest()
@@ -403,6 +449,7 @@ void SubmitReportRequest::SharedCtor() {
   _cached_size_ = 0;
   agent_id_ = NULL;
   report_type_ = NULL;
+  program_ = 0u;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -440,13 +487,14 @@ SubmitReportRequest* SubmitReportRequest::New() const {
 }
 
 void SubmitReportRequest::Clear() {
-  if (_has_bits_[0 / 32] & 3) {
+  if (_has_bits_[0 / 32] & 7) {
     if (has_agent_id()) {
       if (agent_id_ != NULL) agent_id_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
     }
     if (has_report_type()) {
       if (report_type_ != NULL) report_type_->::bgs::protocol::report::v1::ReportType::Clear();
     }
+    program_ = 0u;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -483,6 +531,21 @@ bool SubmitReportRequest::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
+        if (input->ExpectTag(24)) goto parse_program;
+        break;
+      }
+
+      // optional uint32 program = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
@@ -524,6 +587,11 @@ void SubmitReportRequest::SerializeWithCachedSizes(
       2, this->report_type(), output);
   }
 
+  // optional uint32 program = 3;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->program(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -548,6 +616,11 @@ void SubmitReportRequest::SerializeWithCachedSizes(
         2, this->report_type(), target);
   }
 
+  // optional uint32 program = 3;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->program(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -574,6 +647,13 @@ int SubmitReportRequest::ByteSize() const {
           this->report_type());
     }
 
+    // optional uint32 program = 3;
+    if (has_program()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->program());
+    }
+
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -607,6 +687,9 @@ void SubmitReportRequest::MergeFrom(const SubmitReportRequest& from) {
     if (from.has_report_type()) {
       mutable_report_type()->::bgs::protocol::report::v1::ReportType::MergeFrom(from.report_type());
     }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -638,6 +721,7 @@ void SubmitReportRequest::Swap(SubmitReportRequest* other) {
   if (other != this) {
     std::swap(agent_id_, other->agent_id_);
     std::swap(report_type_, other->report_type_);
+    std::swap(program_, other->program_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
diff --git a/src/server/proto/Client/report_service.pb.h b/src/server/proto/Client/report_service.pb.h
index 10ec0a2a620..a7b722c077e 100644
--- a/src/server/proto/Client/report_service.pb.h
+++ b/src/server/proto/Client/report_service.pb.h
@@ -110,16 +110,26 @@ class TC_PROTO_API SendReportRequest : public ::google::protobuf::Message {
   inline ::bgs::protocol::report::v1::Report* release_report();
   inline void set_allocated_report(::bgs::protocol::report::v1::Report* report);
 
+  // optional uint32 program = 2;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 2;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.SendReportRequest)
  private:
   inline void set_has_report();
   inline void clear_has_report();
+  inline void set_has_program();
+  inline void clear_has_program();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
   ::bgs::protocol::report::v1::Report* report_;
+  ::google::protobuf::uint32 program_;
   friend void TC_PROTO_API protobuf_AddDesc_report_5fservice_2eproto();
   friend void protobuf_AssignDesc_report_5fservice_2eproto();
   friend void protobuf_ShutdownFile_report_5fservice_2eproto();
@@ -200,12 +210,21 @@ class TC_PROTO_API SubmitReportRequest : public ::google::protobuf::Message {
   inline ::bgs::protocol::report::v1::ReportType* release_report_type();
   inline void set_allocated_report_type(::bgs::protocol::report::v1::ReportType* report_type);
 
+  // optional uint32 program = 3;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 3;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
   // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.SubmitReportRequest)
  private:
   inline void set_has_agent_id();
   inline void clear_has_agent_id();
   inline void set_has_report_type();
   inline void clear_has_report_type();
+  inline void set_has_program();
+  inline void clear_has_program();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -213,6 +232,7 @@ class TC_PROTO_API SubmitReportRequest : public ::google::protobuf::Message {
   mutable int _cached_size_;
   ::bgs::protocol::account::v1::GameAccountHandle* agent_id_;
   ::bgs::protocol::report::v1::ReportType* report_type_;
+  ::google::protobuf::uint32 program_;
   friend void TC_PROTO_API protobuf_AddDesc_report_5fservice_2eproto();
   friend void protobuf_AssignDesc_report_5fservice_2eproto();
   friend void protobuf_ShutdownFile_report_5fservice_2eproto();
@@ -300,6 +320,30 @@ inline void SendReportRequest::set_allocated_report(::bgs::protocol::report::v1:
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.SendReportRequest.report)
 }
 
+// optional uint32 program = 2;
+inline bool SendReportRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SendReportRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SendReportRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SendReportRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 SendReportRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.SendReportRequest.program)
+  return program_;
+}
+inline void SendReportRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.SendReportRequest.program)
+}
+
 // -------------------------------------------------------------------
 
 // SubmitReportRequest
@@ -386,6 +430,30 @@ inline void SubmitReportRequest::set_allocated_report_type(::bgs::protocol::repo
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.SubmitReportRequest.report_type)
 }
 
+// optional uint32 program = 3;
+inline bool SubmitReportRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SubmitReportRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SubmitReportRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SubmitReportRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 SubmitReportRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.SubmitReportRequest.program)
+  return program_;
+}
+inline void SubmitReportRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.SubmitReportRequest.program)
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/src/server/proto/Client/report_types.pb.cc b/src/server/proto/Client/report_types.pb.cc
index 1fc8c19ce23..b20a101b7b7 100644
--- a/src/server/proto/Client/report_types.pb.cc
+++ b/src/server/proto/Client/report_types.pb.cc
@@ -74,7 +74,7 @@ void protobuf_AssignDesc_report_5ftypes_2eproto() {
   GOOGLE_CHECK(file != NULL);
   ReportType_descriptor_ = file->message_type(0);
   static const int ReportType_offsets_[9] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReportType, note_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReportType, user_description_),
     PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ReportType_default_oneof_instance_, custom_report_),
     PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ReportType_default_oneof_instance_, spam_report_),
     PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(ReportType_default_oneof_instance_, harassment_report_),
@@ -100,7 +100,7 @@ void protobuf_AssignDesc_report_5ftypes_2eproto() {
   CustomReport_descriptor_ = file->message_type(1);
   static const int CustomReport_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CustomReport, type_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CustomReport, programid_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CustomReport, program_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CustomReport, attribute_),
   };
   CustomReport_reflection_ =
@@ -299,45 +299,46 @@ void protobuf_AddDesc_report_5ftypes_2eproto() {
     "\n\022report_types.proto\022\026bgs.protocol.repor"
     "t.v1\032\023account_types.proto\032\025attribute_typ"
     "es.proto\032\022entity_types.proto\032\017rpc_types."
-    "proto\"\227\004\n\nReportType\022\014\n\004note\030\001 \001(\t\022=\n\rcu"
-    "stom_report\030\n \001(\0132$.bgs.protocol.report."
-    "v1.CustomReportH\000\0229\n\013spam_report\030\013 \001(\0132\""
-    ".bgs.protocol.report.v1.SpamReportH\000\022E\n\021"
-    "harassment_report\030\014 \001(\0132(.bgs.protocol.r"
-    "eport.v1.HarassmentReportH\000\022O\n\027real_life"
-    "_threat_report\030\r \001(\0132,.bgs.protocol.repo"
-    "rt.v1.RealLifeThreatReportH\000\022_\n\037inapprop"
-    "riate_battle_tag_report\030\016 \001(\01324.bgs.prot"
-    "ocol.report.v1.InappropriateBattleTagRep"
-    "ortH\000\022\?\n\016hacking_report\030\017 \001(\0132%.bgs.prot"
-    "ocol.report.v1.HackingReportH\000\022\?\n\016bottin"
-    "g_report\030\020 \001(\0132%.bgs.protocol.report.v1."
-    "BottingReportH\000B\006\n\004type\"[\n\014CustomReport\022"
-    "\014\n\004type\030\001 \001(\t\022\021\n\tprogramId\030\002 \001(\t\022*\n\tattr"
-    "ibute\030\003 \003(\0132\027.bgs.protocol.Attribute\"\321\001\n"
-    "\nSpamReport\022:\n\006target\030\001 \001(\0132*.bgs.protoc"
-    "ol.account.v1.GameAccountHandle\022D\n\006sourc"
-    "e\030\002 \001(\0162-.bgs.protocol.report.v1.SpamRep"
-    "ort.SpamSource:\005OTHER\"A\n\nSpamSource\022\t\n\005O"
-    "THER\020\001\022\021\n\rFRIEND_INVITE\020\002\022\013\n\007WHISPER\020\003\022\010"
-    "\n\004CHAT\020\004\"\\\n\020HarassmentReport\022:\n\006target\030\001"
+    "proto\"\243\004\n\nReportType\022\030\n\020user_description"
+    "\030\001 \001(\t\022=\n\rcustom_report\030\n \001(\0132$.bgs.prot"
+    "ocol.report.v1.CustomReportH\000\0229\n\013spam_re"
+    "port\030\013 \001(\0132\".bgs.protocol.report.v1.Spam"
+    "ReportH\000\022E\n\021harassment_report\030\014 \001(\0132(.bg"
+    "s.protocol.report.v1.HarassmentReportH\000\022"
+    "O\n\027real_life_threat_report\030\r \001(\0132,.bgs.p"
+    "rotocol.report.v1.RealLifeThreatReportH\000"
+    "\022_\n\037inappropriate_battle_tag_report\030\016 \001("
+    "\01324.bgs.protocol.report.v1.Inappropriate"
+    "BattleTagReportH\000\022\?\n\016hacking_report\030\017 \001("
+    "\0132%.bgs.protocol.report.v1.HackingReport"
+    "H\000\022\?\n\016botting_report\030\020 \001(\0132%.bgs.protoco"
+    "l.report.v1.BottingReportH\000B\006\n\004type\"`\n\014C"
+    "ustomReport\022\014\n\004type\030\001 \001(\t\022\026\n\nprogram_id\030"
+    "\002 \001(\tB\002\030\001\022*\n\tattribute\030\003 \003(\0132\027.bgs.proto"
+    "col.Attribute\"\325\001\n\nSpamReport\022:\n\006target\030\001"
     " \001(\0132*.bgs.protocol.account.v1.GameAccou"
-    "ntHandle\022\014\n\004text\030\002 \001(\t\"`\n\024RealLifeThreat"
-    "Report\022:\n\006target\030\001 \001(\0132*.bgs.protocol.ac"
-    "count.v1.GameAccountHandle\022\014\n\004text\030\002 \001(\t"
-    "\"n\n\034InappropriateBattleTagReport\022:\n\006targ"
-    "et\030\001 \001(\0132*.bgs.protocol.account.v1.GameA"
-    "ccountHandle\022\022\n\nbattle_tag\030\002 \001(\t\"K\n\rHack"
-    "ingReport\022:\n\006target\030\001 \001(\0132*.bgs.protocol"
-    ".account.v1.GameAccountHandle\"K\n\rBotting"
-    "Report\022:\n\006target\030\001 \001(\0132*.bgs.protocol.ac"
-    "count.v1.GameAccountHandle\"\345\001\n\006Report\022\023\n"
-    "\013report_type\030\001 \002(\t\022*\n\tattribute\030\002 \003(\0132\027."
-    "bgs.protocol.Attribute\022\025\n\nreport_qos\030\003 \001"
-    "(\005:\0010\0221\n\021reporting_account\030\004 \001(\0132\026.bgs.p"
-    "rotocol.EntityId\0226\n\026reporting_game_accou"
-    "nt\030\005 \001(\0132\026.bgs.protocol.EntityId\022\030\n\020repo"
-    "rt_timestamp\030\006 \001(\006B\005H\001\200\001\000", 1665);
+    "ntHandle\022D\n\006source\030\002 \001(\0162-.bgs.protocol."
+    "report.v1.SpamReport.SpamSource:\005OTHER\"E"
+    "\n\nSpamSource\022\t\n\005OTHER\020\001\022\025\n\021FRIEND_INVITA"
+    "TION\020\002\022\013\n\007WHISPER\020\003\022\010\n\004CHAT\020\004\"\\\n\020Harassm"
+    "entReport\022:\n\006target\030\001 \001(\0132*.bgs.protocol"
+    ".account.v1.GameAccountHandle\022\014\n\004text\030\002 "
+    "\001(\t\"`\n\024RealLifeThreatReport\022:\n\006target\030\001 "
+    "\001(\0132*.bgs.protocol.account.v1.GameAccoun"
+    "tHandle\022\014\n\004text\030\002 \001(\t\"n\n\034InappropriateBa"
+    "ttleTagReport\022:\n\006target\030\001 \001(\0132*.bgs.prot"
+    "ocol.account.v1.GameAccountHandle\022\022\n\nbat"
+    "tle_tag\030\002 \001(\t\"K\n\rHackingReport\022:\n\006target"
+    "\030\001 \001(\0132*.bgs.protocol.account.v1.GameAcc"
+    "ountHandle\"K\n\rBottingReport\022:\n\006target\030\001 "
+    "\001(\0132*.bgs.protocol.account.v1.GameAccoun"
+    "tHandle\"\345\001\n\006Report\022\023\n\013report_type\030\001 \002(\t\022"
+    "*\n\tattribute\030\002 \003(\0132\027.bgs.protocol.Attrib"
+    "ute\022\025\n\nreport_qos\030\003 \001(\005:\0010\0221\n\021reporting_"
+    "account\030\004 \001(\0132\026.bgs.protocol.EntityId\0226\n"
+    "\026reporting_game_account\030\005 \001(\0132\026.bgs.prot"
+    "ocol.EntityId\022\030\n\020report_timestamp\030\006 \001(\006B"
+    "\005H\001\200\001\000", 1686);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "report_types.proto", &protobuf_RegisterTypes);
   ReportType::default_instance_ = new ReportType();
@@ -372,7 +373,7 @@ struct StaticDescriptorInitializer_report_5ftypes_2eproto {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int ReportType::kNoteFieldNumber;
+const int ReportType::kUserDescriptionFieldNumber;
 const int ReportType::kCustomReportFieldNumber;
 const int ReportType::kSpamReportFieldNumber;
 const int ReportType::kHarassmentReportFieldNumber;
@@ -408,7 +409,7 @@ ReportType::ReportType(const ReportType& from)
 void ReportType::SharedCtor() {
   ::google::protobuf::internal::GetEmptyString();
   _cached_size_ = 0;
-  note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  user_description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   clear_has_type();
 }
@@ -419,8 +420,8 @@ ReportType::~ReportType() {
 }
 
 void ReportType::SharedDtor() {
-  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete note_;
+  if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete user_description_;
   }
   if (has_type()) {
     clear_type();
@@ -489,9 +490,9 @@ void ReportType::clear_type() {
 
 
 void ReportType::Clear() {
-  if (has_note()) {
-    if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-      note_->clear();
+  if (has_user_description()) {
+    if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      user_description_->clear();
     }
   }
   clear_type();
@@ -509,15 +510,15 @@ bool ReportType::MergePartialFromCodedStream(
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string note = 1;
+      // optional string user_description = 1;
       case 1: {
         if (tag == 10) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_note()));
+                input, this->mutable_user_description()));
           ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->note().data(), this->note().length(),
+            this->user_description().data(), this->user_description().length(),
             ::google::protobuf::internal::WireFormat::PARSE,
-            "note");
+            "user_description");
         } else {
           goto handle_unusual;
         }
@@ -641,14 +642,14 @@ failure:
 void ReportType::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // @@protoc_insertion_point(serialize_start:bgs.protocol.report.v1.ReportType)
-  // optional string note = 1;
-  if (has_note()) {
+  // optional string user_description = 1;
+  if (has_user_description()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->note().data(), this->note().length(),
+      this->user_description().data(), this->user_description().length(),
       ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "note");
+      "user_description");
     ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->note(), output);
+      1, this->user_description(), output);
   }
 
   // optional .bgs.protocol.report.v1.CustomReport custom_report = 10;
@@ -703,15 +704,15 @@ void ReportType::SerializeWithCachedSizes(
 ::google::protobuf::uint8* ReportType::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
   // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.report.v1.ReportType)
-  // optional string note = 1;
-  if (has_note()) {
+  // optional string user_description = 1;
+  if (has_user_description()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->note().data(), this->note().length(),
+      this->user_description().data(), this->user_description().length(),
       ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "note");
+      "user_description");
     target =
       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->note(), target);
+        1, this->user_description(), target);
   }
 
   // optional .bgs.protocol.report.v1.CustomReport custom_report = 10;
@@ -775,11 +776,11 @@ int ReportType::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional string note = 1;
-    if (has_note()) {
+    // optional string user_description = 1;
+    if (has_user_description()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->note());
+          this->user_description());
     }
 
   }
@@ -896,8 +897,8 @@ void ReportType::MergeFrom(const ReportType& from) {
     }
   }
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_note()) {
-      set_note(from.note());
+    if (from.has_user_description()) {
+      set_user_description(from.user_description());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
@@ -943,7 +944,7 @@ bool ReportType::IsInitialized() const {
 
 void ReportType::Swap(ReportType* other) {
   if (other != this) {
-    std::swap(note_, other->note_);
+    std::swap(user_description_, other->user_description_);
     std::swap(type_, other->type_);
     std::swap(_oneof_case_[0], other->_oneof_case_[0]);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
@@ -989,7 +990,7 @@ void CustomReport::SharedCtor() {
   ::google::protobuf::internal::GetEmptyString();
   _cached_size_ = 0;
   type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  programid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  program_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -1002,8 +1003,8 @@ void CustomReport::SharedDtor() {
   if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete type_;
   }
-  if (programid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete programid_;
+  if (program_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete program_id_;
   }
   if (this != default_instance_) {
   }
@@ -1037,9 +1038,9 @@ void CustomReport::Clear() {
         type_->clear();
       }
     }
-    if (has_programid()) {
-      if (programid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        programid_->clear();
+    if (has_program_id()) {
+      if (program_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        program_id_->clear();
       }
     }
   }
@@ -1070,20 +1071,20 @@ bool CustomReport::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(18)) goto parse_programId;
+        if (input->ExpectTag(18)) goto parse_program_id;
         break;
       }
 
-      // optional string programId = 2;
+      // optional string program_id = 2 [deprecated = true];
       case 2: {
         if (tag == 18) {
-         parse_programId:
+         parse_program_id:
           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_programid()));
+                input, this->mutable_program_id()));
           ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->programid().data(), this->programid().length(),
+            this->program_id().data(), this->program_id().length(),
             ::google::protobuf::internal::WireFormat::PARSE,
-            "programid");
+            "program_id");
         } else {
           goto handle_unusual;
         }
@@ -1140,14 +1141,14 @@ void CustomReport::SerializeWithCachedSizes(
       1, this->type(), output);
   }
 
-  // optional string programId = 2;
-  if (has_programid()) {
+  // optional string program_id = 2 [deprecated = true];
+  if (has_program_id()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->programid().data(), this->programid().length(),
+      this->program_id().data(), this->program_id().length(),
       ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "programid");
+      "program_id");
     ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->programid(), output);
+      2, this->program_id(), output);
   }
 
   // repeated .bgs.protocol.Attribute attribute = 3;
@@ -1177,15 +1178,15 @@ void CustomReport::SerializeWithCachedSizes(
         1, this->type(), target);
   }
 
-  // optional string programId = 2;
-  if (has_programid()) {
+  // optional string program_id = 2 [deprecated = true];
+  if (has_program_id()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->programid().data(), this->programid().length(),
+      this->program_id().data(), this->program_id().length(),
       ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "programid");
+      "program_id");
     target =
       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->programid(), target);
+        2, this->program_id(), target);
   }
 
   // repeated .bgs.protocol.Attribute attribute = 3;
@@ -1214,11 +1215,11 @@ int CustomReport::ByteSize() const {
           this->type());
     }
 
-    // optional string programId = 2;
-    if (has_programid()) {
+    // optional string program_id = 2 [deprecated = true];
+    if (has_program_id()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->programid());
+          this->program_id());
     }
 
   }
@@ -1260,8 +1261,8 @@ void CustomReport::MergeFrom(const CustomReport& from) {
     if (from.has_type()) {
       set_type(from.type());
     }
-    if (from.has_programid()) {
-      set_programid(from.programid());
+    if (from.has_program_id()) {
+      set_program_id(from.program_id());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
@@ -1288,7 +1289,7 @@ bool CustomReport::IsInitialized() const {
 void CustomReport::Swap(CustomReport* other) {
   if (other != this) {
     std::swap(type_, other->type_);
-    std::swap(programid_, other->programid_);
+    std::swap(program_id_, other->program_id_);
     attribute_.Swap(&other->attribute_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
@@ -1325,7 +1326,7 @@ bool SpamReport_SpamSource_IsValid(int value) {
 
 #ifndef _MSC_VER
 const SpamReport_SpamSource SpamReport::OTHER;
-const SpamReport_SpamSource SpamReport::FRIEND_INVITE;
+const SpamReport_SpamSource SpamReport::FRIEND_INVITATION;
 const SpamReport_SpamSource SpamReport::WHISPER;
 const SpamReport_SpamSource SpamReport::CHAT;
 const SpamReport_SpamSource SpamReport::SpamSource_MIN;
diff --git a/src/server/proto/Client/report_types.pb.h b/src/server/proto/Client/report_types.pb.h
index 79a81218660..afcce679dc5 100644
--- a/src/server/proto/Client/report_types.pb.h
+++ b/src/server/proto/Client/report_types.pb.h
@@ -54,7 +54,7 @@ class Report;
 
 enum SpamReport_SpamSource {
   SpamReport_SpamSource_OTHER = 1,
-  SpamReport_SpamSource_FRIEND_INVITE = 2,
+  SpamReport_SpamSource_FRIEND_INVITATION = 2,
   SpamReport_SpamSource_WHISPER = 3,
   SpamReport_SpamSource_CHAT = 4
 };
@@ -139,17 +139,17 @@ class TC_PROTO_API ReportType : public ::google::protobuf::Message {
 
   // accessors -------------------------------------------------------
 
-  // optional string note = 1;
-  inline bool has_note() const;
-  inline void clear_note();
-  static const int kNoteFieldNumber = 1;
-  inline const ::std::string& note() const;
-  inline void set_note(const ::std::string& value);
-  inline void set_note(const char* value);
-  inline void set_note(const char* value, size_t size);
-  inline ::std::string* mutable_note();
-  inline ::std::string* release_note();
-  inline void set_allocated_note(::std::string* note);
+  // optional string user_description = 1;
+  inline bool has_user_description() const;
+  inline void clear_user_description();
+  static const int kUserDescriptionFieldNumber = 1;
+  inline const ::std::string& user_description() const;
+  inline void set_user_description(const ::std::string& value);
+  inline void set_user_description(const char* value);
+  inline void set_user_description(const char* value, size_t size);
+  inline ::std::string* mutable_user_description();
+  inline ::std::string* release_user_description();
+  inline void set_allocated_user_description(::std::string* user_description);
 
   // optional .bgs.protocol.report.v1.CustomReport custom_report = 10;
   inline bool has_custom_report() const;
@@ -217,8 +217,8 @@ class TC_PROTO_API ReportType : public ::google::protobuf::Message {
   inline TypeCase type_case() const;
   // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.ReportType)
  private:
-  inline void set_has_note();
-  inline void clear_has_note();
+  inline void set_has_user_description();
+  inline void clear_has_user_description();
   inline void set_has_custom_report();
   inline void set_has_spam_report();
   inline void set_has_harassment_report();
@@ -235,7 +235,7 @@ class TC_PROTO_API ReportType : public ::google::protobuf::Message {
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
-  ::std::string* note_;
+  ::std::string* user_description_;
   union TypeUnion {
     ::bgs::protocol::report::v1::CustomReport* custom_report_;
     ::bgs::protocol::report::v1::SpamReport* spam_report_;
@@ -321,17 +321,17 @@ class TC_PROTO_API CustomReport : public ::google::protobuf::Message {
   inline ::std::string* release_type();
   inline void set_allocated_type(::std::string* type);
 
-  // optional string programId = 2;
-  inline bool has_programid() const;
-  inline void clear_programid();
+  // optional string program_id = 2 [deprecated = true];
+  inline bool has_program_id() const PROTOBUF_DEPRECATED;
+  inline void clear_program_id() PROTOBUF_DEPRECATED;
   static const int kProgramIdFieldNumber = 2;
-  inline const ::std::string& programid() const;
-  inline void set_programid(const ::std::string& value);
-  inline void set_programid(const char* value);
-  inline void set_programid(const char* value, size_t size);
-  inline ::std::string* mutable_programid();
-  inline ::std::string* release_programid();
-  inline void set_allocated_programid(::std::string* programid);
+  inline const ::std::string& program_id() const PROTOBUF_DEPRECATED;
+  inline void set_program_id(const ::std::string& value) PROTOBUF_DEPRECATED;
+  inline void set_program_id(const char* value) PROTOBUF_DEPRECATED;
+  inline void set_program_id(const char* value, size_t size) PROTOBUF_DEPRECATED;
+  inline ::std::string* mutable_program_id() PROTOBUF_DEPRECATED;
+  inline ::std::string* release_program_id() PROTOBUF_DEPRECATED;
+  inline void set_allocated_program_id(::std::string* program_id) PROTOBUF_DEPRECATED;
 
   // repeated .bgs.protocol.Attribute attribute = 3;
   inline int attribute_size() const;
@@ -349,15 +349,15 @@ class TC_PROTO_API CustomReport : public ::google::protobuf::Message {
  private:
   inline void set_has_type();
   inline void clear_has_type();
-  inline void set_has_programid();
-  inline void clear_has_programid();
+  inline void set_has_program_id();
+  inline void clear_has_program_id();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
   ::std::string* type_;
-  ::std::string* programid_;
+  ::std::string* program_id_;
   ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
   friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
   friend void protobuf_AssignDesc_report_5ftypes_2eproto();
@@ -421,7 +421,7 @@ class TC_PROTO_API SpamReport : public ::google::protobuf::Message {
 
   typedef SpamReport_SpamSource SpamSource;
   static const SpamSource OTHER = SpamReport_SpamSource_OTHER;
-  static const SpamSource FRIEND_INVITE = SpamReport_SpamSource_FRIEND_INVITE;
+  static const SpamSource FRIEND_INVITATION = SpamReport_SpamSource_FRIEND_INVITATION;
   static const SpamSource WHISPER = SpamReport_SpamSource_WHISPER;
   static const SpamSource CHAT = SpamReport_SpamSource_CHAT;
   static inline bool SpamSource_IsValid(int value) {
@@ -1084,80 +1084,80 @@ class TC_PROTO_API Report : public ::google::protobuf::Message {
 
 // ReportType
 
-// optional string note = 1;
-inline bool ReportType::has_note() const {
+// optional string user_description = 1;
+inline bool ReportType::has_user_description() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
-inline void ReportType::set_has_note() {
+inline void ReportType::set_has_user_description() {
   _has_bits_[0] |= 0x00000001u;
 }
-inline void ReportType::clear_has_note() {
+inline void ReportType::clear_has_user_description() {
   _has_bits_[0] &= ~0x00000001u;
 }
-inline void ReportType::clear_note() {
-  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    note_->clear();
+inline void ReportType::clear_user_description() {
+  if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_->clear();
   }
-  clear_has_note();
+  clear_has_user_description();
 }
-inline const ::std::string& ReportType::note() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.ReportType.note)
-  return *note_;
+inline const ::std::string& ReportType::user_description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.ReportType.user_description)
+  return *user_description_;
 }
-inline void ReportType::set_note(const ::std::string& value) {
-  set_has_note();
-  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    note_ = new ::std::string;
+inline void ReportType::set_user_description(const ::std::string& value) {
+  set_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_ = new ::std::string;
   }
-  note_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.ReportType.note)
+  user_description_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.ReportType.user_description)
 }
-inline void ReportType::set_note(const char* value) {
-  set_has_note();
-  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    note_ = new ::std::string;
+inline void ReportType::set_user_description(const char* value) {
+  set_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_ = new ::std::string;
   }
-  note_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.ReportType.note)
+  user_description_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.ReportType.user_description)
 }
-inline void ReportType::set_note(const char* value, size_t size) {
-  set_has_note();
-  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    note_ = new ::std::string;
+inline void ReportType::set_user_description(const char* value, size_t size) {
+  set_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_ = new ::std::string;
   }
-  note_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.ReportType.note)
+  user_description_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.ReportType.user_description)
 }
-inline ::std::string* ReportType::mutable_note() {
-  set_has_note();
-  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    note_ = new ::std::string;
+inline ::std::string* ReportType::mutable_user_description() {
+  set_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    user_description_ = new ::std::string;
   }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.ReportType.note)
-  return note_;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.ReportType.user_description)
+  return user_description_;
 }
-inline ::std::string* ReportType::release_note() {
-  clear_has_note();
-  if (note_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+inline ::std::string* ReportType::release_user_description() {
+  clear_has_user_description();
+  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     return NULL;
   } else {
-    ::std::string* temp = note_;
-    note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    ::std::string* temp = user_description_;
+    user_description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
     return temp;
   }
 }
-inline void ReportType::set_allocated_note(::std::string* note) {
-  if (note_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete note_;
+inline void ReportType::set_allocated_user_description(::std::string* user_description) {
+  if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete user_description_;
   }
-  if (note) {
-    set_has_note();
-    note_ = note;
+  if (user_description) {
+    set_has_user_description();
+    user_description_ = user_description;
   } else {
-    clear_has_note();
-    note_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    clear_has_user_description();
+    user_description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.ReportType.note)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.ReportType.user_description)
 }
 
 // optional .bgs.protocol.report.v1.CustomReport custom_report = 10;
@@ -1550,80 +1550,80 @@ inline void CustomReport::set_allocated_type(::std::string* type) {
   // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.CustomReport.type)
 }
 
-// optional string programId = 2;
-inline bool CustomReport::has_programid() const {
+// optional string program_id = 2 [deprecated = true];
+inline bool CustomReport::has_program_id() const {
   return (_has_bits_[0] & 0x00000002u) != 0;
 }
-inline void CustomReport::set_has_programid() {
+inline void CustomReport::set_has_program_id() {
   _has_bits_[0] |= 0x00000002u;
 }
-inline void CustomReport::clear_has_programid() {
+inline void CustomReport::clear_has_program_id() {
   _has_bits_[0] &= ~0x00000002u;
 }
-inline void CustomReport::clear_programid() {
-  if (programid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    programid_->clear();
+inline void CustomReport::clear_program_id() {
+  if (program_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    program_id_->clear();
   }
-  clear_has_programid();
+  clear_has_program_id();
 }
-inline const ::std::string& CustomReport::programid() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.CustomReport.programId)
-  return *programid_;
+inline const ::std::string& CustomReport::program_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.CustomReport.program_id)
+  return *program_id_;
 }
-inline void CustomReport::set_programid(const ::std::string& value) {
-  set_has_programid();
-  if (programid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    programid_ = new ::std::string;
+inline void CustomReport::set_program_id(const ::std::string& value) {
+  set_has_program_id();
+  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    program_id_ = new ::std::string;
   }
-  programid_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.CustomReport.programId)
+  program_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.CustomReport.program_id)
 }
-inline void CustomReport::set_programid(const char* value) {
-  set_has_programid();
-  if (programid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    programid_ = new ::std::string;
+inline void CustomReport::set_program_id(const char* value) {
+  set_has_program_id();
+  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    program_id_ = new ::std::string;
   }
-  programid_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.CustomReport.programId)
+  program_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.CustomReport.program_id)
 }
-inline void CustomReport::set_programid(const char* value, size_t size) {
-  set_has_programid();
-  if (programid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    programid_ = new ::std::string;
+inline void CustomReport::set_program_id(const char* value, size_t size) {
+  set_has_program_id();
+  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    program_id_ = new ::std::string;
   }
-  programid_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.CustomReport.programId)
+  program_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.CustomReport.program_id)
 }
-inline ::std::string* CustomReport::mutable_programid() {
-  set_has_programid();
-  if (programid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    programid_ = new ::std::string;
+inline ::std::string* CustomReport::mutable_program_id() {
+  set_has_program_id();
+  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    program_id_ = new ::std::string;
   }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.CustomReport.programId)
-  return programid_;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.CustomReport.program_id)
+  return program_id_;
 }
-inline ::std::string* CustomReport::release_programid() {
-  clear_has_programid();
-  if (programid_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+inline ::std::string* CustomReport::release_program_id() {
+  clear_has_program_id();
+  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     return NULL;
   } else {
-    ::std::string* temp = programid_;
-    programid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    ::std::string* temp = program_id_;
+    program_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
     return temp;
   }
 }
-inline void CustomReport::set_allocated_programid(::std::string* programid) {
-  if (programid_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete programid_;
+inline void CustomReport::set_allocated_program_id(::std::string* program_id) {
+  if (program_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete program_id_;
   }
-  if (programid) {
-    set_has_programid();
-    programid_ = programid;
+  if (program_id) {
+    set_has_program_id();
+    program_id_ = program_id;
   } else {
-    clear_has_programid();
-    programid_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    clear_has_program_id();
+    program_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.CustomReport.programId)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.CustomReport.program_id)
 }
 
 // repeated .bgs.protocol.Attribute attribute = 3;
diff --git a/src/server/proto/Client/resource_service.pb.cc b/src/server/proto/Client/resource_service.pb.cc
index 260a88eac89..bece2a03a26 100644
--- a/src/server/proto/Client/resource_service.pb.cc
+++ b/src/server/proto/Client/resource_service.pb.cc
@@ -93,13 +93,14 @@ void protobuf_AddDesc_resource_5fservice_2eproto() {
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\026resource_service.proto\022\031bgs.protocol.r"
     "esources.v1\032\032content_handle_types.proto\032"
-    "\017rpc_types.proto\"T\n\024ContentHandleRequest"
+    "\017rpc_types.proto\"\\\n\024ContentHandleRequest"
     "\022\017\n\007program\030\001 \002(\007\022\016\n\006stream\030\002 \002(\007\022\033\n\007ver"
-    "sion\030\003 \001(\007:\n17017296192\240\001\n\020ResourcesServ"
-    "ice\022f\n\020GetContentHandle\022/.bgs.protocol.r"
-    "esources.v1.ContentHandleRequest\032\033.bgs.p"
-    "rotocol.ContentHandle\"\004\200\265\030\001\032$\312>!bnet.pro"
-    "tocol.resources.ResourcesB\005H\001\200\001\000", 352);
+    "sion\030\003 \001(\007:\n1701729619:\006\202\371+\002\010\0012\253\001\n\020Resou"
+    "rcesService\022h\n\020GetContentHandle\022/.bgs.pr"
+    "otocol.resources.v1.ContentHandleRequest"
+    "\032\033.bgs.protocol.ContentHandle\"\006\202\371+\002\010\001\032-\202"
+    "\371+#\n!bnet.protocol.resources.Resources\212\371"
+    "+\002\020\001B\005H\001\200\001\000", 371);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "resource_service.proto", &protobuf_RegisterTypes);
   ContentHandleRequest::default_instance_ = new ContentHandleRequest();
diff --git a/src/server/proto/Client/role_types.pb.cc b/src/server/proto/Client/role_types.pb.cc
index b44aa779a3b..6a04b33ceac 100644
--- a/src/server/proto/Client/role_types.pb.cc
+++ b/src/server/proto/Client/role_types.pb.cc
@@ -26,6 +26,9 @@ namespace {
 const ::google::protobuf::Descriptor* Role_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   Role_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RoleState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RoleState_reflection_ = NULL;
 
 }  // namespace
 
@@ -37,7 +40,7 @@ void protobuf_AssignDesc_role_5ftypes_2eproto() {
       "role_types.proto");
   GOOGLE_CHECK(file != NULL);
   Role_descriptor_ = file->message_type(0);
-  static const int Role_offsets_[10] = {
+  static const int Role_offsets_[9] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, name_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, privilege_),
@@ -45,7 +48,6 @@ void protobuf_AssignDesc_role_5ftypes_2eproto() {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, required_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, unique_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, relegation_role_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, attribute_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, kickable_role_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, removable_role_),
   };
@@ -60,6 +62,28 @@ void protobuf_AssignDesc_role_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(Role));
+  RoleState_descriptor_ = file->message_type(1);
+  static const int RoleState_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, assignable_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, required_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, unique_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, relegation_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, kickable_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, removable_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, mentionable_role_),
+  };
+  RoleState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RoleState_descriptor_,
+      RoleState::default_instance_,
+      RoleState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RoleState, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RoleState));
 }
 
 namespace {
@@ -74,6 +98,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     Role_descriptor_, &Role::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RoleState_descriptor_, &RoleState::default_instance());
 }
 
 }  // namespace
@@ -81,6 +107,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
 void protobuf_ShutdownFile_role_5ftypes_2eproto() {
   delete Role::default_instance_;
   delete Role_reflection_;
+  delete RoleState::default_instance_;
+  delete RoleState_reflection_;
 }
 
 void protobuf_AddDesc_role_5ftypes_2eproto() {
@@ -89,20 +117,24 @@ void protobuf_AddDesc_role_5ftypes_2eproto() {
   already_here = true;
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
-  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-    "\n\020role_types.proto\022\014bgs.protocol\032\025attrib"
-    "ute_types.proto\"\374\001\n\004Role\022\n\n\002id\030\001 \002(\r\022\014\n\004"
-    "name\030\002 \002(\t\022\021\n\tprivilege\030\003 \003(\t\022\033\n\017assigna"
-    "ble_role\030\004 \003(\rB\002\020\001\022\027\n\010required\030\005 \001(\010:\005fa"
-    "lse\022\025\n\006unique\030\006 \001(\010:\005false\022\027\n\017relegation"
-    "_role\030\007 \001(\r\022*\n\tattribute\030\010 \003(\0132\027.bgs.pro"
-    "tocol.Attribute\022\031\n\rkickable_role\030\t \003(\rB\002"
-    "\020\001\022\032\n\016removable_role\030\n \003(\rB\002\020\001B\002H\001", 314);
+    "\n\020role_types.proto\022\014bgs.protocol\"\302\001\n\004Rol"
+    "e\022\n\n\002id\030\001 \002(\r\022\014\n\004name\030\002 \002(\t\022\021\n\tprivilege"
+    "\030\003 \003(\t\022\033\n\017assignable_role\030\004 \003(\rB\002\020\001\022\020\n\010r"
+    "equired\030\005 \001(\010\022\016\n\006unique\030\006 \001(\010\022\027\n\017relegat"
+    "ion_role\030\007 \001(\r\022\031\n\rkickable_role\030\t \003(\rB\002\020"
+    "\001\022\032\n\016removable_role\030\n \003(\rB\002\020\001\"\306\001\n\tRoleSt"
+    "ate\022\014\n\004name\030\002 \001(\t\022\033\n\017assignable_role\030\004 \003"
+    "(\rB\002\020\001\022\020\n\010required\030\005 \001(\010\022\016\n\006unique\030\006 \001(\010"
+    "\022\027\n\017relegation_role\030\007 \001(\r\022\031\n\rkickable_ro"
+    "le\030\t \003(\rB\002\020\001\022\032\n\016removable_role\030\n \003(\rB\002\020\001"
+    "\022\034\n\020mentionable_role\030\013 \003(\rB\002\020\001B\002H\001", 434);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "role_types.proto", &protobuf_RegisterTypes);
   Role::default_instance_ = new Role();
+  RoleState::default_instance_ = new RoleState();
   Role::default_instance_->InitAsDefaultInstance();
+  RoleState::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_role_5ftypes_2eproto);
 }
 
@@ -123,7 +155,6 @@ const int Role::kAssignableRoleFieldNumber;
 const int Role::kRequiredFieldNumber;
 const int Role::kUniqueFieldNumber;
 const int Role::kRelegationRoleFieldNumber;
-const int Role::kAttributeFieldNumber;
 const int Role::kKickableRoleFieldNumber;
 const int Role::kRemovableRoleFieldNumber;
 #endif  // !_MSC_VER
@@ -218,7 +249,6 @@ void Role::Clear() {
 
   privilege_.Clear();
   assignable_role_.Clear();
-  attribute_.Clear();
   kickable_role_.Clear();
   removable_role_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
@@ -303,7 +333,7 @@ bool Role::MergePartialFromCodedStream(
         break;
       }
 
-      // optional bool required = 5 [default = false];
+      // optional bool required = 5;
       case 5: {
         if (tag == 40) {
          parse_required:
@@ -318,7 +348,7 @@ bool Role::MergePartialFromCodedStream(
         break;
       }
 
-      // optional bool unique = 6 [default = false];
+      // optional bool unique = 6;
       case 6: {
         if (tag == 48) {
          parse_unique:
@@ -344,20 +374,6 @@ bool Role::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(66)) goto parse_attribute;
-        break;
-      }
-
-      // repeated .bgs.protocol.Attribute attribute = 8;
-      case 8: {
-        if (tag == 66) {
-         parse_attribute:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_attribute()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(66)) goto parse_attribute;
         if (input->ExpectTag(74)) goto parse_kickable_role;
         break;
       }
@@ -458,12 +474,12 @@ void Role::SerializeWithCachedSizes(
       this->assignable_role(i), output);
   }
 
-  // optional bool required = 5 [default = false];
+  // optional bool required = 5;
   if (has_required()) {
     ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->required(), output);
   }
 
-  // optional bool unique = 6 [default = false];
+  // optional bool unique = 6;
   if (has_unique()) {
     ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->unique(), output);
   }
@@ -473,12 +489,6 @@ void Role::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->relegation_role(), output);
   }
 
-  // repeated .bgs.protocol.Attribute attribute = 8;
-  for (int i = 0; i < this->attribute_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      8, this->attribute(i), output);
-  }
-
   // repeated uint32 kickable_role = 9 [packed = true];
   if (this->kickable_role_size() > 0) {
     ::google::protobuf::internal::WireFormatLite::WriteTag(9, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
@@ -549,12 +559,12 @@ void Role::SerializeWithCachedSizes(
       WriteUInt32NoTagToArray(this->assignable_role(i), target);
   }
 
-  // optional bool required = 5 [default = false];
+  // optional bool required = 5;
   if (has_required()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->required(), target);
   }
 
-  // optional bool unique = 6 [default = false];
+  // optional bool unique = 6;
   if (has_unique()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->unique(), target);
   }
@@ -564,13 +574,6 @@ void Role::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->relegation_role(), target);
   }
 
-  // repeated .bgs.protocol.Attribute attribute = 8;
-  for (int i = 0; i < this->attribute_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        8, this->attribute(i), target);
-  }
-
   // repeated uint32 kickable_role = 9 [packed = true];
   if (this->kickable_role_size() > 0) {
     target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
@@ -625,12 +628,12 @@ int Role::ByteSize() const {
           this->name());
     }
 
-    // optional bool required = 5 [default = false];
+    // optional bool required = 5;
     if (has_required()) {
       total_size += 1 + 1;
     }
 
-    // optional bool unique = 6 [default = false];
+    // optional bool unique = 6;
     if (has_unique()) {
       total_size += 1 + 1;
     }
@@ -667,14 +670,6 @@ int Role::ByteSize() const {
     total_size += data_size;
   }
 
-  // repeated .bgs.protocol.Attribute attribute = 8;
-  total_size += 1 * this->attribute_size();
-  for (int i = 0; i < this->attribute_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->attribute(i));
-  }
-
   // repeated uint32 kickable_role = 9 [packed = true];
   {
     int data_size = 0;
@@ -736,7 +731,6 @@ void Role::MergeFrom(const Role& from) {
   GOOGLE_CHECK_NE(&from, this);
   privilege_.MergeFrom(from.privilege_);
   assignable_role_.MergeFrom(from.assignable_role_);
-  attribute_.MergeFrom(from.attribute_);
   kickable_role_.MergeFrom(from.kickable_role_);
   removable_role_.MergeFrom(from.removable_role_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
@@ -774,7 +768,6 @@ void Role::CopyFrom(const Role& from) {
 bool Role::IsInitialized() const {
   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
 
-  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
   return true;
 }
 
@@ -787,7 +780,6 @@ void Role::Swap(Role* other) {
     std::swap(required_, other->required_);
     std::swap(unique_, other->unique_);
     std::swap(relegation_role_, other->relegation_role_);
-    attribute_.Swap(&other->attribute_);
     kickable_role_.Swap(&other->kickable_role_);
     removable_role_.Swap(&other->removable_role_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
@@ -805,6 +797,632 @@ void Role::Swap(Role* other) {
 }
 
 
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RoleState::kNameFieldNumber;
+const int RoleState::kAssignableRoleFieldNumber;
+const int RoleState::kRequiredFieldNumber;
+const int RoleState::kUniqueFieldNumber;
+const int RoleState::kRelegationRoleFieldNumber;
+const int RoleState::kKickableRoleFieldNumber;
+const int RoleState::kRemovableRoleFieldNumber;
+const int RoleState::kMentionableRoleFieldNumber;
+#endif  // !_MSC_VER
+
+RoleState::RoleState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.RoleState)
+}
+
+void RoleState::InitAsDefaultInstance() {
+}
+
+RoleState::RoleState(const RoleState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.RoleState)
+}
+
+void RoleState::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  _assignable_role_cached_byte_size_ = 0;
+  required_ = false;
+  unique_ = false;
+  relegation_role_ = 0u;
+  _kickable_role_cached_byte_size_ = 0;
+  _removable_role_cached_byte_size_ = 0;
+  _mentionable_role_cached_byte_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RoleState::~RoleState() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.RoleState)
+  SharedDtor();
+}
+
+void RoleState::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void RoleState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RoleState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RoleState_descriptor_;
+}
+
+const RoleState& RoleState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_role_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+RoleState* RoleState::default_instance_ = NULL;
+
+RoleState* RoleState::New() const {
+  return new RoleState;
+}
+
+void RoleState::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<RoleState*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 29) {
+    ZR_(required_, relegation_role_);
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  assignable_role_.Clear();
+  kickable_role_.Clear();
+  removable_role_.Clear();
+  mentionable_role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RoleState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.RoleState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string name = 2;
+      case 2: {
+        if (tag == 18) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_assignable_role;
+        break;
+      }
+
+      // repeated uint32 assignable_role = 4 [packed = true];
+      case 4: {
+        if (tag == 34) {
+         parse_assignable_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_assignable_role())));
+        } else if (tag == 32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 34, input, this->mutable_assignable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_required;
+        break;
+      }
+
+      // optional bool required = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_required:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &required_)));
+          set_has_required();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_unique;
+        break;
+      }
+
+      // optional bool unique = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_unique:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &unique_)));
+          set_has_unique();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_relegation_role;
+        break;
+      }
+
+      // optional uint32 relegation_role = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_relegation_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &relegation_role_)));
+          set_has_relegation_role();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_kickable_role;
+        break;
+      }
+
+      // repeated uint32 kickable_role = 9 [packed = true];
+      case 9: {
+        if (tag == 74) {
+         parse_kickable_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_kickable_role())));
+        } else if (tag == 72) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 74, input, this->mutable_kickable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_removable_role;
+        break;
+      }
+
+      // repeated uint32 removable_role = 10 [packed = true];
+      case 10: {
+        if (tag == 82) {
+         parse_removable_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_removable_role())));
+        } else if (tag == 80) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 82, input, this->mutable_removable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(90)) goto parse_mentionable_role;
+        break;
+      }
+
+      // repeated uint32 mentionable_role = 11 [packed = true];
+      case 11: {
+        if (tag == 90) {
+         parse_mentionable_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_mentionable_role())));
+        } else if (tag == 88) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 90, input, this->mutable_mentionable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.RoleState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.RoleState)
+  return false;
+#undef DO_
+}
+
+void RoleState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.RoleState)
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->name(), output);
+  }
+
+  // repeated uint32 assignable_role = 4 [packed = true];
+  if (this->assignable_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_assignable_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->assignable_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->assignable_role(i), output);
+  }
+
+  // optional bool required = 5;
+  if (has_required()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->required(), output);
+  }
+
+  // optional bool unique = 6;
+  if (has_unique()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->unique(), output);
+  }
+
+  // optional uint32 relegation_role = 7;
+  if (has_relegation_role()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->relegation_role(), output);
+  }
+
+  // repeated uint32 kickable_role = 9 [packed = true];
+  if (this->kickable_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(9, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_kickable_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->kickable_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->kickable_role(i), output);
+  }
+
+  // repeated uint32 removable_role = 10 [packed = true];
+  if (this->removable_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(10, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_removable_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->removable_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->removable_role(i), output);
+  }
+
+  // repeated uint32 mentionable_role = 11 [packed = true];
+  if (this->mentionable_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(11, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_mentionable_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->mentionable_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->mentionable_role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.RoleState)
+}
+
+::google::protobuf::uint8* RoleState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.RoleState)
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+
+  // repeated uint32 assignable_role = 4 [packed = true];
+  if (this->assignable_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      4,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _assignable_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->assignable_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->assignable_role(i), target);
+  }
+
+  // optional bool required = 5;
+  if (has_required()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->required(), target);
+  }
+
+  // optional bool unique = 6;
+  if (has_unique()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->unique(), target);
+  }
+
+  // optional uint32 relegation_role = 7;
+  if (has_relegation_role()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->relegation_role(), target);
+  }
+
+  // repeated uint32 kickable_role = 9 [packed = true];
+  if (this->kickable_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      9,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _kickable_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->kickable_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->kickable_role(i), target);
+  }
+
+  // repeated uint32 removable_role = 10 [packed = true];
+  if (this->removable_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      10,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _removable_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->removable_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->removable_role(i), target);
+  }
+
+  // repeated uint32 mentionable_role = 11 [packed = true];
+  if (this->mentionable_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      11,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _mentionable_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->mentionable_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->mentionable_role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.RoleState)
+  return target;
+}
+
+int RoleState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string name = 2;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional bool required = 5;
+    if (has_required()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool unique = 6;
+    if (has_unique()) {
+      total_size += 1 + 1;
+    }
+
+    // optional uint32 relegation_role = 7;
+    if (has_relegation_role()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->relegation_role());
+    }
+
+  }
+  // repeated uint32 assignable_role = 4 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->assignable_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->assignable_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _assignable_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 kickable_role = 9 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->kickable_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->kickable_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _kickable_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 removable_role = 10 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->removable_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->removable_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _removable_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 mentionable_role = 11 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->mentionable_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->mentionable_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _mentionable_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RoleState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RoleState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RoleState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RoleState::MergeFrom(const RoleState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  assignable_role_.MergeFrom(from.assignable_role_);
+  kickable_role_.MergeFrom(from.kickable_role_);
+  removable_role_.MergeFrom(from.removable_role_);
+  mentionable_role_.MergeFrom(from.mentionable_role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_required()) {
+      set_required(from.required());
+    }
+    if (from.has_unique()) {
+      set_unique(from.unique());
+    }
+    if (from.has_relegation_role()) {
+      set_relegation_role(from.relegation_role());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RoleState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RoleState::CopyFrom(const RoleState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RoleState::IsInitialized() const {
+
+  return true;
+}
+
+void RoleState::Swap(RoleState* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    assignable_role_.Swap(&other->assignable_role_);
+    std::swap(required_, other->required_);
+    std::swap(unique_, other->unique_);
+    std::swap(relegation_role_, other->relegation_role_);
+    kickable_role_.Swap(&other->kickable_role_);
+    removable_role_.Swap(&other->removable_role_);
+    mentionable_role_.Swap(&other->mentionable_role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RoleState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RoleState_descriptor_;
+  metadata.reflection = RoleState_reflection_;
+  return metadata;
+}
+
+
 // @@protoc_insertion_point(namespace_scope)
 
 }  // namespace protocol
diff --git a/src/server/proto/Client/role_types.pb.h b/src/server/proto/Client/role_types.pb.h
index 0215edf49f3..7e79d0cfb06 100644
--- a/src/server/proto/Client/role_types.pb.h
+++ b/src/server/proto/Client/role_types.pb.h
@@ -24,7 +24,6 @@
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/extension_set.h>
 #include <google/protobuf/unknown_field_set.h>
-#include "attribute_types.pb.h"
 #include "Define.h" // for TC_PROTO_API
 // @@protoc_insertion_point(includes)
 
@@ -37,6 +36,7 @@ void protobuf_AssignDesc_role_5ftypes_2eproto();
 void protobuf_ShutdownFile_role_5ftypes_2eproto();
 
 class Role;
+class RoleState;
 
 // ===================================================================
 
@@ -140,14 +140,14 @@ class TC_PROTO_API Role : public ::google::protobuf::Message {
   inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
       mutable_assignable_role();
 
-  // optional bool required = 5 [default = false];
+  // optional bool required = 5;
   inline bool has_required() const;
   inline void clear_required();
   static const int kRequiredFieldNumber = 5;
   inline bool required() const;
   inline void set_required(bool value);
 
-  // optional bool unique = 6 [default = false];
+  // optional bool unique = 6;
   inline bool has_unique() const;
   inline void clear_unique();
   static const int kUniqueFieldNumber = 6;
@@ -161,18 +161,6 @@ class TC_PROTO_API Role : public ::google::protobuf::Message {
   inline ::google::protobuf::uint32 relegation_role() const;
   inline void set_relegation_role(::google::protobuf::uint32 value);
 
-  // repeated .bgs.protocol.Attribute attribute = 8;
-  inline int attribute_size() const;
-  inline void clear_attribute();
-  static const int kAttributeFieldNumber = 8;
-  inline const ::bgs::protocol::Attribute& attribute(int index) const;
-  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
-  inline ::bgs::protocol::Attribute* add_attribute();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
-      attribute() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
-      mutable_attribute();
-
   // repeated uint32 kickable_role = 9 [packed = true];
   inline int kickable_role_size() const;
   inline void clear_kickable_role();
@@ -221,7 +209,6 @@ class TC_PROTO_API Role : public ::google::protobuf::Message {
   ::google::protobuf::uint32 id_;
   bool required_;
   bool unique_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
   ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > kickable_role_;
   mutable int _kickable_role_cached_byte_size_;
   ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > removable_role_;
@@ -234,6 +221,176 @@ class TC_PROTO_API Role : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static Role* default_instance_;
 };
+// -------------------------------------------------------------------
+
+class TC_PROTO_API RoleState : public ::google::protobuf::Message {
+ public:
+  RoleState();
+  virtual ~RoleState();
+
+  RoleState(const RoleState& from);
+
+  inline RoleState& operator=(const RoleState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RoleState& default_instance();
+
+  void Swap(RoleState* other);
+
+  // implements Message ----------------------------------------------
+
+  RoleState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RoleState& from);
+  void MergeFrom(const RoleState& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 2;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // repeated uint32 assignable_role = 4 [packed = true];
+  inline int assignable_role_size() const;
+  inline void clear_assignable_role();
+  static const int kAssignableRoleFieldNumber = 4;
+  inline ::google::protobuf::uint32 assignable_role(int index) const;
+  inline void set_assignable_role(int index, ::google::protobuf::uint32 value);
+  inline void add_assignable_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      assignable_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_assignable_role();
+
+  // optional bool required = 5;
+  inline bool has_required() const;
+  inline void clear_required();
+  static const int kRequiredFieldNumber = 5;
+  inline bool required() const;
+  inline void set_required(bool value);
+
+  // optional bool unique = 6;
+  inline bool has_unique() const;
+  inline void clear_unique();
+  static const int kUniqueFieldNumber = 6;
+  inline bool unique() const;
+  inline void set_unique(bool value);
+
+  // optional uint32 relegation_role = 7;
+  inline bool has_relegation_role() const;
+  inline void clear_relegation_role();
+  static const int kRelegationRoleFieldNumber = 7;
+  inline ::google::protobuf::uint32 relegation_role() const;
+  inline void set_relegation_role(::google::protobuf::uint32 value);
+
+  // repeated uint32 kickable_role = 9 [packed = true];
+  inline int kickable_role_size() const;
+  inline void clear_kickable_role();
+  static const int kKickableRoleFieldNumber = 9;
+  inline ::google::protobuf::uint32 kickable_role(int index) const;
+  inline void set_kickable_role(int index, ::google::protobuf::uint32 value);
+  inline void add_kickable_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      kickable_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_kickable_role();
+
+  // repeated uint32 removable_role = 10 [packed = true];
+  inline int removable_role_size() const;
+  inline void clear_removable_role();
+  static const int kRemovableRoleFieldNumber = 10;
+  inline ::google::protobuf::uint32 removable_role(int index) const;
+  inline void set_removable_role(int index, ::google::protobuf::uint32 value);
+  inline void add_removable_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      removable_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_removable_role();
+
+  // repeated uint32 mentionable_role = 11 [packed = true];
+  inline int mentionable_role_size() const;
+  inline void clear_mentionable_role();
+  static const int kMentionableRoleFieldNumber = 11;
+  inline ::google::protobuf::uint32 mentionable_role(int index) const;
+  inline void set_mentionable_role(int index, ::google::protobuf::uint32 value);
+  inline void add_mentionable_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      mentionable_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_mentionable_role();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.RoleState)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_required();
+  inline void clear_has_required();
+  inline void set_has_unique();
+  inline void clear_has_unique();
+  inline void set_has_relegation_role();
+  inline void clear_has_relegation_role();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > assignable_role_;
+  mutable int _assignable_role_cached_byte_size_;
+  bool required_;
+  bool unique_;
+  ::google::protobuf::uint32 relegation_role_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > kickable_role_;
+  mutable int _kickable_role_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > removable_role_;
+  mutable int _removable_role_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > mentionable_role_;
+  mutable int _mentionable_role_cached_byte_size_;
+  friend void TC_PROTO_API protobuf_AddDesc_role_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_role_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_role_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static RoleState* default_instance_;
+};
 // ===================================================================
 
 
@@ -428,7 +585,7 @@ Role::mutable_assignable_role() {
   return &assignable_role_;
 }
 
-// optional bool required = 5 [default = false];
+// optional bool required = 5;
 inline bool Role::has_required() const {
   return (_has_bits_[0] & 0x00000010u) != 0;
 }
@@ -452,7 +609,7 @@ inline void Role::set_required(bool value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.Role.required)
 }
 
-// optional bool unique = 6 [default = false];
+// optional bool unique = 6;
 inline bool Role::has_unique() const {
   return (_has_bits_[0] & 0x00000020u) != 0;
 }
@@ -500,36 +657,6 @@ inline void Role::set_relegation_role(::google::protobuf::uint32 value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.Role.relegation_role)
 }
 
-// repeated .bgs.protocol.Attribute attribute = 8;
-inline int Role::attribute_size() const {
-  return attribute_.size();
-}
-inline void Role::clear_attribute() {
-  attribute_.Clear();
-}
-inline const ::bgs::protocol::Attribute& Role::attribute(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.Role.attribute)
-  return attribute_.Get(index);
-}
-inline ::bgs::protocol::Attribute* Role::mutable_attribute(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.Role.attribute)
-  return attribute_.Mutable(index);
-}
-inline ::bgs::protocol::Attribute* Role::add_attribute() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.Role.attribute)
-  return attribute_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
-Role::attribute() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.Role.attribute)
-  return attribute_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
-Role::mutable_attribute() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.attribute)
-  return &attribute_;
-}
-
 // repeated uint32 kickable_role = 9 [packed = true];
 inline int Role::kickable_role_size() const {
   return kickable_role_.size();
@@ -590,6 +717,278 @@ Role::mutable_removable_role() {
   return &removable_role_;
 }
 
+// -------------------------------------------------------------------
+
+// RoleState
+
+// optional string name = 2;
+inline bool RoleState::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RoleState::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RoleState::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RoleState::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& RoleState::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RoleState.name)
+  return *name_;
+}
+inline void RoleState::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.RoleState.name)
+}
+inline void RoleState::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.RoleState.name)
+}
+inline void RoleState::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.RoleState.name)
+}
+inline ::std::string* RoleState::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.RoleState.name)
+  return name_;
+}
+inline ::std::string* RoleState::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void RoleState::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.RoleState.name)
+}
+
+// repeated uint32 assignable_role = 4 [packed = true];
+inline int RoleState::assignable_role_size() const {
+  return assignable_role_.size();
+}
+inline void RoleState::clear_assignable_role() {
+  assignable_role_.Clear();
+}
+inline ::google::protobuf::uint32 RoleState::assignable_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RoleState.assignable_role)
+  return assignable_role_.Get(index);
+}
+inline void RoleState::set_assignable_role(int index, ::google::protobuf::uint32 value) {
+  assignable_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.RoleState.assignable_role)
+}
+inline void RoleState::add_assignable_role(::google::protobuf::uint32 value) {
+  assignable_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.RoleState.assignable_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+RoleState::assignable_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.RoleState.assignable_role)
+  return assignable_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+RoleState::mutable_assignable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.RoleState.assignable_role)
+  return &assignable_role_;
+}
+
+// optional bool required = 5;
+inline bool RoleState::has_required() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RoleState::set_has_required() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RoleState::clear_has_required() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RoleState::clear_required() {
+  required_ = false;
+  clear_has_required();
+}
+inline bool RoleState::required() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RoleState.required)
+  return required_;
+}
+inline void RoleState::set_required(bool value) {
+  set_has_required();
+  required_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.RoleState.required)
+}
+
+// optional bool unique = 6;
+inline bool RoleState::has_unique() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void RoleState::set_has_unique() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void RoleState::clear_has_unique() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void RoleState::clear_unique() {
+  unique_ = false;
+  clear_has_unique();
+}
+inline bool RoleState::unique() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RoleState.unique)
+  return unique_;
+}
+inline void RoleState::set_unique(bool value) {
+  set_has_unique();
+  unique_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.RoleState.unique)
+}
+
+// optional uint32 relegation_role = 7;
+inline bool RoleState::has_relegation_role() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void RoleState::set_has_relegation_role() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void RoleState::clear_has_relegation_role() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void RoleState::clear_relegation_role() {
+  relegation_role_ = 0u;
+  clear_has_relegation_role();
+}
+inline ::google::protobuf::uint32 RoleState::relegation_role() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RoleState.relegation_role)
+  return relegation_role_;
+}
+inline void RoleState::set_relegation_role(::google::protobuf::uint32 value) {
+  set_has_relegation_role();
+  relegation_role_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.RoleState.relegation_role)
+}
+
+// repeated uint32 kickable_role = 9 [packed = true];
+inline int RoleState::kickable_role_size() const {
+  return kickable_role_.size();
+}
+inline void RoleState::clear_kickable_role() {
+  kickable_role_.Clear();
+}
+inline ::google::protobuf::uint32 RoleState::kickable_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RoleState.kickable_role)
+  return kickable_role_.Get(index);
+}
+inline void RoleState::set_kickable_role(int index, ::google::protobuf::uint32 value) {
+  kickable_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.RoleState.kickable_role)
+}
+inline void RoleState::add_kickable_role(::google::protobuf::uint32 value) {
+  kickable_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.RoleState.kickable_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+RoleState::kickable_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.RoleState.kickable_role)
+  return kickable_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+RoleState::mutable_kickable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.RoleState.kickable_role)
+  return &kickable_role_;
+}
+
+// repeated uint32 removable_role = 10 [packed = true];
+inline int RoleState::removable_role_size() const {
+  return removable_role_.size();
+}
+inline void RoleState::clear_removable_role() {
+  removable_role_.Clear();
+}
+inline ::google::protobuf::uint32 RoleState::removable_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RoleState.removable_role)
+  return removable_role_.Get(index);
+}
+inline void RoleState::set_removable_role(int index, ::google::protobuf::uint32 value) {
+  removable_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.RoleState.removable_role)
+}
+inline void RoleState::add_removable_role(::google::protobuf::uint32 value) {
+  removable_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.RoleState.removable_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+RoleState::removable_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.RoleState.removable_role)
+  return removable_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+RoleState::mutable_removable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.RoleState.removable_role)
+  return &removable_role_;
+}
+
+// repeated uint32 mentionable_role = 11 [packed = true];
+inline int RoleState::mentionable_role_size() const {
+  return mentionable_role_.size();
+}
+inline void RoleState::clear_mentionable_role() {
+  mentionable_role_.Clear();
+}
+inline ::google::protobuf::uint32 RoleState::mentionable_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.RoleState.mentionable_role)
+  return mentionable_role_.Get(index);
+}
+inline void RoleState::set_mentionable_role(int index, ::google::protobuf::uint32 value) {
+  mentionable_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.RoleState.mentionable_role)
+}
+inline void RoleState::add_mentionable_role(::google::protobuf::uint32 value) {
+  mentionable_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.RoleState.mentionable_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+RoleState::mentionable_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.RoleState.mentionable_role)
+  return mentionable_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+RoleState::mutable_mentionable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.RoleState.mentionable_role)
+  return &mentionable_role_;
+}
+
 
 // @@protoc_insertion_point(namespace_scope)
 
diff --git a/src/server/proto/Client/rpc_types.pb.cc b/src/server/proto/Client/rpc_types.pb.cc
index 2107769319a..30a5ef168f7 100644
--- a/src/server/proto/Client/rpc_types.pb.cc
+++ b/src/server/proto/Client/rpc_types.pb.cc
@@ -41,13 +41,12 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* ErrorInfo_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   ErrorInfo_reflection_ = NULL;
-const ::google::protobuf::Descriptor* TraceInfo_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  TraceInfo_reflection_ = NULL;
-const ::google::protobuf::EnumDescriptor* TraceInfo_Sampling_descriptor_ = NULL;
 const ::google::protobuf::Descriptor* Header_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   Header_reflection_ = NULL;
+const ::google::protobuf::Descriptor* KafkaHeader_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  KafkaHeader_reflection_ = NULL;
 
 }  // namespace
 
@@ -152,27 +151,7 @@ void protobuf_AssignDesc_rpc_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ErrorInfo));
-  TraceInfo_descriptor_ = file->message_type(6);
-  static const int TraceInfo_offsets_[5] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TraceInfo, session_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TraceInfo, trace_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TraceInfo, span_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TraceInfo, parent_span_id_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TraceInfo, sampling_),
-  };
-  TraceInfo_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      TraceInfo_descriptor_,
-      TraceInfo::default_instance_,
-      TraceInfo_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TraceInfo, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TraceInfo, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(TraceInfo));
-  TraceInfo_Sampling_descriptor_ = TraceInfo_descriptor_->enum_type(0);
-  Header_descriptor_ = file->message_type(7);
+  Header_descriptor_ = file->message_type(6);
   static const int Header_offsets_[12] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, service_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, method_id_),
@@ -185,7 +164,7 @@ void protobuf_AssignDesc_rpc_5ftypes_2eproto() {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, is_response_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, forward_targets_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, service_hash_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, trace_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, client_id_),
   };
   Header_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -198,6 +177,30 @@ void protobuf_AssignDesc_rpc_5ftypes_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(Header));
+  KafkaHeader_descriptor_ = file->message_type(7);
+  static const int KafkaHeader_offsets_[10] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, service_hash_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, method_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, token_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, object_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, size_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, timeout_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, forward_target_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, return_topic_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, client_id_),
+  };
+  KafkaHeader_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      KafkaHeader_descriptor_,
+      KafkaHeader::default_instance_,
+      KafkaHeader_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(KafkaHeader, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(KafkaHeader));
 }
 
 namespace {
@@ -223,9 +226,9 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     ErrorInfo_descriptor_, &ErrorInfo::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    TraceInfo_descriptor_, &TraceInfo::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     Header_descriptor_, &Header::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    KafkaHeader_descriptor_, &KafkaHeader::default_instance());
 }
 
 }  // namespace
@@ -243,10 +246,10 @@ void protobuf_ShutdownFile_rpc_5ftypes_2eproto() {
   delete NoData_reflection_;
   delete ErrorInfo::default_instance_;
   delete ErrorInfo_reflection_;
-  delete TraceInfo::default_instance_;
-  delete TraceInfo_reflection_;
   delete Header::default_instance_;
   delete Header_reflection_;
+  delete KafkaHeader::default_instance_;
+  delete KafkaHeader_reflection_;
 }
 
 void protobuf_AddDesc_rpc_5ftypes_2eproto() {
@@ -255,36 +258,38 @@ void protobuf_AddDesc_rpc_5ftypes_2eproto() {
   already_here = true;
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
   ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2fmessage_5foptions_2eproto();
   ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
-  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
-    "\n\017rpc_types.proto\022\014bgs.protocol\032&global_"
-    "extensions/method_options.proto\032\'global_"
-    "extensions/service_options.proto\032%global"
-    "_extensions/field_options.proto\"\r\n\013NO_RE"
-    "SPONSE\"(\n\007Address\022\017\n\007address\030\001 \002(\t\022\014\n\004po"
-    "rt\030\002 \001(\r\")\n\tProcessId\022\r\n\005label\030\001 \002(\r\022\r\n\005"
-    "epoch\030\002 \002(\r\"L\n\rObjectAddress\022%\n\004host\030\001 \002"
-    "(\0132\027.bgs.protocol.ProcessId\022\024\n\tobject_id"
-    "\030\002 \001(\004:\0010\"\010\n\006NoData\"y\n\tErrorInfo\0223\n\016obje"
-    "ct_address\030\001 \002(\0132\033.bgs.protocol.ObjectAd"
-    "dress\022\016\n\006status\030\002 \002(\r\022\024\n\014service_hash\030\003 "
-    "\002(\r\022\021\n\tmethod_id\030\004 \002(\r\"\275\001\n\tTraceInfo\022\022\n\n"
-    "session_id\030\001 \001(\t\022\020\n\010trace_id\030\002 \001(\t\022\017\n\007sp"
-    "an_id\030\003 \001(\t\022\026\n\016parent_span_id\030\004 \001(\t\0229\n\010s"
-    "ampling\030\005 \001(\0162 .bgs.protocol.TraceInfo.S"
-    "ampling:\005DEFER\"&\n\010Sampling\022\007\n\003YES\020\000\022\006\n\002N"
-    "O\020\001\022\t\n\005DEFER\020\002\"\273\002\n\006Header\022\022\n\nservice_id\030"
-    "\001 \002(\r\022\021\n\tmethod_id\030\002 \001(\r\022\r\n\005token\030\003 \002(\r\022"
-    "\024\n\tobject_id\030\004 \001(\004:\0010\022\017\n\004size\030\005 \001(\r:\0010\022\021"
-    "\n\006status\030\006 \001(\r:\0010\022&\n\005error\030\007 \003(\0132\027.bgs.p"
-    "rotocol.ErrorInfo\022\017\n\007timeout\030\010 \001(\004\022\023\n\013is"
-    "_response\030\t \001(\010\0220\n\017forward_targets\030\n \003(\013"
-    "2\027.bgs.protocol.ProcessId\022\024\n\014service_has"
-    "h\030\013 \001(\007\022+\n\ntrace_info\030\014 \001(\0132\027.bgs.protoc"
-    "ol.TraceInfoB\033\n\rbnet.protocolB\010RpcProtoH"
-    "\001P\000P\001P\002", 1007);
+    "\n\017rpc_types.proto\022\014bgs.protocol\032%global_"
+    "extensions/field_options.proto\032&global_e"
+    "xtensions/method_options.proto\032\'global_e"
+    "xtensions/message_options.proto\032\'global_"
+    "extensions/service_options.proto\"\r\n\013NO_R"
+    "ESPONSE\"(\n\007Address\022\017\n\007address\030\001 \002(\t\022\014\n\004p"
+    "ort\030\002 \001(\r\"3\n\tProcessId\022\027\n\005label\030\001 \002(\rB\010\212"
+    "\371+\004\022\002\020\000\022\r\n\005epoch\030\002 \002(\r\"L\n\rObjectAddress\022"
+    "%\n\004host\030\001 \002(\0132\027.bgs.protocol.ProcessId\022\024"
+    "\n\tobject_id\030\002 \001(\004:\0010\"\010\n\006NoData\"y\n\tErrorI"
+    "nfo\0223\n\016object_address\030\001 \002(\0132\033.bgs.protoc"
+    "ol.ObjectAddress\022\016\n\006status\030\002 \002(\r\022\024\n\014serv"
+    "ice_hash\030\003 \002(\r\022\021\n\tmethod_id\030\004 \002(\r\"\241\002\n\006He"
+    "ader\022\022\n\nservice_id\030\001 \002(\r\022\021\n\tmethod_id\030\002 "
+    "\001(\r\022\r\n\005token\030\003 \002(\r\022\024\n\tobject_id\030\004 \001(\004:\0010"
+    "\022\017\n\004size\030\005 \001(\r:\0010\022\021\n\006status\030\006 \001(\r:\0010\022&\n\005"
+    "error\030\007 \003(\0132\027.bgs.protocol.ErrorInfo\022\017\n\007"
+    "timeout\030\010 \001(\004\022\023\n\013is_response\030\t \001(\010\0220\n\017fo"
+    "rward_targets\030\n \003(\0132\027.bgs.protocol.Proce"
+    "ssId\022\024\n\014service_hash\030\013 \001(\007\022\021\n\tclient_id\030"
+    "\r \001(\t\"\352\001\n\013KafkaHeader\022\024\n\014service_hash\030\001 "
+    "\001(\007\022\021\n\tmethod_id\030\002 \001(\r\022\r\n\005token\030\003 \001(\r\022\024\n"
+    "\tobject_id\030\004 \001(\004:\0010\022\017\n\004size\030\005 \001(\r:\0010\022\021\n\006"
+    "status\030\006 \001(\r:\0010\022\017\n\007timeout\030\007 \001(\004\022/\n\016forw"
+    "ard_target\030\010 \001(\0132\027.bgs.protocol.ProcessI"
+    "d\022\024\n\014return_topic\030\t \001(\t\022\021\n\tclient_id\030\013 \001"
+    "(\tB\033\n\rbnet.protocolB\010RpcProtoH\001P\000P\001P\002P\003", 1079);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "rpc_types.proto", &protobuf_RegisterTypes);
   NO_RESPONSE::default_instance_ = new NO_RESPONSE();
@@ -293,16 +298,16 @@ void protobuf_AddDesc_rpc_5ftypes_2eproto() {
   ObjectAddress::default_instance_ = new ObjectAddress();
   NoData::default_instance_ = new NoData();
   ErrorInfo::default_instance_ = new ErrorInfo();
-  TraceInfo::default_instance_ = new TraceInfo();
   Header::default_instance_ = new Header();
+  KafkaHeader::default_instance_ = new KafkaHeader();
   NO_RESPONSE::default_instance_->InitAsDefaultInstance();
   Address::default_instance_->InitAsDefaultInstance();
   ProcessId::default_instance_->InitAsDefaultInstance();
   ObjectAddress::default_instance_->InitAsDefaultInstance();
   NoData::default_instance_->InitAsDefaultInstance();
   ErrorInfo::default_instance_->InitAsDefaultInstance();
-  TraceInfo::default_instance_->InitAsDefaultInstance();
   Header::default_instance_->InitAsDefaultInstance();
+  KafkaHeader::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_rpc_5ftypes_2eproto);
 }
 
@@ -1857,225 +1862,304 @@ void ErrorInfo::Swap(ErrorInfo* other) {
 
 // ===================================================================
 
-const ::google::protobuf::EnumDescriptor* TraceInfo_Sampling_descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return TraceInfo_Sampling_descriptor_;
-}
-bool TraceInfo_Sampling_IsValid(int value) {
-  switch(value) {
-    case 0:
-    case 1:
-    case 2:
-      return true;
-    default:
-      return false;
-  }
-}
-
 #ifndef _MSC_VER
-const TraceInfo_Sampling TraceInfo::YES;
-const TraceInfo_Sampling TraceInfo::NO;
-const TraceInfo_Sampling TraceInfo::DEFER;
-const TraceInfo_Sampling TraceInfo::Sampling_MIN;
-const TraceInfo_Sampling TraceInfo::Sampling_MAX;
-const int TraceInfo::Sampling_ARRAYSIZE;
-#endif  // _MSC_VER
-#ifndef _MSC_VER
-const int TraceInfo::kSessionIdFieldNumber;
-const int TraceInfo::kTraceIdFieldNumber;
-const int TraceInfo::kSpanIdFieldNumber;
-const int TraceInfo::kParentSpanIdFieldNumber;
-const int TraceInfo::kSamplingFieldNumber;
+const int Header::kServiceIdFieldNumber;
+const int Header::kMethodIdFieldNumber;
+const int Header::kTokenFieldNumber;
+const int Header::kObjectIdFieldNumber;
+const int Header::kSizeFieldNumber;
+const int Header::kStatusFieldNumber;
+const int Header::kErrorFieldNumber;
+const int Header::kTimeoutFieldNumber;
+const int Header::kIsResponseFieldNumber;
+const int Header::kForwardTargetsFieldNumber;
+const int Header::kServiceHashFieldNumber;
+const int Header::kClientIdFieldNumber;
 #endif  // !_MSC_VER
 
-TraceInfo::TraceInfo()
+Header::Header()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.TraceInfo)
+  // @@protoc_insertion_point(constructor:bgs.protocol.Header)
 }
 
-void TraceInfo::InitAsDefaultInstance() {
+void Header::InitAsDefaultInstance() {
 }
 
-TraceInfo::TraceInfo(const TraceInfo& from)
+Header::Header(const Header& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.TraceInfo)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Header)
 }
 
-void TraceInfo::SharedCtor() {
+void Header::SharedCtor() {
   ::google::protobuf::internal::GetEmptyString();
   _cached_size_ = 0;
-  session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  trace_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  span_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  parent_span_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  sampling_ = 2;
+  service_id_ = 0u;
+  method_id_ = 0u;
+  token_ = 0u;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  size_ = 0u;
+  status_ = 0u;
+  timeout_ = GOOGLE_ULONGLONG(0);
+  is_response_ = false;
+  service_hash_ = 0u;
+  client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-TraceInfo::~TraceInfo() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.TraceInfo)
+Header::~Header() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.Header)
   SharedDtor();
 }
 
-void TraceInfo::SharedDtor() {
-  if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete session_id_;
-  }
-  if (trace_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete trace_id_;
-  }
-  if (span_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete span_id_;
-  }
-  if (parent_span_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete parent_span_id_;
+void Header::SharedDtor() {
+  if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_id_;
   }
   if (this != default_instance_) {
   }
 }
 
-void TraceInfo::SetCachedSize(int size) const {
+void Header::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* TraceInfo::descriptor() {
+const ::google::protobuf::Descriptor* Header::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return TraceInfo_descriptor_;
+  return Header_descriptor_;
 }
 
-const TraceInfo& TraceInfo::default_instance() {
+const Header& Header::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto();
   return *default_instance_;
 }
 
-TraceInfo* TraceInfo::default_instance_ = NULL;
+Header* Header::default_instance_ = NULL;
 
-TraceInfo* TraceInfo::New() const {
-  return new TraceInfo;
+Header* Header::New() const {
+  return new Header;
 }
 
-void TraceInfo::Clear() {
-  if (_has_bits_[0 / 32] & 31) {
-    if (has_session_id()) {
-      if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        session_id_->clear();
-      }
-    }
-    if (has_trace_id()) {
-      if (trace_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        trace_id_->clear();
-      }
-    }
-    if (has_span_id()) {
-      if (span_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        span_id_->clear();
-      }
-    }
-    if (has_parent_span_id()) {
-      if (parent_span_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-        parent_span_id_->clear();
+void Header::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Header*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 191) {
+    ZR_(service_id_, size_);
+    status_ = 0u;
+    timeout_ = GOOGLE_ULONGLONG(0);
+  }
+  if (_has_bits_[8 / 32] & 3328) {
+    is_response_ = false;
+    service_hash_ = 0u;
+    if (has_client_id()) {
+      if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        client_id_->clear();
       }
     }
-    sampling_ = 2;
   }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  error_.Clear();
+  forward_targets_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool TraceInfo::MergePartialFromCodedStream(
+bool Header::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.TraceInfo)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.Header)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // optional string session_id = 1;
+      // required uint32 service_id = 1;
       case 1: {
-        if (tag == 10) {
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_session_id()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->session_id().data(), this->session_id().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "session_id");
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &service_id_)));
+          set_has_service_id();
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(18)) goto parse_trace_id;
+        if (input->ExpectTag(16)) goto parse_method_id;
         break;
       }
 
-      // optional string trace_id = 2;
+      // optional uint32 method_id = 2;
       case 2: {
-        if (tag == 18) {
-         parse_trace_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_trace_id()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->trace_id().data(), this->trace_id().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "trace_id");
+        if (tag == 16) {
+         parse_method_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &method_id_)));
+          set_has_method_id();
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(26)) goto parse_span_id;
+        if (input->ExpectTag(24)) goto parse_token;
         break;
       }
 
-      // optional string span_id = 3;
+      // required uint32 token = 3;
       case 3: {
-        if (tag == 26) {
-         parse_span_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_span_id()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->span_id().data(), this->span_id().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "span_id");
+        if (tag == 24) {
+         parse_token:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &token_)));
+          set_has_token();
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(34)) goto parse_parent_span_id;
+        if (input->ExpectTag(32)) goto parse_object_id;
         break;
       }
 
-      // optional string parent_span_id = 4;
+      // optional uint64 object_id = 4 [default = 0];
       case 4: {
-        if (tag == 34) {
-         parse_parent_span_id:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
-                input, this->mutable_parent_span_id()));
-          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-            this->parent_span_id().data(), this->parent_span_id().length(),
-            ::google::protobuf::internal::WireFormat::PARSE,
-            "parent_span_id");
+        if (tag == 32) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(40)) goto parse_sampling;
+        if (input->ExpectTag(40)) goto parse_size;
         break;
       }
 
-      // optional .bgs.protocol.TraceInfo.Sampling sampling = 5 [default = DEFER];
+      // optional uint32 size = 5 [default = 0];
       case 5: {
         if (tag == 40) {
-         parse_sampling:
-          int value;
+         parse_size:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &size_)));
+          set_has_size();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_status;
+        break;
+      }
+
+      // optional uint32 status = 6 [default = 0];
+      case 6: {
+        if (tag == 48) {
+         parse_status:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &status_)));
+          set_has_status();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_error;
+        break;
+      }
+
+      // repeated .bgs.protocol.ErrorInfo error = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_error:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_error()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_error;
+        if (input->ExpectTag(64)) goto parse_timeout;
+        break;
+      }
+
+      // optional uint64 timeout = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_timeout:
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
-                 input, &value)));
-          if (::bgs::protocol::TraceInfo_Sampling_IsValid(value)) {
-            set_sampling(static_cast< ::bgs::protocol::TraceInfo_Sampling >(value));
-          } else {
-            mutable_unknown_fields()->AddVarint(5, value);
-          }
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &timeout_)));
+          set_has_timeout();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_is_response;
+        break;
+      }
+
+      // optional bool is_response = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_is_response:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_response_)));
+          set_has_is_response();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_forward_targets;
+        break;
+      }
+
+      // repeated .bgs.protocol.ProcessId forward_targets = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_forward_targets:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_forward_targets()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_forward_targets;
+        if (input->ExpectTag(93)) goto parse_service_hash;
+        break;
+      }
+
+      // optional fixed32 service_hash = 11;
+      case 11: {
+        if (tag == 93) {
+         parse_service_hash:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &service_hash_)));
+          set_has_service_hash();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(106)) goto parse_client_id;
+        break;
+      }
+
+      // optional string client_id = 13;
+      case 13: {
+        if (tag == 106) {
+         parse_client_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_client_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->client_id().data(), this->client_id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "client_id");
         } else {
           goto handle_unusual;
         }
@@ -2097,170 +2181,261 @@ bool TraceInfo::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.TraceInfo)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.Header)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.TraceInfo)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.Header)
   return false;
 #undef DO_
 }
 
-void TraceInfo::SerializeWithCachedSizes(
+void Header::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.TraceInfo)
-  // optional string session_id = 1;
-  if (has_session_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->session_id().data(), this->session_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "session_id");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      1, this->session_id(), output);
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.Header)
+  // required uint32 service_id = 1;
+  if (has_service_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->service_id(), output);
   }
 
-  // optional string trace_id = 2;
-  if (has_trace_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->trace_id().data(), this->trace_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "trace_id");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      2, this->trace_id(), output);
+  // optional uint32 method_id = 2;
+  if (has_method_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->method_id(), output);
   }
 
-  // optional string span_id = 3;
-  if (has_span_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->span_id().data(), this->span_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "span_id");
-    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      3, this->span_id(), output);
+  // required uint32 token = 3;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->token(), output);
+  }
+
+  // optional uint64 object_id = 4 [default = 0];
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->object_id(), output);
+  }
+
+  // optional uint32 size = 5 [default = 0];
+  if (has_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->size(), output);
+  }
+
+  // optional uint32 status = 6 [default = 0];
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->status(), output);
+  }
+
+  // repeated .bgs.protocol.ErrorInfo error = 7;
+  for (int i = 0; i < this->error_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->error(i), output);
+  }
+
+  // optional uint64 timeout = 8;
+  if (has_timeout()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->timeout(), output);
   }
 
-  // optional string parent_span_id = 4;
-  if (has_parent_span_id()) {
+  // optional bool is_response = 9;
+  if (has_is_response()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->is_response(), output);
+  }
+
+  // repeated .bgs.protocol.ProcessId forward_targets = 10;
+  for (int i = 0; i < this->forward_targets_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->forward_targets(i), output);
+  }
+
+  // optional fixed32 service_hash = 11;
+  if (has_service_hash()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(11, this->service_hash(), output);
+  }
+
+  // optional string client_id = 13;
+  if (has_client_id()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->parent_span_id().data(), this->parent_span_id().length(),
+      this->client_id().data(), this->client_id().length(),
       ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "parent_span_id");
+      "client_id");
     ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
-      4, this->parent_span_id(), output);
-  }
-
-  // optional .bgs.protocol.TraceInfo.Sampling sampling = 5 [default = DEFER];
-  if (has_sampling()) {
-    ::google::protobuf::internal::WireFormatLite::WriteEnum(
-      5, this->sampling(), output);
+      13, this->client_id(), output);
   }
 
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.TraceInfo)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.Header)
 }
 
-::google::protobuf::uint8* TraceInfo::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* Header::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.TraceInfo)
-  // optional string session_id = 1;
-  if (has_session_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->session_id().data(), this->session_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "session_id");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        1, this->session_id(), target);
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Header)
+  // required uint32 service_id = 1;
+  if (has_service_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->service_id(), target);
   }
 
-  // optional string trace_id = 2;
-  if (has_trace_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->trace_id().data(), this->trace_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "trace_id");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        2, this->trace_id(), target);
+  // optional uint32 method_id = 2;
+  if (has_method_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->method_id(), target);
   }
 
-  // optional string span_id = 3;
-  if (has_span_id()) {
-    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->span_id().data(), this->span_id().length(),
-      ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "span_id");
-    target =
-      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        3, this->span_id(), target);
+  // required uint32 token = 3;
+  if (has_token()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->token(), target);
   }
 
-  // optional string parent_span_id = 4;
-  if (has_parent_span_id()) {
+  // optional uint64 object_id = 4 [default = 0];
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->object_id(), target);
+  }
+
+  // optional uint32 size = 5 [default = 0];
+  if (has_size()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->size(), target);
+  }
+
+  // optional uint32 status = 6 [default = 0];
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->status(), target);
+  }
+
+  // repeated .bgs.protocol.ErrorInfo error = 7;
+  for (int i = 0; i < this->error_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->error(i), target);
+  }
+
+  // optional uint64 timeout = 8;
+  if (has_timeout()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->timeout(), target);
+  }
+
+  // optional bool is_response = 9;
+  if (has_is_response()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->is_response(), target);
+  }
+
+  // repeated .bgs.protocol.ProcessId forward_targets = 10;
+  for (int i = 0; i < this->forward_targets_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->forward_targets(i), target);
+  }
+
+  // optional fixed32 service_hash = 11;
+  if (has_service_hash()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(11, this->service_hash(), target);
+  }
+
+  // optional string client_id = 13;
+  if (has_client_id()) {
     ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
-      this->parent_span_id().data(), this->parent_span_id().length(),
+      this->client_id().data(), this->client_id().length(),
       ::google::protobuf::internal::WireFormat::SERIALIZE,
-      "parent_span_id");
+      "client_id");
     target =
       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
-        4, this->parent_span_id(), target);
-  }
-
-  // optional .bgs.protocol.TraceInfo.Sampling sampling = 5 [default = DEFER];
-  if (has_sampling()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
-      5, this->sampling(), target);
+        13, this->client_id(), target);
   }
 
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.TraceInfo)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Header)
   return target;
 }
 
-int TraceInfo::ByteSize() const {
+int Header::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // optional string session_id = 1;
-    if (has_session_id()) {
+    // required uint32 service_id = 1;
+    if (has_service_id()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->session_id());
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->service_id());
     }
 
-    // optional string trace_id = 2;
-    if (has_trace_id()) {
+    // optional uint32 method_id = 2;
+    if (has_method_id()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->trace_id());
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->method_id());
     }
 
-    // optional string span_id = 3;
-    if (has_span_id()) {
+    // required uint32 token = 3;
+    if (has_token()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->span_id());
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->token());
+    }
+
+    // optional uint64 object_id = 4 [default = 0];
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
     }
 
-    // optional string parent_span_id = 4;
-    if (has_parent_span_id()) {
+    // optional uint32 size = 5 [default = 0];
+    if (has_size()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::StringSize(
-          this->parent_span_id());
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->size());
+    }
+
+    // optional uint32 status = 6 [default = 0];
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->status());
+    }
+
+    // optional uint64 timeout = 8;
+    if (has_timeout()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->timeout());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional bool is_response = 9;
+    if (has_is_response()) {
+      total_size += 1 + 1;
+    }
+
+    // optional fixed32 service_hash = 11;
+    if (has_service_hash()) {
+      total_size += 1 + 4;
     }
 
-    // optional .bgs.protocol.TraceInfo.Sampling sampling = 5 [default = DEFER];
-    if (has_sampling()) {
+    // optional string client_id = 13;
+    if (has_client_id()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::EnumSize(this->sampling());
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->client_id());
     }
 
   }
+  // repeated .bgs.protocol.ErrorInfo error = 7;
+  total_size += 1 * this->error_size();
+  for (int i = 0; i < this->error_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->error(i));
+  }
+
+  // repeated .bgs.protocol.ProcessId forward_targets = 10;
+  total_size += 1 * this->forward_targets_size();
+  for (int i = 0; i < this->forward_targets_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->forward_targets(i));
+  }
+
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -2272,10 +2447,10 @@ int TraceInfo::ByteSize() const {
   return total_size;
 }
 
-void TraceInfo::MergeFrom(const ::google::protobuf::Message& from) {
+void Header::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const TraceInfo* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const TraceInfo*>(
+  const Header* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Header*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -2284,63 +2459,92 @@ void TraceInfo::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void TraceInfo::MergeFrom(const TraceInfo& from) {
+void Header::MergeFrom(const Header& from) {
   GOOGLE_CHECK_NE(&from, this);
+  error_.MergeFrom(from.error_);
+  forward_targets_.MergeFrom(from.forward_targets_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_session_id()) {
-      set_session_id(from.session_id());
+    if (from.has_service_id()) {
+      set_service_id(from.service_id());
+    }
+    if (from.has_method_id()) {
+      set_method_id(from.method_id());
+    }
+    if (from.has_token()) {
+      set_token(from.token());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+    if (from.has_size()) {
+      set_size(from.size());
+    }
+    if (from.has_status()) {
+      set_status(from.status());
     }
-    if (from.has_trace_id()) {
-      set_trace_id(from.trace_id());
+    if (from.has_timeout()) {
+      set_timeout(from.timeout());
     }
-    if (from.has_span_id()) {
-      set_span_id(from.span_id());
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_is_response()) {
+      set_is_response(from.is_response());
     }
-    if (from.has_parent_span_id()) {
-      set_parent_span_id(from.parent_span_id());
+    if (from.has_service_hash()) {
+      set_service_hash(from.service_hash());
     }
-    if (from.has_sampling()) {
-      set_sampling(from.sampling());
+    if (from.has_client_id()) {
+      set_client_id(from.client_id());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void TraceInfo::CopyFrom(const ::google::protobuf::Message& from) {
+void Header::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void TraceInfo::CopyFrom(const TraceInfo& from) {
+void Header::CopyFrom(const Header& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool TraceInfo::IsInitialized() const {
+bool Header::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
 
+  if (!::google::protobuf::internal::AllAreInitialized(this->error())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->forward_targets())) return false;
   return true;
 }
 
-void TraceInfo::Swap(TraceInfo* other) {
+void Header::Swap(Header* other) {
   if (other != this) {
-    std::swap(session_id_, other->session_id_);
-    std::swap(trace_id_, other->trace_id_);
-    std::swap(span_id_, other->span_id_);
-    std::swap(parent_span_id_, other->parent_span_id_);
-    std::swap(sampling_, other->sampling_);
+    std::swap(service_id_, other->service_id_);
+    std::swap(method_id_, other->method_id_);
+    std::swap(token_, other->token_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(size_, other->size_);
+    std::swap(status_, other->status_);
+    error_.Swap(&other->error_);
+    std::swap(timeout_, other->timeout_);
+    std::swap(is_response_, other->is_response_);
+    forward_targets_.Swap(&other->forward_targets_);
+    std::swap(service_hash_, other->service_hash_);
+    std::swap(client_id_, other->client_id_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata TraceInfo::GetMetadata() const {
+::google::protobuf::Metadata Header::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = TraceInfo_descriptor_;
-  metadata.reflection = TraceInfo_reflection_;
+  metadata.descriptor = Header_descriptor_;
+  metadata.reflection = Header_reflection_;
   return metadata;
 }
 
@@ -2348,87 +2552,92 @@ void TraceInfo::Swap(TraceInfo* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int Header::kServiceIdFieldNumber;
-const int Header::kMethodIdFieldNumber;
-const int Header::kTokenFieldNumber;
-const int Header::kObjectIdFieldNumber;
-const int Header::kSizeFieldNumber;
-const int Header::kStatusFieldNumber;
-const int Header::kErrorFieldNumber;
-const int Header::kTimeoutFieldNumber;
-const int Header::kIsResponseFieldNumber;
-const int Header::kForwardTargetsFieldNumber;
-const int Header::kServiceHashFieldNumber;
-const int Header::kTraceInfoFieldNumber;
+const int KafkaHeader::kServiceHashFieldNumber;
+const int KafkaHeader::kMethodIdFieldNumber;
+const int KafkaHeader::kTokenFieldNumber;
+const int KafkaHeader::kObjectIdFieldNumber;
+const int KafkaHeader::kSizeFieldNumber;
+const int KafkaHeader::kStatusFieldNumber;
+const int KafkaHeader::kTimeoutFieldNumber;
+const int KafkaHeader::kForwardTargetFieldNumber;
+const int KafkaHeader::kReturnTopicFieldNumber;
+const int KafkaHeader::kClientIdFieldNumber;
 #endif  // !_MSC_VER
 
-Header::Header()
+KafkaHeader::KafkaHeader()
   : ::google::protobuf::Message() {
   SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.Header)
+  // @@protoc_insertion_point(constructor:bgs.protocol.KafkaHeader)
 }
 
-void Header::InitAsDefaultInstance() {
-  trace_info_ = const_cast< ::bgs::protocol::TraceInfo*>(&::bgs::protocol::TraceInfo::default_instance());
+void KafkaHeader::InitAsDefaultInstance() {
+  forward_target_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
 }
 
-Header::Header(const Header& from)
+KafkaHeader::KafkaHeader(const KafkaHeader& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Header)
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.KafkaHeader)
 }
 
-void Header::SharedCtor() {
+void KafkaHeader::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
   _cached_size_ = 0;
-  service_id_ = 0u;
+  service_hash_ = 0u;
   method_id_ = 0u;
   token_ = 0u;
   object_id_ = GOOGLE_ULONGLONG(0);
   size_ = 0u;
   status_ = 0u;
   timeout_ = GOOGLE_ULONGLONG(0);
-  is_response_ = false;
-  service_hash_ = 0u;
-  trace_info_ = NULL;
+  forward_target_ = NULL;
+  return_topic_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
-Header::~Header() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.Header)
+KafkaHeader::~KafkaHeader() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.KafkaHeader)
   SharedDtor();
 }
 
-void Header::SharedDtor() {
+void KafkaHeader::SharedDtor() {
+  if (return_topic_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete return_topic_;
+  }
+  if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_id_;
+  }
   if (this != default_instance_) {
-    delete trace_info_;
+    delete forward_target_;
   }
 }
 
-void Header::SetCachedSize(int size) const {
+void KafkaHeader::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
-const ::google::protobuf::Descriptor* Header::descriptor() {
+const ::google::protobuf::Descriptor* KafkaHeader::descriptor() {
   protobuf_AssignDescriptorsOnce();
-  return Header_descriptor_;
+  return KafkaHeader_descriptor_;
 }
 
-const Header& Header::default_instance() {
+const KafkaHeader& KafkaHeader::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto();
   return *default_instance_;
 }
 
-Header* Header::default_instance_ = NULL;
+KafkaHeader* KafkaHeader::default_instance_ = NULL;
 
-Header* Header::New() const {
-  return new Header;
+KafkaHeader* KafkaHeader::New() const {
+  return new KafkaHeader;
 }
 
-void Header::Clear() {
+void KafkaHeader::Clear() {
 #define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
-  &reinterpret_cast<Header*>(16)->f) - \
+  &reinterpret_cast<KafkaHeader*>(16)->f) - \
    reinterpret_cast<char*>(16))
 
 #define ZR_(first, last) do {                              \
@@ -2437,45 +2646,50 @@ void Header::Clear() {
     ::memset(&first, 0, n);                                \
   } while (0)
 
-  if (_has_bits_[0 / 32] & 191) {
-    ZR_(service_id_, size_);
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(service_hash_, timeout_);
     status_ = 0u;
-    timeout_ = GOOGLE_ULONGLONG(0);
+    if (has_forward_target()) {
+      if (forward_target_ != NULL) forward_target_->::bgs::protocol::ProcessId::Clear();
+    }
   }
-  if (_has_bits_[8 / 32] & 3328) {
-    is_response_ = false;
-    service_hash_ = 0u;
-    if (has_trace_info()) {
-      if (trace_info_ != NULL) trace_info_->::bgs::protocol::TraceInfo::Clear();
+  if (_has_bits_[8 / 32] & 768) {
+    if (has_return_topic()) {
+      if (return_topic_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        return_topic_->clear();
+      }
+    }
+    if (has_client_id()) {
+      if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        client_id_->clear();
+      }
     }
   }
 
 #undef OFFSET_OF_FIELD_
 #undef ZR_
 
-  error_.Clear();
-  forward_targets_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
-bool Header::MergePartialFromCodedStream(
+bool KafkaHeader::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
   ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.Header)
+  // @@protoc_insertion_point(parse_start:bgs.protocol.KafkaHeader)
   for (;;) {
     ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
     tag = p.first;
     if (!p.second) goto handle_unusual;
     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // required uint32 service_id = 1;
+      // optional fixed32 service_hash = 1;
       case 1: {
-        if (tag == 8) {
+        if (tag == 13) {
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
-                 input, &service_id_)));
-          set_has_service_id();
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &service_hash_)));
+          set_has_service_hash();
         } else {
           goto handle_unusual;
         }
@@ -2498,7 +2712,7 @@ bool Header::MergePartialFromCodedStream(
         break;
       }
 
-      // required uint32 token = 3;
+      // optional uint32 token = 3;
       case 3: {
         if (tag == 24) {
          parse_token:
@@ -2554,27 +2768,13 @@ bool Header::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(58)) goto parse_error;
+        if (input->ExpectTag(56)) goto parse_timeout;
         break;
       }
 
-      // repeated .bgs.protocol.ErrorInfo error = 7;
+      // optional uint64 timeout = 7;
       case 7: {
-        if (tag == 58) {
-         parse_error:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_error()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(58)) goto parse_error;
-        if (input->ExpectTag(64)) goto parse_timeout;
-        break;
-      }
-
-      // optional uint64 timeout = 8;
-      case 8: {
-        if (tag == 64) {
+        if (tag == 56) {
          parse_timeout:
           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                    ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
@@ -2583,60 +2783,50 @@ bool Header::MergePartialFromCodedStream(
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(72)) goto parse_is_response;
-        break;
-      }
-
-      // optional bool is_response = 9;
-      case 9: {
-        if (tag == 72) {
-         parse_is_response:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
-                 input, &is_response_)));
-          set_has_is_response();
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(82)) goto parse_forward_targets;
+        if (input->ExpectTag(66)) goto parse_forward_target;
         break;
       }
 
-      // repeated .bgs.protocol.ProcessId forward_targets = 10;
-      case 10: {
-        if (tag == 82) {
-         parse_forward_targets:
+      // optional .bgs.protocol.ProcessId forward_target = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_forward_target:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_forward_targets()));
+               input, mutable_forward_target()));
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(82)) goto parse_forward_targets;
-        if (input->ExpectTag(93)) goto parse_service_hash;
+        if (input->ExpectTag(74)) goto parse_return_topic;
         break;
       }
 
-      // optional fixed32 service_hash = 11;
-      case 11: {
-        if (tag == 93) {
-         parse_service_hash:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, &service_hash_)));
-          set_has_service_hash();
+      // optional string return_topic = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_return_topic:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_return_topic()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->return_topic().data(), this->return_topic().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "return_topic");
         } else {
           goto handle_unusual;
         }
-        if (input->ExpectTag(98)) goto parse_trace_info;
+        if (input->ExpectTag(90)) goto parse_client_id;
         break;
       }
 
-      // optional .bgs.protocol.TraceInfo trace_info = 12;
-      case 12: {
-        if (tag == 98) {
-         parse_trace_info:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-               input, mutable_trace_info()));
+      // optional string client_id = 11;
+      case 11: {
+        if (tag == 90) {
+         parse_client_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_client_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->client_id().data(), this->client_id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "client_id");
         } else {
           goto handle_unusual;
         }
@@ -2658,20 +2848,20 @@ bool Header::MergePartialFromCodedStream(
     }
   }
 success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.Header)
+  // @@protoc_insertion_point(parse_success:bgs.protocol.KafkaHeader)
   return true;
 failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.Header)
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.KafkaHeader)
   return false;
 #undef DO_
 }
 
-void Header::SerializeWithCachedSizes(
+void KafkaHeader::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.Header)
-  // required uint32 service_id = 1;
-  if (has_service_id()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->service_id(), output);
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.KafkaHeader)
+  // optional fixed32 service_hash = 1;
+  if (has_service_hash()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->service_hash(), output);
   }
 
   // optional uint32 method_id = 2;
@@ -2679,7 +2869,7 @@ void Header::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->method_id(), output);
   }
 
-  // required uint32 token = 3;
+  // optional uint32 token = 3;
   if (has_token()) {
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->token(), output);
   }
@@ -2699,52 +2889,50 @@ void Header::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->status(), output);
   }
 
-  // repeated .bgs.protocol.ErrorInfo error = 7;
-  for (int i = 0; i < this->error_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      7, this->error(i), output);
-  }
-
-  // optional uint64 timeout = 8;
+  // optional uint64 timeout = 7;
   if (has_timeout()) {
-    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->timeout(), output);
-  }
-
-  // optional bool is_response = 9;
-  if (has_is_response()) {
-    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->is_response(), output);
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->timeout(), output);
   }
 
-  // repeated .bgs.protocol.ProcessId forward_targets = 10;
-  for (int i = 0; i < this->forward_targets_size(); i++) {
+  // optional .bgs.protocol.ProcessId forward_target = 8;
+  if (has_forward_target()) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      10, this->forward_targets(i), output);
+      8, this->forward_target(), output);
   }
 
-  // optional fixed32 service_hash = 11;
-  if (has_service_hash()) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(11, this->service_hash(), output);
+  // optional string return_topic = 9;
+  if (has_return_topic()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->return_topic().data(), this->return_topic().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "return_topic");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      9, this->return_topic(), output);
   }
 
-  // optional .bgs.protocol.TraceInfo trace_info = 12;
-  if (has_trace_info()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      12, this->trace_info(), output);
+  // optional string client_id = 11;
+  if (has_client_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->client_id().data(), this->client_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "client_id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      11, this->client_id(), output);
   }
 
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.Header)
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.KafkaHeader)
 }
 
-::google::protobuf::uint8* Header::SerializeWithCachedSizesToArray(
+::google::protobuf::uint8* KafkaHeader::SerializeWithCachedSizesToArray(
     ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Header)
-  // required uint32 service_id = 1;
-  if (has_service_id()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->service_id(), target);
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.KafkaHeader)
+  // optional fixed32 service_hash = 1;
+  if (has_service_hash()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->service_hash(), target);
   }
 
   // optional uint32 method_id = 2;
@@ -2752,7 +2940,7 @@ void Header::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->method_id(), target);
   }
 
-  // required uint32 token = 3;
+  // optional uint32 token = 3;
   if (has_token()) {
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->token(), target);
   }
@@ -2772,59 +2960,55 @@ void Header::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->status(), target);
   }
 
-  // repeated .bgs.protocol.ErrorInfo error = 7;
-  for (int i = 0; i < this->error_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        7, this->error(i), target);
-  }
-
-  // optional uint64 timeout = 8;
+  // optional uint64 timeout = 7;
   if (has_timeout()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->timeout(), target);
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->timeout(), target);
   }
 
-  // optional bool is_response = 9;
-  if (has_is_response()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->is_response(), target);
-  }
-
-  // repeated .bgs.protocol.ProcessId forward_targets = 10;
-  for (int i = 0; i < this->forward_targets_size(); i++) {
+  // optional .bgs.protocol.ProcessId forward_target = 8;
+  if (has_forward_target()) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
-        10, this->forward_targets(i), target);
+        8, this->forward_target(), target);
   }
 
-  // optional fixed32 service_hash = 11;
-  if (has_service_hash()) {
-    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(11, this->service_hash(), target);
+  // optional string return_topic = 9;
+  if (has_return_topic()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->return_topic().data(), this->return_topic().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "return_topic");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        9, this->return_topic(), target);
   }
 
-  // optional .bgs.protocol.TraceInfo trace_info = 12;
-  if (has_trace_info()) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        12, this->trace_info(), target);
+  // optional string client_id = 11;
+  if (has_client_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->client_id().data(), this->client_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "client_id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        11, this->client_id(), target);
   }
 
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Header)
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.KafkaHeader)
   return target;
 }
 
-int Header::ByteSize() const {
+int KafkaHeader::ByteSize() const {
   int total_size = 0;
 
   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    // required uint32 service_id = 1;
-    if (has_service_id()) {
-      total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::UInt32Size(
-          this->service_id());
+    // optional fixed32 service_hash = 1;
+    if (has_service_hash()) {
+      total_size += 1 + 4;
     }
 
     // optional uint32 method_id = 2;
@@ -2834,7 +3018,7 @@ int Header::ByteSize() const {
           this->method_id());
     }
 
-    // required uint32 token = 3;
+    // optional uint32 token = 3;
     if (has_token()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt32Size(
@@ -2862,49 +3046,37 @@ int Header::ByteSize() const {
           this->status());
     }
 
-    // optional uint64 timeout = 8;
+    // optional uint64 timeout = 7;
     if (has_timeout()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt64Size(
           this->timeout());
     }
 
-  }
-  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
-    // optional bool is_response = 9;
-    if (has_is_response()) {
-      total_size += 1 + 1;
+    // optional .bgs.protocol.ProcessId forward_target = 8;
+    if (has_forward_target()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->forward_target());
     }
 
-    // optional fixed32 service_hash = 11;
-    if (has_service_hash()) {
-      total_size += 1 + 4;
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional string return_topic = 9;
+    if (has_return_topic()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->return_topic());
     }
 
-    // optional .bgs.protocol.TraceInfo trace_info = 12;
-    if (has_trace_info()) {
+    // optional string client_id = 11;
+    if (has_client_id()) {
       total_size += 1 +
-        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-          this->trace_info());
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->client_id());
     }
 
   }
-  // repeated .bgs.protocol.ErrorInfo error = 7;
-  total_size += 1 * this->error_size();
-  for (int i = 0; i < this->error_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->error(i));
-  }
-
-  // repeated .bgs.protocol.ProcessId forward_targets = 10;
-  total_size += 1 * this->forward_targets_size();
-  for (int i = 0; i < this->forward_targets_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->forward_targets(i));
-  }
-
   if (!unknown_fields().empty()) {
     total_size +=
       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
@@ -2916,10 +3088,10 @@ int Header::ByteSize() const {
   return total_size;
 }
 
-void Header::MergeFrom(const ::google::protobuf::Message& from) {
+void KafkaHeader::MergeFrom(const ::google::protobuf::Message& from) {
   GOOGLE_CHECK_NE(&from, this);
-  const Header* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const Header*>(
+  const KafkaHeader* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const KafkaHeader*>(
       &from);
   if (source == NULL) {
     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
@@ -2928,13 +3100,11 @@ void Header::MergeFrom(const ::google::protobuf::Message& from) {
   }
 }
 
-void Header::MergeFrom(const Header& from) {
+void KafkaHeader::MergeFrom(const KafkaHeader& from) {
   GOOGLE_CHECK_NE(&from, this);
-  error_.MergeFrom(from.error_);
-  forward_targets_.MergeFrom(from.forward_targets_);
   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
-    if (from.has_service_id()) {
-      set_service_id(from.service_id());
+    if (from.has_service_hash()) {
+      set_service_hash(from.service_hash());
     }
     if (from.has_method_id()) {
       set_method_id(from.method_id());
@@ -2954,66 +3124,64 @@ void Header::MergeFrom(const Header& from) {
     if (from.has_timeout()) {
       set_timeout(from.timeout());
     }
+    if (from.has_forward_target()) {
+      mutable_forward_target()->::bgs::protocol::ProcessId::MergeFrom(from.forward_target());
+    }
   }
   if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
-    if (from.has_is_response()) {
-      set_is_response(from.is_response());
-    }
-    if (from.has_service_hash()) {
-      set_service_hash(from.service_hash());
+    if (from.has_return_topic()) {
+      set_return_topic(from.return_topic());
     }
-    if (from.has_trace_info()) {
-      mutable_trace_info()->::bgs::protocol::TraceInfo::MergeFrom(from.trace_info());
+    if (from.has_client_id()) {
+      set_client_id(from.client_id());
     }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
-void Header::CopyFrom(const ::google::protobuf::Message& from) {
+void KafkaHeader::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-void Header::CopyFrom(const Header& from) {
+void KafkaHeader::CopyFrom(const KafkaHeader& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
 }
 
-bool Header::IsInitialized() const {
-  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
+bool KafkaHeader::IsInitialized() const {
 
-  if (!::google::protobuf::internal::AllAreInitialized(this->error())) return false;
-  if (!::google::protobuf::internal::AllAreInitialized(this->forward_targets())) return false;
+  if (has_forward_target()) {
+    if (!this->forward_target().IsInitialized()) return false;
+  }
   return true;
 }
 
-void Header::Swap(Header* other) {
+void KafkaHeader::Swap(KafkaHeader* other) {
   if (other != this) {
-    std::swap(service_id_, other->service_id_);
+    std::swap(service_hash_, other->service_hash_);
     std::swap(method_id_, other->method_id_);
     std::swap(token_, other->token_);
     std::swap(object_id_, other->object_id_);
     std::swap(size_, other->size_);
     std::swap(status_, other->status_);
-    error_.Swap(&other->error_);
     std::swap(timeout_, other->timeout_);
-    std::swap(is_response_, other->is_response_);
-    forward_targets_.Swap(&other->forward_targets_);
-    std::swap(service_hash_, other->service_hash_);
-    std::swap(trace_info_, other->trace_info_);
+    std::swap(forward_target_, other->forward_target_);
+    std::swap(return_topic_, other->return_topic_);
+    std::swap(client_id_, other->client_id_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
-::google::protobuf::Metadata Header::GetMetadata() const {
+::google::protobuf::Metadata KafkaHeader::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::Metadata metadata;
-  metadata.descriptor = Header_descriptor_;
-  metadata.reflection = Header_reflection_;
+  metadata.descriptor = KafkaHeader_descriptor_;
+  metadata.reflection = KafkaHeader_reflection_;
   return metadata;
 }
 
diff --git a/src/server/proto/Client/rpc_types.pb.h b/src/server/proto/Client/rpc_types.pb.h
index 2ace3cac87e..4d56daf3131 100644
--- a/src/server/proto/Client/rpc_types.pb.h
+++ b/src/server/proto/Client/rpc_types.pb.h
@@ -23,11 +23,11 @@
 #include <google/protobuf/message.h>
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/extension_set.h>
-#include <google/protobuf/generated_enum_reflection.h>
 #include <google/protobuf/unknown_field_set.h>
+#include "global_extensions/field_options.pb.h"  // IWYU pragma: export
 #include "global_extensions/method_options.pb.h"  // IWYU pragma: export
+#include "global_extensions/message_options.pb.h"  // IWYU pragma: export
 #include "global_extensions/service_options.pb.h"  // IWYU pragma: export
-#include "global_extensions/field_options.pb.h"  // IWYU pragma: export
 #include "Define.h" // for TC_PROTO_API
 // @@protoc_insertion_point(includes)
 
@@ -45,29 +45,9 @@ class ProcessId;
 class ObjectAddress;
 class NoData;
 class ErrorInfo;
-class TraceInfo;
 class Header;
+class KafkaHeader;
 
-enum TraceInfo_Sampling {
-  TraceInfo_Sampling_YES = 0,
-  TraceInfo_Sampling_NO = 1,
-  TraceInfo_Sampling_DEFER = 2
-};
-TC_PROTO_API bool TraceInfo_Sampling_IsValid(int value);
-const TraceInfo_Sampling TraceInfo_Sampling_Sampling_MIN = TraceInfo_Sampling_YES;
-const TraceInfo_Sampling TraceInfo_Sampling_Sampling_MAX = TraceInfo_Sampling_DEFER;
-const int TraceInfo_Sampling_Sampling_ARRAYSIZE = TraceInfo_Sampling_Sampling_MAX + 1;
-
-TC_PROTO_API const ::google::protobuf::EnumDescriptor* TraceInfo_Sampling_descriptor();
-inline const ::std::string& TraceInfo_Sampling_Name(TraceInfo_Sampling value) {
-  return ::google::protobuf::internal::NameOfEnum(
-    TraceInfo_Sampling_descriptor(), value);
-}
-inline bool TraceInfo_Sampling_Parse(
-    const ::std::string& name, TraceInfo_Sampling* value) {
-  return ::google::protobuf::internal::ParseNamedEnum<TraceInfo_Sampling>(
-    TraceInfo_Sampling_descriptor(), name, value);
-}
 // ===================================================================
 
 class TC_PROTO_API NO_RESPONSE : public ::google::protobuf::Message {
@@ -593,170 +573,6 @@ class TC_PROTO_API ErrorInfo : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API TraceInfo : public ::google::protobuf::Message {
- public:
-  TraceInfo();
-  virtual ~TraceInfo();
-
-  TraceInfo(const TraceInfo& from);
-
-  inline TraceInfo& operator=(const TraceInfo& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const TraceInfo& default_instance();
-
-  void Swap(TraceInfo* other);
-
-  // implements Message ----------------------------------------------
-
-  TraceInfo* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const TraceInfo& from);
-  void MergeFrom(const TraceInfo& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  typedef TraceInfo_Sampling Sampling;
-  static const Sampling YES = TraceInfo_Sampling_YES;
-  static const Sampling NO = TraceInfo_Sampling_NO;
-  static const Sampling DEFER = TraceInfo_Sampling_DEFER;
-  static inline bool Sampling_IsValid(int value) {
-    return TraceInfo_Sampling_IsValid(value);
-  }
-  static const Sampling Sampling_MIN =
-    TraceInfo_Sampling_Sampling_MIN;
-  static const Sampling Sampling_MAX =
-    TraceInfo_Sampling_Sampling_MAX;
-  static const int Sampling_ARRAYSIZE =
-    TraceInfo_Sampling_Sampling_ARRAYSIZE;
-  static inline const ::google::protobuf::EnumDescriptor*
-  Sampling_descriptor() {
-    return TraceInfo_Sampling_descriptor();
-  }
-  static inline const ::std::string& Sampling_Name(Sampling value) {
-    return TraceInfo_Sampling_Name(value);
-  }
-  static inline bool Sampling_Parse(const ::std::string& name,
-      Sampling* value) {
-    return TraceInfo_Sampling_Parse(name, value);
-  }
-
-  // accessors -------------------------------------------------------
-
-  // optional string session_id = 1;
-  inline bool has_session_id() const;
-  inline void clear_session_id();
-  static const int kSessionIdFieldNumber = 1;
-  inline const ::std::string& session_id() const;
-  inline void set_session_id(const ::std::string& value);
-  inline void set_session_id(const char* value);
-  inline void set_session_id(const char* value, size_t size);
-  inline ::std::string* mutable_session_id();
-  inline ::std::string* release_session_id();
-  inline void set_allocated_session_id(::std::string* session_id);
-
-  // optional string trace_id = 2;
-  inline bool has_trace_id() const;
-  inline void clear_trace_id();
-  static const int kTraceIdFieldNumber = 2;
-  inline const ::std::string& trace_id() const;
-  inline void set_trace_id(const ::std::string& value);
-  inline void set_trace_id(const char* value);
-  inline void set_trace_id(const char* value, size_t size);
-  inline ::std::string* mutable_trace_id();
-  inline ::std::string* release_trace_id();
-  inline void set_allocated_trace_id(::std::string* trace_id);
-
-  // optional string span_id = 3;
-  inline bool has_span_id() const;
-  inline void clear_span_id();
-  static const int kSpanIdFieldNumber = 3;
-  inline const ::std::string& span_id() const;
-  inline void set_span_id(const ::std::string& value);
-  inline void set_span_id(const char* value);
-  inline void set_span_id(const char* value, size_t size);
-  inline ::std::string* mutable_span_id();
-  inline ::std::string* release_span_id();
-  inline void set_allocated_span_id(::std::string* span_id);
-
-  // optional string parent_span_id = 4;
-  inline bool has_parent_span_id() const;
-  inline void clear_parent_span_id();
-  static const int kParentSpanIdFieldNumber = 4;
-  inline const ::std::string& parent_span_id() const;
-  inline void set_parent_span_id(const ::std::string& value);
-  inline void set_parent_span_id(const char* value);
-  inline void set_parent_span_id(const char* value, size_t size);
-  inline ::std::string* mutable_parent_span_id();
-  inline ::std::string* release_parent_span_id();
-  inline void set_allocated_parent_span_id(::std::string* parent_span_id);
-
-  // optional .bgs.protocol.TraceInfo.Sampling sampling = 5 [default = DEFER];
-  inline bool has_sampling() const;
-  inline void clear_sampling();
-  static const int kSamplingFieldNumber = 5;
-  inline ::bgs::protocol::TraceInfo_Sampling sampling() const;
-  inline void set_sampling(::bgs::protocol::TraceInfo_Sampling value);
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.TraceInfo)
- private:
-  inline void set_has_session_id();
-  inline void clear_has_session_id();
-  inline void set_has_trace_id();
-  inline void clear_has_trace_id();
-  inline void set_has_span_id();
-  inline void clear_has_span_id();
-  inline void set_has_parent_span_id();
-  inline void clear_has_parent_span_id();
-  inline void set_has_sampling();
-  inline void clear_has_sampling();
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::std::string* session_id_;
-  ::std::string* trace_id_;
-  ::std::string* span_id_;
-  ::std::string* parent_span_id_;
-  int sampling_;
-  friend void TC_PROTO_API protobuf_AddDesc_rpc_5ftypes_2eproto();
-  friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
-  friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
-
-  void InitAsDefaultInstance();
-  static TraceInfo* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API Header : public ::google::protobuf::Message {
  public:
   Header();
@@ -897,14 +713,17 @@ class TC_PROTO_API Header : public ::google::protobuf::Message {
   inline ::google::protobuf::uint32 service_hash() const;
   inline void set_service_hash(::google::protobuf::uint32 value);
 
-  // optional .bgs.protocol.TraceInfo trace_info = 12;
-  inline bool has_trace_info() const;
-  inline void clear_trace_info();
-  static const int kTraceInfoFieldNumber = 12;
-  inline const ::bgs::protocol::TraceInfo& trace_info() const;
-  inline ::bgs::protocol::TraceInfo* mutable_trace_info();
-  inline ::bgs::protocol::TraceInfo* release_trace_info();
-  inline void set_allocated_trace_info(::bgs::protocol::TraceInfo* trace_info);
+  // optional string client_id = 13;
+  inline bool has_client_id() const;
+  inline void clear_client_id();
+  static const int kClientIdFieldNumber = 13;
+  inline const ::std::string& client_id() const;
+  inline void set_client_id(const ::std::string& value);
+  inline void set_client_id(const char* value);
+  inline void set_client_id(const char* value, size_t size);
+  inline ::std::string* mutable_client_id();
+  inline ::std::string* release_client_id();
+  inline void set_allocated_client_id(::std::string* client_id);
 
   // @@protoc_insertion_point(class_scope:bgs.protocol.Header)
  private:
@@ -926,8 +745,8 @@ class TC_PROTO_API Header : public ::google::protobuf::Message {
   inline void clear_has_is_response();
   inline void set_has_service_hash();
   inline void clear_has_service_hash();
-  inline void set_has_trace_info();
-  inline void clear_has_trace_info();
+  inline void set_has_client_id();
+  inline void clear_has_client_id();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
@@ -943,7 +762,7 @@ class TC_PROTO_API Header : public ::google::protobuf::Message {
   bool is_response_;
   ::google::protobuf::uint64 timeout_;
   ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId > forward_targets_;
-  ::bgs::protocol::TraceInfo* trace_info_;
+  ::std::string* client_id_;
   ::google::protobuf::uint32 service_hash_;
   friend void TC_PROTO_API protobuf_AddDesc_rpc_5ftypes_2eproto();
   friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
@@ -952,6 +771,187 @@ class TC_PROTO_API Header : public ::google::protobuf::Message {
   void InitAsDefaultInstance();
   static Header* default_instance_;
 };
+// -------------------------------------------------------------------
+
+class TC_PROTO_API KafkaHeader : public ::google::protobuf::Message {
+ public:
+  KafkaHeader();
+  virtual ~KafkaHeader();
+
+  KafkaHeader(const KafkaHeader& from);
+
+  inline KafkaHeader& operator=(const KafkaHeader& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const KafkaHeader& default_instance();
+
+  void Swap(KafkaHeader* other);
+
+  // implements Message ----------------------------------------------
+
+  KafkaHeader* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const KafkaHeader& from);
+  void MergeFrom(const KafkaHeader& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional fixed32 service_hash = 1;
+  inline bool has_service_hash() const;
+  inline void clear_service_hash();
+  static const int kServiceHashFieldNumber = 1;
+  inline ::google::protobuf::uint32 service_hash() const;
+  inline void set_service_hash(::google::protobuf::uint32 value);
+
+  // optional uint32 method_id = 2;
+  inline bool has_method_id() const;
+  inline void clear_method_id();
+  static const int kMethodIdFieldNumber = 2;
+  inline ::google::protobuf::uint32 method_id() const;
+  inline void set_method_id(::google::protobuf::uint32 value);
+
+  // optional uint32 token = 3;
+  inline bool has_token() const;
+  inline void clear_token();
+  static const int kTokenFieldNumber = 3;
+  inline ::google::protobuf::uint32 token() const;
+  inline void set_token(::google::protobuf::uint32 value);
+
+  // optional uint64 object_id = 4 [default = 0];
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // optional uint32 size = 5 [default = 0];
+  inline bool has_size() const;
+  inline void clear_size();
+  static const int kSizeFieldNumber = 5;
+  inline ::google::protobuf::uint32 size() const;
+  inline void set_size(::google::protobuf::uint32 value);
+
+  // optional uint32 status = 6 [default = 0];
+  inline bool has_status() const;
+  inline void clear_status();
+  static const int kStatusFieldNumber = 6;
+  inline ::google::protobuf::uint32 status() const;
+  inline void set_status(::google::protobuf::uint32 value);
+
+  // optional uint64 timeout = 7;
+  inline bool has_timeout() const;
+  inline void clear_timeout();
+  static const int kTimeoutFieldNumber = 7;
+  inline ::google::protobuf::uint64 timeout() const;
+  inline void set_timeout(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.ProcessId forward_target = 8;
+  inline bool has_forward_target() const;
+  inline void clear_forward_target();
+  static const int kForwardTargetFieldNumber = 8;
+  inline const ::bgs::protocol::ProcessId& forward_target() const;
+  inline ::bgs::protocol::ProcessId* mutable_forward_target();
+  inline ::bgs::protocol::ProcessId* release_forward_target();
+  inline void set_allocated_forward_target(::bgs::protocol::ProcessId* forward_target);
+
+  // optional string return_topic = 9;
+  inline bool has_return_topic() const;
+  inline void clear_return_topic();
+  static const int kReturnTopicFieldNumber = 9;
+  inline const ::std::string& return_topic() const;
+  inline void set_return_topic(const ::std::string& value);
+  inline void set_return_topic(const char* value);
+  inline void set_return_topic(const char* value, size_t size);
+  inline ::std::string* mutable_return_topic();
+  inline ::std::string* release_return_topic();
+  inline void set_allocated_return_topic(::std::string* return_topic);
+
+  // optional string client_id = 11;
+  inline bool has_client_id() const;
+  inline void clear_client_id();
+  static const int kClientIdFieldNumber = 11;
+  inline const ::std::string& client_id() const;
+  inline void set_client_id(const ::std::string& value);
+  inline void set_client_id(const char* value);
+  inline void set_client_id(const char* value, size_t size);
+  inline ::std::string* mutable_client_id();
+  inline ::std::string* release_client_id();
+  inline void set_allocated_client_id(::std::string* client_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.KafkaHeader)
+ private:
+  inline void set_has_service_hash();
+  inline void clear_has_service_hash();
+  inline void set_has_method_id();
+  inline void clear_has_method_id();
+  inline void set_has_token();
+  inline void clear_has_token();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+  inline void set_has_size();
+  inline void clear_has_size();
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_timeout();
+  inline void clear_has_timeout();
+  inline void set_has_forward_target();
+  inline void clear_has_forward_target();
+  inline void set_has_return_topic();
+  inline void clear_has_return_topic();
+  inline void set_has_client_id();
+  inline void clear_has_client_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 service_hash_;
+  ::google::protobuf::uint32 method_id_;
+  ::google::protobuf::uint64 object_id_;
+  ::google::protobuf::uint32 token_;
+  ::google::protobuf::uint32 size_;
+  ::google::protobuf::uint64 timeout_;
+  ::bgs::protocol::ProcessId* forward_target_;
+  ::std::string* return_topic_;
+  ::std::string* client_id_;
+  ::google::protobuf::uint32 status_;
+  friend void TC_PROTO_API protobuf_AddDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static KafkaHeader* default_instance_;
+};
 // ===================================================================
 
 
@@ -1310,339 +1310,6 @@ inline void ErrorInfo::set_method_id(::google::protobuf::uint32 value) {
 
 // -------------------------------------------------------------------
 
-// TraceInfo
-
-// optional string session_id = 1;
-inline bool TraceInfo::has_session_id() const {
-  return (_has_bits_[0] & 0x00000001u) != 0;
-}
-inline void TraceInfo::set_has_session_id() {
-  _has_bits_[0] |= 0x00000001u;
-}
-inline void TraceInfo::clear_has_session_id() {
-  _has_bits_[0] &= ~0x00000001u;
-}
-inline void TraceInfo::clear_session_id() {
-  if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_id_->clear();
-  }
-  clear_has_session_id();
-}
-inline const ::std::string& TraceInfo::session_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.TraceInfo.session_id)
-  return *session_id_;
-}
-inline void TraceInfo::set_session_id(const ::std::string& value) {
-  set_has_session_id();
-  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_id_ = new ::std::string;
-  }
-  session_id_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.TraceInfo.session_id)
-}
-inline void TraceInfo::set_session_id(const char* value) {
-  set_has_session_id();
-  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_id_ = new ::std::string;
-  }
-  session_id_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.TraceInfo.session_id)
-}
-inline void TraceInfo::set_session_id(const char* value, size_t size) {
-  set_has_session_id();
-  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_id_ = new ::std::string;
-  }
-  session_id_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.TraceInfo.session_id)
-}
-inline ::std::string* TraceInfo::mutable_session_id() {
-  set_has_session_id();
-  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    session_id_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.TraceInfo.session_id)
-  return session_id_;
-}
-inline ::std::string* TraceInfo::release_session_id() {
-  clear_has_session_id();
-  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = session_id_;
-    session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void TraceInfo::set_allocated_session_id(::std::string* session_id) {
-  if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete session_id_;
-  }
-  if (session_id) {
-    set_has_session_id();
-    session_id_ = session_id;
-  } else {
-    clear_has_session_id();
-    session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.TraceInfo.session_id)
-}
-
-// optional string trace_id = 2;
-inline bool TraceInfo::has_trace_id() const {
-  return (_has_bits_[0] & 0x00000002u) != 0;
-}
-inline void TraceInfo::set_has_trace_id() {
-  _has_bits_[0] |= 0x00000002u;
-}
-inline void TraceInfo::clear_has_trace_id() {
-  _has_bits_[0] &= ~0x00000002u;
-}
-inline void TraceInfo::clear_trace_id() {
-  if (trace_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    trace_id_->clear();
-  }
-  clear_has_trace_id();
-}
-inline const ::std::string& TraceInfo::trace_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.TraceInfo.trace_id)
-  return *trace_id_;
-}
-inline void TraceInfo::set_trace_id(const ::std::string& value) {
-  set_has_trace_id();
-  if (trace_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    trace_id_ = new ::std::string;
-  }
-  trace_id_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.TraceInfo.trace_id)
-}
-inline void TraceInfo::set_trace_id(const char* value) {
-  set_has_trace_id();
-  if (trace_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    trace_id_ = new ::std::string;
-  }
-  trace_id_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.TraceInfo.trace_id)
-}
-inline void TraceInfo::set_trace_id(const char* value, size_t size) {
-  set_has_trace_id();
-  if (trace_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    trace_id_ = new ::std::string;
-  }
-  trace_id_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.TraceInfo.trace_id)
-}
-inline ::std::string* TraceInfo::mutable_trace_id() {
-  set_has_trace_id();
-  if (trace_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    trace_id_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.TraceInfo.trace_id)
-  return trace_id_;
-}
-inline ::std::string* TraceInfo::release_trace_id() {
-  clear_has_trace_id();
-  if (trace_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = trace_id_;
-    trace_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void TraceInfo::set_allocated_trace_id(::std::string* trace_id) {
-  if (trace_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete trace_id_;
-  }
-  if (trace_id) {
-    set_has_trace_id();
-    trace_id_ = trace_id;
-  } else {
-    clear_has_trace_id();
-    trace_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.TraceInfo.trace_id)
-}
-
-// optional string span_id = 3;
-inline bool TraceInfo::has_span_id() const {
-  return (_has_bits_[0] & 0x00000004u) != 0;
-}
-inline void TraceInfo::set_has_span_id() {
-  _has_bits_[0] |= 0x00000004u;
-}
-inline void TraceInfo::clear_has_span_id() {
-  _has_bits_[0] &= ~0x00000004u;
-}
-inline void TraceInfo::clear_span_id() {
-  if (span_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    span_id_->clear();
-  }
-  clear_has_span_id();
-}
-inline const ::std::string& TraceInfo::span_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.TraceInfo.span_id)
-  return *span_id_;
-}
-inline void TraceInfo::set_span_id(const ::std::string& value) {
-  set_has_span_id();
-  if (span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    span_id_ = new ::std::string;
-  }
-  span_id_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.TraceInfo.span_id)
-}
-inline void TraceInfo::set_span_id(const char* value) {
-  set_has_span_id();
-  if (span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    span_id_ = new ::std::string;
-  }
-  span_id_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.TraceInfo.span_id)
-}
-inline void TraceInfo::set_span_id(const char* value, size_t size) {
-  set_has_span_id();
-  if (span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    span_id_ = new ::std::string;
-  }
-  span_id_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.TraceInfo.span_id)
-}
-inline ::std::string* TraceInfo::mutable_span_id() {
-  set_has_span_id();
-  if (span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    span_id_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.TraceInfo.span_id)
-  return span_id_;
-}
-inline ::std::string* TraceInfo::release_span_id() {
-  clear_has_span_id();
-  if (span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = span_id_;
-    span_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void TraceInfo::set_allocated_span_id(::std::string* span_id) {
-  if (span_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete span_id_;
-  }
-  if (span_id) {
-    set_has_span_id();
-    span_id_ = span_id;
-  } else {
-    clear_has_span_id();
-    span_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.TraceInfo.span_id)
-}
-
-// optional string parent_span_id = 4;
-inline bool TraceInfo::has_parent_span_id() const {
-  return (_has_bits_[0] & 0x00000008u) != 0;
-}
-inline void TraceInfo::set_has_parent_span_id() {
-  _has_bits_[0] |= 0x00000008u;
-}
-inline void TraceInfo::clear_has_parent_span_id() {
-  _has_bits_[0] &= ~0x00000008u;
-}
-inline void TraceInfo::clear_parent_span_id() {
-  if (parent_span_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    parent_span_id_->clear();
-  }
-  clear_has_parent_span_id();
-}
-inline const ::std::string& TraceInfo::parent_span_id() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.TraceInfo.parent_span_id)
-  return *parent_span_id_;
-}
-inline void TraceInfo::set_parent_span_id(const ::std::string& value) {
-  set_has_parent_span_id();
-  if (parent_span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    parent_span_id_ = new ::std::string;
-  }
-  parent_span_id_->assign(value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.TraceInfo.parent_span_id)
-}
-inline void TraceInfo::set_parent_span_id(const char* value) {
-  set_has_parent_span_id();
-  if (parent_span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    parent_span_id_ = new ::std::string;
-  }
-  parent_span_id_->assign(value);
-  // @@protoc_insertion_point(field_set_char:bgs.protocol.TraceInfo.parent_span_id)
-}
-inline void TraceInfo::set_parent_span_id(const char* value, size_t size) {
-  set_has_parent_span_id();
-  if (parent_span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    parent_span_id_ = new ::std::string;
-  }
-  parent_span_id_->assign(reinterpret_cast<const char*>(value), size);
-  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.TraceInfo.parent_span_id)
-}
-inline ::std::string* TraceInfo::mutable_parent_span_id() {
-  set_has_parent_span_id();
-  if (parent_span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    parent_span_id_ = new ::std::string;
-  }
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.TraceInfo.parent_span_id)
-  return parent_span_id_;
-}
-inline ::std::string* TraceInfo::release_parent_span_id() {
-  clear_has_parent_span_id();
-  if (parent_span_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    return NULL;
-  } else {
-    ::std::string* temp = parent_span_id_;
-    parent_span_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-    return temp;
-  }
-}
-inline void TraceInfo::set_allocated_parent_span_id(::std::string* parent_span_id) {
-  if (parent_span_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
-    delete parent_span_id_;
-  }
-  if (parent_span_id) {
-    set_has_parent_span_id();
-    parent_span_id_ = parent_span_id;
-  } else {
-    clear_has_parent_span_id();
-    parent_span_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
-  }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.TraceInfo.parent_span_id)
-}
-
-// optional .bgs.protocol.TraceInfo.Sampling sampling = 5 [default = DEFER];
-inline bool TraceInfo::has_sampling() const {
-  return (_has_bits_[0] & 0x00000010u) != 0;
-}
-inline void TraceInfo::set_has_sampling() {
-  _has_bits_[0] |= 0x00000010u;
-}
-inline void TraceInfo::clear_has_sampling() {
-  _has_bits_[0] &= ~0x00000010u;
-}
-inline void TraceInfo::clear_sampling() {
-  sampling_ = 2;
-  clear_has_sampling();
-}
-inline ::bgs::protocol::TraceInfo_Sampling TraceInfo::sampling() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.TraceInfo.sampling)
-  return static_cast< ::bgs::protocol::TraceInfo_Sampling >(sampling_);
-}
-inline void TraceInfo::set_sampling(::bgs::protocol::TraceInfo_Sampling value) {
-  assert(::bgs::protocol::TraceInfo_Sampling_IsValid(value));
-  set_has_sampling();
-  sampling_ = value;
-  // @@protoc_insertion_point(field_set:bgs.protocol.TraceInfo.sampling)
-}
-
-// -------------------------------------------------------------------
-
 // Header
 
 // required uint32 service_id = 1;
@@ -1921,45 +1588,445 @@ inline void Header::set_service_hash(::google::protobuf::uint32 value) {
   // @@protoc_insertion_point(field_set:bgs.protocol.Header.service_hash)
 }
 
-// optional .bgs.protocol.TraceInfo trace_info = 12;
-inline bool Header::has_trace_info() const {
+// optional string client_id = 13;
+inline bool Header::has_client_id() const {
   return (_has_bits_[0] & 0x00000800u) != 0;
 }
-inline void Header::set_has_trace_info() {
+inline void Header::set_has_client_id() {
   _has_bits_[0] |= 0x00000800u;
 }
-inline void Header::clear_has_trace_info() {
+inline void Header::clear_has_client_id() {
   _has_bits_[0] &= ~0x00000800u;
 }
-inline void Header::clear_trace_info() {
-  if (trace_info_ != NULL) trace_info_->::bgs::protocol::TraceInfo::Clear();
-  clear_has_trace_info();
+inline void Header::clear_client_id() {
+  if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_->clear();
+  }
+  clear_has_client_id();
 }
-inline const ::bgs::protocol::TraceInfo& Header::trace_info() const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.Header.trace_info)
-  return trace_info_ != NULL ? *trace_info_ : *default_instance_->trace_info_;
+inline const ::std::string& Header::client_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.client_id)
+  return *client_id_;
 }
-inline ::bgs::protocol::TraceInfo* Header::mutable_trace_info() {
-  set_has_trace_info();
-  if (trace_info_ == NULL) trace_info_ = new ::bgs::protocol::TraceInfo;
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.Header.trace_info)
-  return trace_info_;
+inline void Header::set_client_id(const ::std::string& value) {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  client_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.client_id)
 }
-inline ::bgs::protocol::TraceInfo* Header::release_trace_info() {
-  clear_has_trace_info();
-  ::bgs::protocol::TraceInfo* temp = trace_info_;
-  trace_info_ = NULL;
+inline void Header::set_client_id(const char* value) {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  client_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Header.client_id)
+}
+inline void Header::set_client_id(const char* value, size_t size) {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  client_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Header.client_id)
+}
+inline ::std::string* Header::mutable_client_id() {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Header.client_id)
+  return client_id_;
+}
+inline ::std::string* Header::release_client_id() {
+  clear_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = client_id_;
+    client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Header::set_allocated_client_id(::std::string* client_id) {
+  if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_id_;
+  }
+  if (client_id) {
+    set_has_client_id();
+    client_id_ = client_id;
+  } else {
+    clear_has_client_id();
+    client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Header.client_id)
+}
+
+// -------------------------------------------------------------------
+
+// KafkaHeader
+
+// optional fixed32 service_hash = 1;
+inline bool KafkaHeader::has_service_hash() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void KafkaHeader::set_has_service_hash() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void KafkaHeader::clear_has_service_hash() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void KafkaHeader::clear_service_hash() {
+  service_hash_ = 0u;
+  clear_has_service_hash();
+}
+inline ::google::protobuf::uint32 KafkaHeader::service_hash() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.service_hash)
+  return service_hash_;
+}
+inline void KafkaHeader::set_service_hash(::google::protobuf::uint32 value) {
+  set_has_service_hash();
+  service_hash_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.KafkaHeader.service_hash)
+}
+
+// optional uint32 method_id = 2;
+inline bool KafkaHeader::has_method_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void KafkaHeader::set_has_method_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void KafkaHeader::clear_has_method_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void KafkaHeader::clear_method_id() {
+  method_id_ = 0u;
+  clear_has_method_id();
+}
+inline ::google::protobuf::uint32 KafkaHeader::method_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.method_id)
+  return method_id_;
+}
+inline void KafkaHeader::set_method_id(::google::protobuf::uint32 value) {
+  set_has_method_id();
+  method_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.KafkaHeader.method_id)
+}
+
+// optional uint32 token = 3;
+inline bool KafkaHeader::has_token() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void KafkaHeader::set_has_token() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void KafkaHeader::clear_has_token() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void KafkaHeader::clear_token() {
+  token_ = 0u;
+  clear_has_token();
+}
+inline ::google::protobuf::uint32 KafkaHeader::token() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.token)
+  return token_;
+}
+inline void KafkaHeader::set_token(::google::protobuf::uint32 value) {
+  set_has_token();
+  token_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.KafkaHeader.token)
+}
+
+// optional uint64 object_id = 4 [default = 0];
+inline bool KafkaHeader::has_object_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void KafkaHeader::set_has_object_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void KafkaHeader::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void KafkaHeader::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 KafkaHeader::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.object_id)
+  return object_id_;
+}
+inline void KafkaHeader::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.KafkaHeader.object_id)
+}
+
+// optional uint32 size = 5 [default = 0];
+inline bool KafkaHeader::has_size() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void KafkaHeader::set_has_size() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void KafkaHeader::clear_has_size() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void KafkaHeader::clear_size() {
+  size_ = 0u;
+  clear_has_size();
+}
+inline ::google::protobuf::uint32 KafkaHeader::size() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.size)
+  return size_;
+}
+inline void KafkaHeader::set_size(::google::protobuf::uint32 value) {
+  set_has_size();
+  size_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.KafkaHeader.size)
+}
+
+// optional uint32 status = 6 [default = 0];
+inline bool KafkaHeader::has_status() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void KafkaHeader::set_has_status() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void KafkaHeader::clear_has_status() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void KafkaHeader::clear_status() {
+  status_ = 0u;
+  clear_has_status();
+}
+inline ::google::protobuf::uint32 KafkaHeader::status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.status)
+  return status_;
+}
+inline void KafkaHeader::set_status(::google::protobuf::uint32 value) {
+  set_has_status();
+  status_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.KafkaHeader.status)
+}
+
+// optional uint64 timeout = 7;
+inline bool KafkaHeader::has_timeout() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void KafkaHeader::set_has_timeout() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void KafkaHeader::clear_has_timeout() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void KafkaHeader::clear_timeout() {
+  timeout_ = GOOGLE_ULONGLONG(0);
+  clear_has_timeout();
+}
+inline ::google::protobuf::uint64 KafkaHeader::timeout() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.timeout)
+  return timeout_;
+}
+inline void KafkaHeader::set_timeout(::google::protobuf::uint64 value) {
+  set_has_timeout();
+  timeout_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.KafkaHeader.timeout)
+}
+
+// optional .bgs.protocol.ProcessId forward_target = 8;
+inline bool KafkaHeader::has_forward_target() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void KafkaHeader::set_has_forward_target() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void KafkaHeader::clear_has_forward_target() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void KafkaHeader::clear_forward_target() {
+  if (forward_target_ != NULL) forward_target_->::bgs::protocol::ProcessId::Clear();
+  clear_has_forward_target();
+}
+inline const ::bgs::protocol::ProcessId& KafkaHeader::forward_target() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.forward_target)
+  return forward_target_ != NULL ? *forward_target_ : *default_instance_->forward_target_;
+}
+inline ::bgs::protocol::ProcessId* KafkaHeader::mutable_forward_target() {
+  set_has_forward_target();
+  if (forward_target_ == NULL) forward_target_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.KafkaHeader.forward_target)
+  return forward_target_;
+}
+inline ::bgs::protocol::ProcessId* KafkaHeader::release_forward_target() {
+  clear_has_forward_target();
+  ::bgs::protocol::ProcessId* temp = forward_target_;
+  forward_target_ = NULL;
   return temp;
 }
-inline void Header::set_allocated_trace_info(::bgs::protocol::TraceInfo* trace_info) {
-  delete trace_info_;
-  trace_info_ = trace_info;
-  if (trace_info) {
-    set_has_trace_info();
+inline void KafkaHeader::set_allocated_forward_target(::bgs::protocol::ProcessId* forward_target) {
+  delete forward_target_;
+  forward_target_ = forward_target;
+  if (forward_target) {
+    set_has_forward_target();
+  } else {
+    clear_has_forward_target();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.KafkaHeader.forward_target)
+}
+
+// optional string return_topic = 9;
+inline bool KafkaHeader::has_return_topic() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void KafkaHeader::set_has_return_topic() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void KafkaHeader::clear_has_return_topic() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void KafkaHeader::clear_return_topic() {
+  if (return_topic_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return_topic_->clear();
+  }
+  clear_has_return_topic();
+}
+inline const ::std::string& KafkaHeader::return_topic() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.return_topic)
+  return *return_topic_;
+}
+inline void KafkaHeader::set_return_topic(const ::std::string& value) {
+  set_has_return_topic();
+  if (return_topic_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return_topic_ = new ::std::string;
+  }
+  return_topic_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.KafkaHeader.return_topic)
+}
+inline void KafkaHeader::set_return_topic(const char* value) {
+  set_has_return_topic();
+  if (return_topic_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return_topic_ = new ::std::string;
+  }
+  return_topic_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.KafkaHeader.return_topic)
+}
+inline void KafkaHeader::set_return_topic(const char* value, size_t size) {
+  set_has_return_topic();
+  if (return_topic_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return_topic_ = new ::std::string;
+  }
+  return_topic_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.KafkaHeader.return_topic)
+}
+inline ::std::string* KafkaHeader::mutable_return_topic() {
+  set_has_return_topic();
+  if (return_topic_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return_topic_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.KafkaHeader.return_topic)
+  return return_topic_;
+}
+inline ::std::string* KafkaHeader::release_return_topic() {
+  clear_has_return_topic();
+  if (return_topic_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = return_topic_;
+    return_topic_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void KafkaHeader::set_allocated_return_topic(::std::string* return_topic) {
+  if (return_topic_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete return_topic_;
+  }
+  if (return_topic) {
+    set_has_return_topic();
+    return_topic_ = return_topic;
   } else {
-    clear_has_trace_info();
+    clear_has_return_topic();
+    return_topic_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
-  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Header.trace_info)
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.KafkaHeader.return_topic)
+}
+
+// optional string client_id = 11;
+inline bool KafkaHeader::has_client_id() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void KafkaHeader::set_has_client_id() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void KafkaHeader::clear_has_client_id() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void KafkaHeader::clear_client_id() {
+  if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_->clear();
+  }
+  clear_has_client_id();
+}
+inline const ::std::string& KafkaHeader::client_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.KafkaHeader.client_id)
+  return *client_id_;
+}
+inline void KafkaHeader::set_client_id(const ::std::string& value) {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  client_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.KafkaHeader.client_id)
+}
+inline void KafkaHeader::set_client_id(const char* value) {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  client_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.KafkaHeader.client_id)
+}
+inline void KafkaHeader::set_client_id(const char* value, size_t size) {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  client_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.KafkaHeader.client_id)
+}
+inline ::std::string* KafkaHeader::mutable_client_id() {
+  set_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.KafkaHeader.client_id)
+  return client_id_;
+}
+inline ::std::string* KafkaHeader::release_client_id() {
+  clear_has_client_id();
+  if (client_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = client_id_;
+    client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void KafkaHeader::set_allocated_client_id(::std::string* client_id) {
+  if (client_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_id_;
+  }
+  if (client_id) {
+    set_has_client_id();
+    client_id_ = client_id;
+  } else {
+    clear_has_client_id();
+    client_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.KafkaHeader.client_id)
 }
 
 
@@ -1972,11 +2039,6 @@ inline void Header::set_allocated_trace_info(::bgs::protocol::TraceInfo* trace_i
 namespace google {
 namespace protobuf {
 
-template <> struct is_proto_enum< ::bgs::protocol::TraceInfo_Sampling> : ::google::protobuf::internal::true_type {};
-template <>
-inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::TraceInfo_Sampling>() {
-  return ::bgs::protocol::TraceInfo_Sampling_descriptor();
-}
 
 }  // namespace google
 }  // namespace protobuf
diff --git a/src/server/proto/Client/user_manager_service.pb.cc b/src/server/proto/Client/user_manager_service.pb.cc
index 53d41c42c96..1d4ac226a15 100644
--- a/src/server/proto/Client/user_manager_service.pb.cc
+++ b/src/server/proto/Client/user_manager_service.pb.cc
@@ -39,15 +39,9 @@ const ::google::protobuf::internal::GeneratedMessageReflection*
 const ::google::protobuf::Descriptor* AddRecentPlayersRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   AddRecentPlayersRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* AddRecentPlayersResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  AddRecentPlayersResponse_reflection_ = NULL;
 const ::google::protobuf::Descriptor* ClearRecentPlayersRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   ClearRecentPlayersRequest_reflection_ = NULL;
-const ::google::protobuf::Descriptor* ClearRecentPlayersResponse_descriptor_ = NULL;
-const ::google::protobuf::internal::GeneratedMessageReflection*
-  ClearRecentPlayersResponse_reflection_ = NULL;
 const ::google::protobuf::Descriptor* BlockPlayerRequest_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   BlockPlayerRequest_reflection_ = NULL;
@@ -144,23 +138,7 @@ void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(AddRecentPlayersRequest));
-  AddRecentPlayersResponse_descriptor_ = file->message_type(4);
-  static const int AddRecentPlayersResponse_offsets_[2] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, players_added_),
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, players_removed_),
-  };
-  AddRecentPlayersResponse_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      AddRecentPlayersResponse_descriptor_,
-      AddRecentPlayersResponse::default_instance_,
-      AddRecentPlayersResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(AddRecentPlayersResponse));
-  ClearRecentPlayersRequest_descriptor_ = file->message_type(5);
+  ClearRecentPlayersRequest_descriptor_ = file->message_type(4);
   static const int ClearRecentPlayersRequest_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, agent_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, program_),
@@ -176,22 +154,7 @@ void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(ClearRecentPlayersRequest));
-  ClearRecentPlayersResponse_descriptor_ = file->message_type(6);
-  static const int ClearRecentPlayersResponse_offsets_[1] = {
-    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersResponse, players_removed_),
-  };
-  ClearRecentPlayersResponse_reflection_ =
-    new ::google::protobuf::internal::GeneratedMessageReflection(
-      ClearRecentPlayersResponse_descriptor_,
-      ClearRecentPlayersResponse::default_instance_,
-      ClearRecentPlayersResponse_offsets_,
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersResponse, _has_bits_[0]),
-      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersResponse, _unknown_fields_),
-      -1,
-      ::google::protobuf::DescriptorPool::generated_pool(),
-      ::google::protobuf::MessageFactory::generated_factory(),
-      sizeof(ClearRecentPlayersResponse));
-  BlockPlayerRequest_descriptor_ = file->message_type(7);
+  BlockPlayerRequest_descriptor_ = file->message_type(5);
   static const int BlockPlayerRequest_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, agent_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, target_id_),
@@ -208,7 +171,7 @@ void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(BlockPlayerRequest));
-  UnblockPlayerRequest_descriptor_ = file->message_type(8);
+  UnblockPlayerRequest_descriptor_ = file->message_type(6);
   static const int UnblockPlayerRequest_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, agent_id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, target_id_),
@@ -224,7 +187,7 @@ void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(UnblockPlayerRequest));
-  BlockedPlayerAddedNotification_descriptor_ = file->message_type(9);
+  BlockedPlayerAddedNotification_descriptor_ = file->message_type(7);
   static const int BlockedPlayerAddedNotification_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, player_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, game_account_id_),
@@ -241,7 +204,7 @@ void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(BlockedPlayerAddedNotification));
-  BlockedPlayerRemovedNotification_descriptor_ = file->message_type(10);
+  BlockedPlayerRemovedNotification_descriptor_ = file->message_type(8);
   static const int BlockedPlayerRemovedNotification_offsets_[3] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, player_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, game_account_id_),
@@ -258,7 +221,7 @@ void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(BlockedPlayerRemovedNotification));
-  RecentPlayersAddedNotification_descriptor_ = file->message_type(11);
+  RecentPlayersAddedNotification_descriptor_ = file->message_type(9);
   static const int RecentPlayersAddedNotification_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersAddedNotification, player_),
   };
@@ -273,7 +236,7 @@ void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto() {
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(RecentPlayersAddedNotification));
-  RecentPlayersRemovedNotification_descriptor_ = file->message_type(12);
+  RecentPlayersRemovedNotification_descriptor_ = file->message_type(10);
   static const int RecentPlayersRemovedNotification_offsets_[1] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersRemovedNotification, player_),
   };
@@ -311,12 +274,8 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     AddRecentPlayersRequest_descriptor_, &AddRecentPlayersRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    AddRecentPlayersResponse_descriptor_, &AddRecentPlayersResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     ClearRecentPlayersRequest_descriptor_, &ClearRecentPlayersRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
-    ClearRecentPlayersResponse_descriptor_, &ClearRecentPlayersResponse::default_instance());
-  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     BlockPlayerRequest_descriptor_, &BlockPlayerRequest::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     UnblockPlayerRequest_descriptor_, &UnblockPlayerRequest::default_instance());
@@ -341,12 +300,8 @@ void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto() {
   delete UnsubscribeRequest_reflection_;
   delete AddRecentPlayersRequest::default_instance_;
   delete AddRecentPlayersRequest_reflection_;
-  delete AddRecentPlayersResponse::default_instance_;
-  delete AddRecentPlayersResponse_reflection_;
   delete ClearRecentPlayersRequest::default_instance_;
   delete ClearRecentPlayersRequest_reflection_;
-  delete ClearRecentPlayersResponse::default_instance_;
-  delete ClearRecentPlayersResponse_reflection_;
   delete BlockPlayerRequest::default_instance_;
   delete BlockPlayerRequest_reflection_;
   delete UnblockPlayerRequest::default_instance_;
@@ -388,79 +343,71 @@ void protobuf_AddDesc_user_5fmanager_5fservice_2eproto() {
     "quest\022;\n\007players\030\001 \003(\0132*.bgs.protocol.us"
     "er_manager.v1.RecentPlayer\022(\n\010agent_id\030\002"
     " \001(\0132\026.bgs.protocol.EntityId\022\017\n\007program\030"
-    "\003 \001(\r\"v\n\030AddRecentPlayersResponse\022A\n\rpla"
-    "yers_added\030\001 \003(\0132*.bgs.protocol.user_man"
-    "ager.v1.RecentPlayer\022\027\n\017players_removed\030"
-    "\003 \003(\007\"V\n\031ClearRecentPlayersRequest\022(\n\010ag"
+    "\003 \001(\r\"V\n\031ClearRecentPlayersRequest\022(\n\010ag"
     "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\017\n\007"
-    "program\030\002 \001(\r\"5\n\032ClearRecentPlayersRespo"
-    "nse\022\027\n\017players_removed\030\001 \003(\007\"w\n\022BlockPla"
-    "yerRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.proto"
-    "col.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.pr"
-    "otocol.EntityId\022\014\n\004role\030\003 \001(\r\"k\n\024Unblock"
-    "PlayerRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.pr"
-    "otocol.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs"
-    ".protocol.EntityId\"\272\001\n\036BlockedPlayerAdde"
-    "dNotification\022;\n\006player\030\001 \002(\0132+.bgs.prot"
-    "ocol.user_manager.v1.BlockedPlayer\022/\n\017ga"
-    "me_account_id\030\002 \001(\0132\026.bgs.protocol.Entit"
-    "yId\022*\n\naccount_id\030\003 \001(\0132\026.bgs.protocol.E"
-    "ntityId\"\274\001\n BlockedPlayerRemovedNotifica"
-    "tion\022;\n\006player\030\001 \002(\0132+.bgs.protocol.user"
-    "_manager.v1.BlockedPlayer\022/\n\017game_accoun"
-    "t_id\030\002 \001(\0132\026.bgs.protocol.EntityId\022*\n\nac"
-    "count_id\030\003 \001(\0132\026.bgs.protocol.EntityId\"\\"
-    "\n\036RecentPlayersAddedNotification\022:\n\006play"
-    "er\030\001 \003(\0132*.bgs.protocol.user_manager.v1."
-    "RecentPlayer\"^\n RecentPlayersRemovedNoti"
-    "fication\022:\n\006player\030\001 \003(\0132*.bgs.protocol."
-    "user_manager.v1.RecentPlayer2\233\007\n\022UserMan"
-    "agerService\022r\n\tSubscribe\022..bgs.protocol."
-    "user_manager.v1.SubscribeRequest\032/.bgs.p"
-    "rotocol.user_manager.v1.SubscribeRespons"
-    "e\"\004\200\265\030\001\022\207\001\n\020AddRecentPlayers\0225.bgs.proto"
-    "col.user_manager.v1.AddRecentPlayersRequ"
-    "est\0326.bgs.protocol.user_manager.v1.AddRe"
-    "centPlayersResponse\"\004\200\265\030\n\022\215\001\n\022ClearRecen"
-    "tPlayers\0227.bgs.protocol.user_manager.v1."
-    "ClearRecentPlayersRequest\0328.bgs.protocol"
-    ".user_manager.v1.ClearRecentPlayersRespo"
-    "nse\"\004\200\265\030\013\022[\n\013BlockPlayer\0220.bgs.protocol."
-    "user_manager.v1.BlockPlayerRequest\032\024.bgs"
-    ".protocol.NoData\"\004\200\265\030\024\022_\n\rUnblockPlayer\022"
-    "2.bgs.protocol.user_manager.v1.UnblockPl"
-    "ayerRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\025\022"
-    "e\n\025BlockPlayerForSession\0220.bgs.protocol."
-    "user_manager.v1.BlockPlayerRequest\032\024.bgs"
-    ".protocol.NoData\"\004\200\265\030(\022C\n\rLoadBlockList\022"
-    "\026.bgs.protocol.EntityId\032\024.bgs.protocol.N"
-    "oData\"\004\200\265\0302\022[\n\013Unsubscribe\0220.bgs.protoco"
-    "l.user_manager.v1.UnsubscribeRequest\032\024.b"
-    "gs.protocol.NoData\"\004\200\265\0303\0320\312>-bnet.protoc"
-    "ol.user_manager.UserManagerService2\252\004\n\023U"
-    "serManagerListener\022u\n\024OnBlockedPlayerAdd"
-    "ed\022<.bgs.protocol.user_manager.v1.Blocke"
-    "dPlayerAddedNotification\032\031.bgs.protocol."
-    "NO_RESPONSE\"\004\200\265\030\001\022y\n\026OnBlockedPlayerRemo"
-    "ved\022>.bgs.protocol.user_manager.v1.Block"
-    "edPlayerRemovedNotification\032\031.bgs.protoc"
-    "ol.NO_RESPONSE\"\004\200\265\030\002\022u\n\024OnRecentPlayersA"
-    "dded\022<.bgs.protocol.user_manager.v1.Rece"
-    "ntPlayersAddedNotification\032\031.bgs.protoco"
-    "l.NO_RESPONSE\"\004\200\265\030\013\022y\n\026OnRecentPlayersRe"
-    "moved\022>.bgs.protocol.user_manager.v1.Rec"
-    "entPlayersRemovedNotification\032\031.bgs.prot"
-    "ocol.NO_RESPONSE\"\004\200\265\030\014\032/\312>,bnet.protocol"
-    ".user_manager.UserManagerNotifyB\005H\001\200\001\000", 3198);
+    "program\030\002 \001(\r\"w\n\022BlockPlayerRequest\022(\n\010a"
+    "gent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n"
+    "\ttarget_id\030\002 \002(\0132\026.bgs.protocol.EntityId"
+    "\022\014\n\004role\030\003 \001(\r\"k\n\024UnblockPlayerRequest\022("
+    "\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.EntityId"
+    "\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.protocol.Entit"
+    "yId\"\272\001\n\036BlockedPlayerAddedNotification\022;"
+    "\n\006player\030\001 \002(\0132+.bgs.protocol.user_manag"
+    "er.v1.BlockedPlayer\022/\n\017game_account_id\030\002"
+    " \001(\0132\026.bgs.protocol.EntityId\022*\n\naccount_"
+    "id\030\003 \001(\0132\026.bgs.protocol.EntityId\"\274\001\n Blo"
+    "ckedPlayerRemovedNotification\022;\n\006player\030"
+    "\001 \002(\0132+.bgs.protocol.user_manager.v1.Blo"
+    "ckedPlayer\022/\n\017game_account_id\030\002 \001(\0132\026.bg"
+    "s.protocol.EntityId\022*\n\naccount_id\030\003 \001(\0132"
+    "\026.bgs.protocol.EntityId\"\\\n\036RecentPlayers"
+    "AddedNotification\022:\n\006player\030\001 \003(\0132*.bgs."
+    "protocol.user_manager.v1.RecentPlayer\"^\n"
+    " RecentPlayersRemovedNotification\022:\n\006pla"
+    "yer\030\001 \003(\0132*.bgs.protocol.user_manager.v1"
+    ".RecentPlayer2\263\006\n\022UserManagerService\022t\n\t"
+    "Subscribe\022..bgs.protocol.user_manager.v1"
+    ".SubscribeRequest\032/.bgs.protocol.user_ma"
+    "nager.v1.SubscribeResponse\"\006\202\371+\002\010\001\022g\n\020Ad"
+    "dRecentPlayers\0225.bgs.protocol.user_manag"
+    "er.v1.AddRecentPlayersRequest\032\024.bgs.prot"
+    "ocol.NoData\"\006\202\371+\002\010\n\022k\n\022ClearRecentPlayer"
+    "s\0227.bgs.protocol.user_manager.v1.ClearRe"
+    "centPlayersRequest\032\024.bgs.protocol.NoData"
+    "\"\006\202\371+\002\010\013\022]\n\013BlockPlayer\0220.bgs.protocol.u"
+    "ser_manager.v1.BlockPlayerRequest\032\024.bgs."
+    "protocol.NoData\"\006\202\371+\002\010\024\022a\n\rUnblockPlayer"
+    "\0222.bgs.protocol.user_manager.v1.UnblockP"
+    "layerRequest\032\024.bgs.protocol.NoData\"\006\202\371+\002"
+    "\010\025\022g\n\025BlockPlayerForSession\0220.bgs.protoc"
+    "ol.user_manager.v1.BlockPlayerRequest\032\024."
+    "bgs.protocol.NoData\"\006\202\371+\002\010(\022]\n\013Unsubscri"
+    "be\0220.bgs.protocol.user_manager.v1.Unsubs"
+    "cribeRequest\032\024.bgs.protocol.NoData\"\006\202\371+\002"
+    "\0103\032G\202\371+=\n-bnet.protocol.user_manager.Use"
+    "rManagerService*\014user_manager\212\371+\002\020\0012\273\004\n\023"
+    "UserManagerListener\022w\n\024OnBlockedPlayerAd"
+    "ded\022<.bgs.protocol.user_manager.v1.Block"
+    "edPlayerAddedNotification\032\031.bgs.protocol"
+    ".NO_RESPONSE\"\006\202\371+\002\010\001\022{\n\026OnBlockedPlayerR"
+    "emoved\022>.bgs.protocol.user_manager.v1.Bl"
+    "ockedPlayerRemovedNotification\032\031.bgs.pro"
+    "tocol.NO_RESPONSE\"\006\202\371+\002\010\002\022w\n\024OnRecentPla"
+    "yersAdded\022<.bgs.protocol.user_manager.v1"
+    ".RecentPlayersAddedNotification\032\031.bgs.pr"
+    "otocol.NO_RESPONSE\"\006\202\371+\002\010\013\022{\n\026OnRecentPl"
+    "ayersRemoved\022>.bgs.protocol.user_manager"
+    ".v1.RecentPlayersRemovedNotification\032\031.b"
+    "gs.protocol.NO_RESPONSE\"\006\202\371+\002\010\014\0328\202\371+.\n,b"
+    "net.protocol.user_manager.UserManagerNot"
+    "ify\212\371+\002\010\001B\005H\001\200\001\000", 2936);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "user_manager_service.proto", &protobuf_RegisterTypes);
   SubscribeRequest::default_instance_ = new SubscribeRequest();
   SubscribeResponse::default_instance_ = new SubscribeResponse();
   UnsubscribeRequest::default_instance_ = new UnsubscribeRequest();
   AddRecentPlayersRequest::default_instance_ = new AddRecentPlayersRequest();
-  AddRecentPlayersResponse::default_instance_ = new AddRecentPlayersResponse();
   ClearRecentPlayersRequest::default_instance_ = new ClearRecentPlayersRequest();
-  ClearRecentPlayersResponse::default_instance_ = new ClearRecentPlayersResponse();
   BlockPlayerRequest::default_instance_ = new BlockPlayerRequest();
   UnblockPlayerRequest::default_instance_ = new UnblockPlayerRequest();
   BlockedPlayerAddedNotification::default_instance_ = new BlockedPlayerAddedNotification();
@@ -471,9 +418,7 @@ void protobuf_AddDesc_user_5fmanager_5fservice_2eproto() {
   SubscribeResponse::default_instance_->InitAsDefaultInstance();
   UnsubscribeRequest::default_instance_->InitAsDefaultInstance();
   AddRecentPlayersRequest::default_instance_->InitAsDefaultInstance();
-  AddRecentPlayersResponse::default_instance_->InitAsDefaultInstance();
   ClearRecentPlayersRequest::default_instance_->InitAsDefaultInstance();
-  ClearRecentPlayersResponse::default_instance_->InitAsDefaultInstance();
   BlockPlayerRequest::default_instance_->InitAsDefaultInstance();
   UnblockPlayerRequest::default_instance_->InitAsDefaultInstance();
   BlockedPlayerAddedNotification::default_instance_->InitAsDefaultInstance();
@@ -1648,268 +1593,6 @@ void AddRecentPlayersRequest::Swap(AddRecentPlayersRequest* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int AddRecentPlayersResponse::kPlayersAddedFieldNumber;
-const int AddRecentPlayersResponse::kPlayersRemovedFieldNumber;
-#endif  // !_MSC_VER
-
-AddRecentPlayersResponse::AddRecentPlayersResponse()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-}
-
-void AddRecentPlayersResponse::InitAsDefaultInstance() {
-}
-
-AddRecentPlayersResponse::AddRecentPlayersResponse(const AddRecentPlayersResponse& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-}
-
-void AddRecentPlayersResponse::SharedCtor() {
-  _cached_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-AddRecentPlayersResponse::~AddRecentPlayersResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-  SharedDtor();
-}
-
-void AddRecentPlayersResponse::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void AddRecentPlayersResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* AddRecentPlayersResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return AddRecentPlayersResponse_descriptor_;
-}
-
-const AddRecentPlayersResponse& AddRecentPlayersResponse::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
-  return *default_instance_;
-}
-
-AddRecentPlayersResponse* AddRecentPlayersResponse::default_instance_ = NULL;
-
-AddRecentPlayersResponse* AddRecentPlayersResponse::New() const {
-  return new AddRecentPlayersResponse;
-}
-
-void AddRecentPlayersResponse::Clear() {
-  players_added_.Clear();
-  players_removed_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool AddRecentPlayersResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
-      case 1: {
-        if (tag == 10) {
-         parse_players_added:
-          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
-                input, add_players_added()));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(10)) goto parse_players_added;
-        if (input->ExpectTag(29)) goto parse_players_removed;
-        break;
-      }
-
-      // repeated fixed32 players_removed = 3;
-      case 3: {
-        if (tag == 29) {
-         parse_players_removed:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 1, 29, input, this->mutable_players_removed())));
-        } else if (tag == 26) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, this->mutable_players_removed())));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(29)) goto parse_players_removed;
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-  return false;
-#undef DO_
-}
-
-void AddRecentPlayersResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
-  for (int i = 0; i < this->players_added_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
-      1, this->players_added(i), output);
-  }
-
-  // repeated fixed32 players_removed = 3;
-  for (int i = 0; i < this->players_removed_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(
-      3, this->players_removed(i), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-}
-
-::google::protobuf::uint8* AddRecentPlayersResponse::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
-  for (int i = 0; i < this->players_added_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteMessageNoVirtualToArray(
-        1, this->players_added(i), target);
-  }
-
-  // repeated fixed32 players_removed = 3;
-  for (int i = 0; i < this->players_removed_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteFixed32ToArray(3, this->players_removed(i), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
-  return target;
-}
-
-int AddRecentPlayersResponse::ByteSize() const {
-  int total_size = 0;
-
-  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
-  total_size += 1 * this->players_added_size();
-  for (int i = 0; i < this->players_added_size(); i++) {
-    total_size +=
-      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
-        this->players_added(i));
-  }
-
-  // repeated fixed32 players_removed = 3;
-  {
-    int data_size = 0;
-    data_size = 4 * this->players_removed_size();
-    total_size += 1 * this->players_removed_size() + data_size;
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void AddRecentPlayersResponse::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const AddRecentPlayersResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const AddRecentPlayersResponse*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void AddRecentPlayersResponse::MergeFrom(const AddRecentPlayersResponse& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  players_added_.MergeFrom(from.players_added_);
-  players_removed_.MergeFrom(from.players_removed_);
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void AddRecentPlayersResponse::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void AddRecentPlayersResponse::CopyFrom(const AddRecentPlayersResponse& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool AddRecentPlayersResponse::IsInitialized() const {
-
-  if (!::google::protobuf::internal::AllAreInitialized(this->players_added())) return false;
-  return true;
-}
-
-void AddRecentPlayersResponse::Swap(AddRecentPlayersResponse* other) {
-  if (other != this) {
-    players_added_.Swap(&other->players_added_);
-    players_removed_.Swap(&other->players_removed_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata AddRecentPlayersResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = AddRecentPlayersResponse_descriptor_;
-  metadata.reflection = AddRecentPlayersResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int ClearRecentPlayersRequest::kAgentIdFieldNumber;
 const int ClearRecentPlayersRequest::kProgramFieldNumber;
 #endif  // !_MSC_VER
@@ -2181,228 +1864,6 @@ void ClearRecentPlayersRequest::Swap(ClearRecentPlayersRequest* other) {
 // ===================================================================
 
 #ifndef _MSC_VER
-const int ClearRecentPlayersResponse::kPlayersRemovedFieldNumber;
-#endif  // !_MSC_VER
-
-ClearRecentPlayersResponse::ClearRecentPlayersResponse()
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-}
-
-void ClearRecentPlayersResponse::InitAsDefaultInstance() {
-}
-
-ClearRecentPlayersResponse::ClearRecentPlayersResponse(const ClearRecentPlayersResponse& from)
-  : ::google::protobuf::Message() {
-  SharedCtor();
-  MergeFrom(from);
-  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-}
-
-void ClearRecentPlayersResponse::SharedCtor() {
-  _cached_size_ = 0;
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-}
-
-ClearRecentPlayersResponse::~ClearRecentPlayersResponse() {
-  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-  SharedDtor();
-}
-
-void ClearRecentPlayersResponse::SharedDtor() {
-  if (this != default_instance_) {
-  }
-}
-
-void ClearRecentPlayersResponse::SetCachedSize(int size) const {
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-}
-const ::google::protobuf::Descriptor* ClearRecentPlayersResponse::descriptor() {
-  protobuf_AssignDescriptorsOnce();
-  return ClearRecentPlayersResponse_descriptor_;
-}
-
-const ClearRecentPlayersResponse& ClearRecentPlayersResponse::default_instance() {
-  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
-  return *default_instance_;
-}
-
-ClearRecentPlayersResponse* ClearRecentPlayersResponse::default_instance_ = NULL;
-
-ClearRecentPlayersResponse* ClearRecentPlayersResponse::New() const {
-  return new ClearRecentPlayersResponse;
-}
-
-void ClearRecentPlayersResponse::Clear() {
-  players_removed_.Clear();
-  ::memset(_has_bits_, 0, sizeof(_has_bits_));
-  mutable_unknown_fields()->Clear();
-}
-
-bool ClearRecentPlayersResponse::MergePartialFromCodedStream(
-    ::google::protobuf::io::CodedInputStream* input) {
-#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
-  ::google::protobuf::uint32 tag;
-  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-  for (;;) {
-    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
-    tag = p.first;
-    if (!p.second) goto handle_unusual;
-    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
-      // repeated fixed32 players_removed = 1;
-      case 1: {
-        if (tag == 13) {
-         parse_players_removed:
-          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 1, 13, input, this->mutable_players_removed())));
-        } else if (tag == 10) {
-          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
-                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
-                 input, this->mutable_players_removed())));
-        } else {
-          goto handle_unusual;
-        }
-        if (input->ExpectTag(13)) goto parse_players_removed;
-        if (input->ExpectAtEnd()) goto success;
-        break;
-      }
-
-      default: {
-      handle_unusual:
-        if (tag == 0 ||
-            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
-            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
-          goto success;
-        }
-        DO_(::google::protobuf::internal::WireFormat::SkipField(
-              input, tag, mutable_unknown_fields()));
-        break;
-      }
-    }
-  }
-success:
-  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-  return true;
-failure:
-  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-  return false;
-#undef DO_
-}
-
-void ClearRecentPlayersResponse::SerializeWithCachedSizes(
-    ::google::protobuf::io::CodedOutputStream* output) const {
-  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-  // repeated fixed32 players_removed = 1;
-  for (int i = 0; i < this->players_removed_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteFixed32(
-      1, this->players_removed(i), output);
-  }
-
-  if (!unknown_fields().empty()) {
-    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
-        unknown_fields(), output);
-  }
-  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-}
-
-::google::protobuf::uint8* ClearRecentPlayersResponse::SerializeWithCachedSizesToArray(
-    ::google::protobuf::uint8* target) const {
-  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-  // repeated fixed32 players_removed = 1;
-  for (int i = 0; i < this->players_removed_size(); i++) {
-    target = ::google::protobuf::internal::WireFormatLite::
-      WriteFixed32ToArray(1, this->players_removed(i), target);
-  }
-
-  if (!unknown_fields().empty()) {
-    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
-        unknown_fields(), target);
-  }
-  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
-  return target;
-}
-
-int ClearRecentPlayersResponse::ByteSize() const {
-  int total_size = 0;
-
-  // repeated fixed32 players_removed = 1;
-  {
-    int data_size = 0;
-    data_size = 4 * this->players_removed_size();
-    total_size += 1 * this->players_removed_size() + data_size;
-  }
-
-  if (!unknown_fields().empty()) {
-    total_size +=
-      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
-        unknown_fields());
-  }
-  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
-  _cached_size_ = total_size;
-  GOOGLE_SAFE_CONCURRENT_WRITES_END();
-  return total_size;
-}
-
-void ClearRecentPlayersResponse::MergeFrom(const ::google::protobuf::Message& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  const ClearRecentPlayersResponse* source =
-    ::google::protobuf::internal::dynamic_cast_if_available<const ClearRecentPlayersResponse*>(
-      &from);
-  if (source == NULL) {
-    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
-  } else {
-    MergeFrom(*source);
-  }
-}
-
-void ClearRecentPlayersResponse::MergeFrom(const ClearRecentPlayersResponse& from) {
-  GOOGLE_CHECK_NE(&from, this);
-  players_removed_.MergeFrom(from.players_removed_);
-  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
-}
-
-void ClearRecentPlayersResponse::CopyFrom(const ::google::protobuf::Message& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-void ClearRecentPlayersResponse::CopyFrom(const ClearRecentPlayersResponse& from) {
-  if (&from == this) return;
-  Clear();
-  MergeFrom(from);
-}
-
-bool ClearRecentPlayersResponse::IsInitialized() const {
-
-  return true;
-}
-
-void ClearRecentPlayersResponse::Swap(ClearRecentPlayersResponse* other) {
-  if (other != this) {
-    players_removed_.Swap(&other->players_removed_);
-    std::swap(_has_bits_[0], other->_has_bits_[0]);
-    _unknown_fields_.Swap(&other->_unknown_fields_);
-    std::swap(_cached_size_, other->_cached_size_);
-  }
-}
-
-::google::protobuf::Metadata ClearRecentPlayersResponse::GetMetadata() const {
-  protobuf_AssignDescriptorsOnce();
-  ::google::protobuf::Metadata metadata;
-  metadata.descriptor = ClearRecentPlayersResponse_descriptor_;
-  metadata.reflection = ClearRecentPlayersResponse_reflection_;
-  return metadata;
-}
-
-
-// ===================================================================
-
-#ifndef _MSC_VER
 const int BlockPlayerRequest::kAgentIdFieldNumber;
 const int BlockPlayerRequest::kTargetIdFieldNumber;
 const int BlockPlayerRequest::kRoleFieldNumber;
@@ -4117,22 +3578,22 @@ void UserManagerService::Subscribe(::bgs::protocol::user_manager::v1::SubscribeR
   SendRequest(service_hash_, 1, request, std::move(callback));
 }
 
-void UserManagerService::AddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::AddRecentPlayersResponse const*)> responseCallback) {
+void UserManagerService::AddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
   TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.AddRecentPlayers(bgs.protocol.user_manager.v1.AddRecentPlayersRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse response;
+    ::bgs::protocol::NoData response;
     if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
       responseCallback(&response);
   };
   SendRequest(service_hash_, 10, request, std::move(callback));
 }
 
-void UserManagerService::ClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse const*)> responseCallback) {
+void UserManagerService::ClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
   TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.ClearRecentPlayers(bgs.protocol.user_manager.v1.ClearRecentPlayersRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse response;
+    ::bgs::protocol::NoData response;
     if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
       responseCallback(&response);
   };
@@ -4172,17 +3633,6 @@ void UserManagerService::BlockPlayerForSession(::bgs::protocol::user_manager::v1
   SendRequest(service_hash_, 40, request, std::move(callback));
 }
 
-void UserManagerService::LoadBlockList(::bgs::protocol::EntityId const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
-  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.LoadBlockList(bgs.protocol.EntityId{ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  std::function<void(MessageBuffer)> callback = [responseCallback](MessageBuffer buffer) -> void {
-    ::bgs::protocol::NoData response;
-    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
-      responseCallback(&response);
-  };
-  SendRequest(service_hash_, 50, request, std::move(callback));
-}
-
 void UserManagerService::Unsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) {
   TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.Unsubscribe(bgs.protocol.user_manager.v1.UnsubscribeRequest{ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
@@ -4233,16 +3683,16 @@ void UserManagerService::CallServerMethod(uint32 token, uint32 methodId, Message
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse::descriptor());
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
         UserManagerService* self = static_cast<UserManagerService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.AddRecentPlayers() returned bgs.protocol.user_manager.v1.AddRecentPlayersResponse{ %s } status %u.",
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.AddRecentPlayers() returned bgs.protocol.NoData{ %s } status %u.",
           self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
         if (!status)
           self->SendResponse(self->service_hash_, 10, token, response);
         else
           self->SendResponse(self->service_hash_, 10, token, status);
       };
-      ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse response;
+      ::bgs::protocol::NoData response;
       uint32 status = HandleAddRecentPlayers(&request, &response, continuation);
       if (continuation)
         continuation(this, status, &response);
@@ -4259,16 +3709,16 @@ void UserManagerService::CallServerMethod(uint32 token, uint32 methodId, Message
         GetCallerInfo().c_str(), request.ShortDebugString().c_str());
       std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
       {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse::descriptor());
+        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
         UserManagerService* self = static_cast<UserManagerService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.ClearRecentPlayers() returned bgs.protocol.user_manager.v1.ClearRecentPlayersResponse{ %s } status %u.",
+        TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.ClearRecentPlayers() returned bgs.protocol.NoData{ %s } status %u.",
           self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
         if (!status)
           self->SendResponse(self->service_hash_, 11, token, response);
         else
           self->SendResponse(self->service_hash_, 11, token, status);
       };
-      ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse response;
+      ::bgs::protocol::NoData response;
       uint32 status = HandleClearRecentPlayers(&request, &response, continuation);
       if (continuation)
         continuation(this, status, &response);
@@ -4352,32 +3802,6 @@ void UserManagerService::CallServerMethod(uint32 token, uint32 methodId, Message
         continuation(this, status, &response);
       break;
     }
-    case 50: {
-      ::bgs::protocol::EntityId request;
-      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
-        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.LoadBlockList server method call.", GetCallerInfo().c_str());
-        SendResponse(service_hash_, 50, token, ERROR_RPC_MALFORMED_REQUEST);
-        return;
-      }
-      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.LoadBlockList(bgs.protocol.EntityId{ %s }).",
-        GetCallerInfo().c_str(), request.ShortDebugString().c_str());
-      std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)> continuation = [token](ServiceBase* service, uint32 status, ::google::protobuf::Message const* response)
-      {
-        ASSERT(response->GetDescriptor() == ::bgs::protocol::NoData::descriptor());
-        UserManagerService* self = static_cast<UserManagerService*>(service);
-        TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.LoadBlockList() returned bgs.protocol.NoData{ %s } status %u.",
-          self->GetCallerInfo().c_str(), response->ShortDebugString().c_str(), status);
-        if (!status)
-          self->SendResponse(self->service_hash_, 50, token, response);
-        else
-          self->SendResponse(self->service_hash_, 50, token, status);
-      };
-      ::bgs::protocol::NoData response;
-      uint32 status = HandleLoadBlockList(&request, &response, continuation);
-      if (continuation)
-        continuation(this, status, &response);
-      break;
-    }
     case 51: {
       ::bgs::protocol::user_manager::v1::UnsubscribeRequest request;
       if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
@@ -4417,13 +3841,13 @@ uint32 UserManagerService::HandleSubscribe(::bgs::protocol::user_manager::v1::Su
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 UserManagerService::HandleAddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+uint32 UserManagerService::HandleAddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.AddRecentPlayers({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 UserManagerService::HandleClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
+uint32 UserManagerService::HandleClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.ClearRecentPlayers({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
   return ERROR_RPC_NOT_IMPLEMENTED;
@@ -4447,12 +3871,6 @@ uint32 UserManagerService::HandleBlockPlayerForSession(::bgs::protocol::user_man
   return ERROR_RPC_NOT_IMPLEMENTED;
 }
 
-uint32 UserManagerService::HandleLoadBlockList(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
-  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.LoadBlockList({ %s })",
-    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
-  return ERROR_RPC_NOT_IMPLEMENTED;
-}
-
 uint32 UserManagerService::HandleUnsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation) {
   TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.Unsubscribe({ %s })",
     GetCallerInfo().c_str(), request->ShortDebugString().c_str());
diff --git a/src/server/proto/Client/user_manager_service.pb.h b/src/server/proto/Client/user_manager_service.pb.h
index a89705e825a..9e56c0aefcd 100644
--- a/src/server/proto/Client/user_manager_service.pb.h
+++ b/src/server/proto/Client/user_manager_service.pb.h
@@ -48,9 +48,7 @@ class SubscribeRequest;
 class SubscribeResponse;
 class UnsubscribeRequest;
 class AddRecentPlayersRequest;
-class AddRecentPlayersResponse;
 class ClearRecentPlayersRequest;
-class ClearRecentPlayersResponse;
 class BlockPlayerRequest;
 class UnblockPlayerRequest;
 class BlockedPlayerAddedNotification;
@@ -454,101 +452,6 @@ class TC_PROTO_API AddRecentPlayersRequest : public ::google::protobuf::Message
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API AddRecentPlayersResponse : public ::google::protobuf::Message {
- public:
-  AddRecentPlayersResponse();
-  virtual ~AddRecentPlayersResponse();
-
-  AddRecentPlayersResponse(const AddRecentPlayersResponse& from);
-
-  inline AddRecentPlayersResponse& operator=(const AddRecentPlayersResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const AddRecentPlayersResponse& default_instance();
-
-  void Swap(AddRecentPlayersResponse* other);
-
-  // implements Message ----------------------------------------------
-
-  AddRecentPlayersResponse* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const AddRecentPlayersResponse& from);
-  void MergeFrom(const AddRecentPlayersResponse& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
-  inline int players_added_size() const;
-  inline void clear_players_added();
-  static const int kPlayersAddedFieldNumber = 1;
-  inline const ::bgs::protocol::user_manager::v1::RecentPlayer& players_added(int index) const;
-  inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_players_added(int index);
-  inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_players_added();
-  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
-      players_added() const;
-  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
-      mutable_players_added();
-
-  // repeated fixed32 players_removed = 3;
-  inline int players_removed_size() const;
-  inline void clear_players_removed();
-  static const int kPlayersRemovedFieldNumber = 3;
-  inline ::google::protobuf::uint32 players_removed(int index) const;
-  inline void set_players_removed(int index, ::google::protobuf::uint32 value);
-  inline void add_players_removed(::google::protobuf::uint32 value);
-  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-      players_removed() const;
-  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-      mutable_players_removed();
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
- private:
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > players_added_;
-  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > players_removed_;
-  friend void TC_PROTO_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
-  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static AddRecentPlayersResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API ClearRecentPlayersRequest : public ::google::protobuf::Message {
  public:
   ClearRecentPlayersRequest();
@@ -640,88 +543,6 @@ class TC_PROTO_API ClearRecentPlayersRequest : public ::google::protobuf::Messag
 };
 // -------------------------------------------------------------------
 
-class TC_PROTO_API ClearRecentPlayersResponse : public ::google::protobuf::Message {
- public:
-  ClearRecentPlayersResponse();
-  virtual ~ClearRecentPlayersResponse();
-
-  ClearRecentPlayersResponse(const ClearRecentPlayersResponse& from);
-
-  inline ClearRecentPlayersResponse& operator=(const ClearRecentPlayersResponse& from) {
-    CopyFrom(from);
-    return *this;
-  }
-
-  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
-    return _unknown_fields_;
-  }
-
-  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
-    return &_unknown_fields_;
-  }
-
-  static const ::google::protobuf::Descriptor* descriptor();
-  static const ClearRecentPlayersResponse& default_instance();
-
-  void Swap(ClearRecentPlayersResponse* other);
-
-  // implements Message ----------------------------------------------
-
-  ClearRecentPlayersResponse* New() const;
-  void CopyFrom(const ::google::protobuf::Message& from);
-  void MergeFrom(const ::google::protobuf::Message& from);
-  void CopyFrom(const ClearRecentPlayersResponse& from);
-  void MergeFrom(const ClearRecentPlayersResponse& from);
-  void Clear();
-  bool IsInitialized() const;
-
-  int ByteSize() const;
-  bool MergePartialFromCodedStream(
-      ::google::protobuf::io::CodedInputStream* input);
-  void SerializeWithCachedSizes(
-      ::google::protobuf::io::CodedOutputStream* output) const;
-  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
-  int GetCachedSize() const { return _cached_size_; }
-  private:
-  void SharedCtor();
-  void SharedDtor();
-  void SetCachedSize(int size) const;
-  public:
-  ::google::protobuf::Metadata GetMetadata() const;
-
-  // nested types ----------------------------------------------------
-
-  // accessors -------------------------------------------------------
-
-  // repeated fixed32 players_removed = 1;
-  inline int players_removed_size() const;
-  inline void clear_players_removed();
-  static const int kPlayersRemovedFieldNumber = 1;
-  inline ::google::protobuf::uint32 players_removed(int index) const;
-  inline void set_players_removed(int index, ::google::protobuf::uint32 value);
-  inline void add_players_removed(::google::protobuf::uint32 value);
-  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-      players_removed() const;
-  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-      mutable_players_removed();
-
-  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
- private:
-
-  ::google::protobuf::UnknownFieldSet _unknown_fields_;
-
-  ::google::protobuf::uint32 _has_bits_[1];
-  mutable int _cached_size_;
-  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > players_removed_;
-  friend void TC_PROTO_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
-  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
-  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
-
-  void InitAsDefaultInstance();
-  static ClearRecentPlayersResponse* default_instance_;
-};
-// -------------------------------------------------------------------
-
 class TC_PROTO_API BlockPlayerRequest : public ::google::protobuf::Message {
  public:
   BlockPlayerRequest();
@@ -1307,12 +1128,11 @@ class TC_PROTO_API UserManagerService : public ServiceBase
   // client methods --------------------------------------------------
 
   void Subscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::SubscribeResponse const*)> responseCallback);
-  void AddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::AddRecentPlayersResponse const*)> responseCallback);
-  void ClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse const*)> responseCallback);
+  void AddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void ClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void BlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void UnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void BlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
-  void LoadBlockList(::bgs::protocol::EntityId const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   void Unsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
   // server methods --------------------------------------------------
 
@@ -1320,12 +1140,11 @@ class TC_PROTO_API UserManagerService : public ServiceBase
 
  protected:
   virtual uint32 HandleSubscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, ::bgs::protocol::user_manager::v1::SubscribeResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleAddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleAddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
+  virtual uint32 HandleClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleBlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleUnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleBlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
-  virtual uint32 HandleLoadBlockList(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
   virtual uint32 HandleUnsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
 
  private:
@@ -1706,70 +1525,6 @@ inline void AddRecentPlayersRequest::set_program(::google::protobuf::uint32 valu
 
 // -------------------------------------------------------------------
 
-// AddRecentPlayersResponse
-
-// repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
-inline int AddRecentPlayersResponse::players_added_size() const {
-  return players_added_.size();
-}
-inline void AddRecentPlayersResponse::clear_players_added() {
-  players_added_.Clear();
-}
-inline const ::bgs::protocol::user_manager::v1::RecentPlayer& AddRecentPlayersResponse::players_added(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
-  return players_added_.Get(index);
-}
-inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersResponse::mutable_players_added(int index) {
-  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
-  return players_added_.Mutable(index);
-}
-inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersResponse::add_players_added() {
-  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
-  return players_added_.Add();
-}
-inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
-AddRecentPlayersResponse::players_added() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
-  return players_added_;
-}
-inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
-AddRecentPlayersResponse::mutable_players_added() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
-  return &players_added_;
-}
-
-// repeated fixed32 players_removed = 3;
-inline int AddRecentPlayersResponse::players_removed_size() const {
-  return players_removed_.size();
-}
-inline void AddRecentPlayersResponse::clear_players_removed() {
-  players_removed_.Clear();
-}
-inline ::google::protobuf::uint32 AddRecentPlayersResponse::players_removed(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
-  return players_removed_.Get(index);
-}
-inline void AddRecentPlayersResponse::set_players_removed(int index, ::google::protobuf::uint32 value) {
-  players_removed_.Set(index, value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
-}
-inline void AddRecentPlayersResponse::add_players_removed(::google::protobuf::uint32 value) {
-  players_removed_.Add(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
-}
-inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-AddRecentPlayersResponse::players_removed() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
-  return players_removed_;
-}
-inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-AddRecentPlayersResponse::mutable_players_removed() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
-  return &players_removed_;
-}
-
-// -------------------------------------------------------------------
-
 // ClearRecentPlayersRequest
 
 // optional .bgs.protocol.EntityId agent_id = 1;
@@ -1839,40 +1594,6 @@ inline void ClearRecentPlayersRequest::set_program(::google::protobuf::uint32 va
 
 // -------------------------------------------------------------------
 
-// ClearRecentPlayersResponse
-
-// repeated fixed32 players_removed = 1;
-inline int ClearRecentPlayersResponse::players_removed_size() const {
-  return players_removed_.size();
-}
-inline void ClearRecentPlayersResponse::clear_players_removed() {
-  players_removed_.Clear();
-}
-inline ::google::protobuf::uint32 ClearRecentPlayersResponse::players_removed(int index) const {
-  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
-  return players_removed_.Get(index);
-}
-inline void ClearRecentPlayersResponse::set_players_removed(int index, ::google::protobuf::uint32 value) {
-  players_removed_.Set(index, value);
-  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
-}
-inline void ClearRecentPlayersResponse::add_players_removed(::google::protobuf::uint32 value) {
-  players_removed_.Add(value);
-  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
-}
-inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
-ClearRecentPlayersResponse::players_removed() const {
-  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
-  return players_removed_;
-}
-inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
-ClearRecentPlayersResponse::mutable_players_removed() {
-  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
-  return &players_removed_;
-}
-
-// -------------------------------------------------------------------
-
 // BlockPlayerRequest
 
 // optional .bgs.protocol.EntityId agent_id = 1;
diff --git a/src/server/proto/Client/voice_types.pb.cc b/src/server/proto/Client/voice_types.pb.cc
new file mode 100644
index 00000000000..0fed25ba2fc
--- /dev/null
+++ b/src/server/proto/Client/voice_types.pb.cc
@@ -0,0 +1,616 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: voice_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "voice_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* VoiceCredentials_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  VoiceCredentials_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* VoiceJoinType_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* VoiceMuteReason_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_voice_5ftypes_2eproto() {
+  protobuf_AddDesc_voice_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "voice_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  VoiceCredentials_descriptor_ = file->message_type(0);
+  static const int VoiceCredentials_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VoiceCredentials, voice_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VoiceCredentials, token_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VoiceCredentials, url_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VoiceCredentials, join_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VoiceCredentials, mute_reason_),
+  };
+  VoiceCredentials_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      VoiceCredentials_descriptor_,
+      VoiceCredentials::default_instance_,
+      VoiceCredentials_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VoiceCredentials, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VoiceCredentials, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(VoiceCredentials));
+  VoiceJoinType_descriptor_ = file->enum_type(0);
+  VoiceMuteReason_descriptor_ = file->enum_type(1);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_voice_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    VoiceCredentials_descriptor_, &VoiceCredentials::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_voice_5ftypes_2eproto() {
+  delete VoiceCredentials::default_instance_;
+  delete VoiceCredentials_reflection_;
+}
+
+void protobuf_AddDesc_voice_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\021voice_types.proto\022\014bgs.protocol\"\244\001\n\020Vo"
+    "iceCredentials\022\020\n\010voice_id\030\001 \001(\t\022\r\n\005toke"
+    "n\030\002 \001(\t\022\013\n\003url\030\003 \001(\t\022.\n\tjoin_type\030\004 \001(\0162"
+    "\033.bgs.protocol.VoiceJoinType\0222\n\013mute_rea"
+    "son\030\005 \001(\0162\035.bgs.protocol.VoiceMuteReason"
+    "*<\n\rVoiceJoinType\022\025\n\021VOICE_JOIN_NORMAL\020\000"
+    "\022\024\n\020VOICE_JOIN_MUTED\020\001*\202\001\n\017VoiceMuteReas"
+    "on\022\032\n\026VOICE_MUTE_REASON_NONE\020\000\0222\n.VOICE_"
+    "MUTE_REASON_PARENTAL_CONTROL_LISTEN_ONLY"
+    "\020\001\022\037\n\033VOICE_MUTE_REASON_REQUESTED\020\002B\002H\001", 399);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "voice_types.proto", &protobuf_RegisterTypes);
+  VoiceCredentials::default_instance_ = new VoiceCredentials();
+  VoiceCredentials::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_voice_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_voice_5ftypes_2eproto {
+  StaticDescriptorInitializer_voice_5ftypes_2eproto() {
+    protobuf_AddDesc_voice_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_voice_5ftypes_2eproto_;
+const ::google::protobuf::EnumDescriptor* VoiceJoinType_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return VoiceJoinType_descriptor_;
+}
+bool VoiceJoinType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+const ::google::protobuf::EnumDescriptor* VoiceMuteReason_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return VoiceMuteReason_descriptor_;
+}
+bool VoiceMuteReason_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int VoiceCredentials::kVoiceIdFieldNumber;
+const int VoiceCredentials::kTokenFieldNumber;
+const int VoiceCredentials::kUrlFieldNumber;
+const int VoiceCredentials::kJoinTypeFieldNumber;
+const int VoiceCredentials::kMuteReasonFieldNumber;
+#endif  // !_MSC_VER
+
+VoiceCredentials::VoiceCredentials()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.VoiceCredentials)
+}
+
+void VoiceCredentials::InitAsDefaultInstance() {
+}
+
+VoiceCredentials::VoiceCredentials(const VoiceCredentials& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.VoiceCredentials)
+}
+
+void VoiceCredentials::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  voice_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  join_type_ = 0;
+  mute_reason_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+VoiceCredentials::~VoiceCredentials() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.VoiceCredentials)
+  SharedDtor();
+}
+
+void VoiceCredentials::SharedDtor() {
+  if (voice_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete voice_id_;
+  }
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void VoiceCredentials::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* VoiceCredentials::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return VoiceCredentials_descriptor_;
+}
+
+const VoiceCredentials& VoiceCredentials::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_voice_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+VoiceCredentials* VoiceCredentials::default_instance_ = NULL;
+
+VoiceCredentials* VoiceCredentials::New() const {
+  return new VoiceCredentials;
+}
+
+void VoiceCredentials::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<VoiceCredentials*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(join_type_, mute_reason_);
+    if (has_voice_id()) {
+      if (voice_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        voice_id_->clear();
+      }
+    }
+    if (has_token()) {
+      if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        token_->clear();
+      }
+    }
+    if (has_url()) {
+      if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        url_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool VoiceCredentials::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.VoiceCredentials)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string voice_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_voice_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->voice_id().data(), this->voice_id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "voice_id");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_token;
+        break;
+      }
+
+      // optional string token = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_token:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_token()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->token().data(), this->token().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "token");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_url;
+        break;
+      }
+
+      // optional string url = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_url()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->url().data(), this->url().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "url");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_join_type;
+        break;
+      }
+
+      // optional .bgs.protocol.VoiceJoinType join_type = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_join_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::VoiceJoinType_IsValid(value)) {
+            set_join_type(static_cast< ::bgs::protocol::VoiceJoinType >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(4, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_mute_reason;
+        break;
+      }
+
+      // optional .bgs.protocol.VoiceMuteReason mute_reason = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_mute_reason:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::VoiceMuteReason_IsValid(value)) {
+            set_mute_reason(static_cast< ::bgs::protocol::VoiceMuteReason >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(5, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.VoiceCredentials)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.VoiceCredentials)
+  return false;
+#undef DO_
+}
+
+void VoiceCredentials::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.VoiceCredentials)
+  // optional string voice_id = 1;
+  if (has_voice_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->voice_id().data(), this->voice_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "voice_id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->voice_id(), output);
+  }
+
+  // optional string token = 2;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->token().data(), this->token().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "token");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->token(), output);
+  }
+
+  // optional string url = 3;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->url().data(), this->url().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "url");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->url(), output);
+  }
+
+  // optional .bgs.protocol.VoiceJoinType join_type = 4;
+  if (has_join_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      4, this->join_type(), output);
+  }
+
+  // optional .bgs.protocol.VoiceMuteReason mute_reason = 5;
+  if (has_mute_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->mute_reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.VoiceCredentials)
+}
+
+::google::protobuf::uint8* VoiceCredentials::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.VoiceCredentials)
+  // optional string voice_id = 1;
+  if (has_voice_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->voice_id().data(), this->voice_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "voice_id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->voice_id(), target);
+  }
+
+  // optional string token = 2;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->token().data(), this->token().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "token");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->token(), target);
+  }
+
+  // optional string url = 3;
+  if (has_url()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->url().data(), this->url().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "url");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->url(), target);
+  }
+
+  // optional .bgs.protocol.VoiceJoinType join_type = 4;
+  if (has_join_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      4, this->join_type(), target);
+  }
+
+  // optional .bgs.protocol.VoiceMuteReason mute_reason = 5;
+  if (has_mute_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      5, this->mute_reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.VoiceCredentials)
+  return target;
+}
+
+int VoiceCredentials::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string voice_id = 1;
+    if (has_voice_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->voice_id());
+    }
+
+    // optional string token = 2;
+    if (has_token()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->token());
+    }
+
+    // optional string url = 3;
+    if (has_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->url());
+    }
+
+    // optional .bgs.protocol.VoiceJoinType join_type = 4;
+    if (has_join_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->join_type());
+    }
+
+    // optional .bgs.protocol.VoiceMuteReason mute_reason = 5;
+    if (has_mute_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->mute_reason());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void VoiceCredentials::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const VoiceCredentials* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const VoiceCredentials*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void VoiceCredentials::MergeFrom(const VoiceCredentials& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_voice_id()) {
+      set_voice_id(from.voice_id());
+    }
+    if (from.has_token()) {
+      set_token(from.token());
+    }
+    if (from.has_url()) {
+      set_url(from.url());
+    }
+    if (from.has_join_type()) {
+      set_join_type(from.join_type());
+    }
+    if (from.has_mute_reason()) {
+      set_mute_reason(from.mute_reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void VoiceCredentials::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void VoiceCredentials::CopyFrom(const VoiceCredentials& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool VoiceCredentials::IsInitialized() const {
+
+  return true;
+}
+
+void VoiceCredentials::Swap(VoiceCredentials* other) {
+  if (other != this) {
+    std::swap(voice_id_, other->voice_id_);
+    std::swap(token_, other->token_);
+    std::swap(url_, other->url_);
+    std::swap(join_type_, other->join_type_);
+    std::swap(mute_reason_, other->mute_reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata VoiceCredentials::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = VoiceCredentials_descriptor_;
+  metadata.reflection = VoiceCredentials_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/voice_types.pb.h b/src/server/proto/Client/voice_types.pb.h
new file mode 100644
index 00000000000..658ca9917d5
--- /dev/null
+++ b/src/server/proto/Client/voice_types.pb.h
@@ -0,0 +1,529 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: voice_types.proto
+
+#ifndef PROTOBUF_voice_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_voice_5ftypes_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2006000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Define.h" // for TC_PROTO_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_PROTO_API protobuf_AddDesc_voice_5ftypes_2eproto();
+void protobuf_AssignDesc_voice_5ftypes_2eproto();
+void protobuf_ShutdownFile_voice_5ftypes_2eproto();
+
+class VoiceCredentials;
+
+enum VoiceJoinType {
+  VOICE_JOIN_NORMAL = 0,
+  VOICE_JOIN_MUTED = 1
+};
+TC_PROTO_API bool VoiceJoinType_IsValid(int value);
+const VoiceJoinType VoiceJoinType_MIN = VOICE_JOIN_NORMAL;
+const VoiceJoinType VoiceJoinType_MAX = VOICE_JOIN_MUTED;
+const int VoiceJoinType_ARRAYSIZE = VoiceJoinType_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* VoiceJoinType_descriptor();
+inline const ::std::string& VoiceJoinType_Name(VoiceJoinType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    VoiceJoinType_descriptor(), value);
+}
+inline bool VoiceJoinType_Parse(
+    const ::std::string& name, VoiceJoinType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<VoiceJoinType>(
+    VoiceJoinType_descriptor(), name, value);
+}
+enum VoiceMuteReason {
+  VOICE_MUTE_REASON_NONE = 0,
+  VOICE_MUTE_REASON_PARENTAL_CONTROL_LISTEN_ONLY = 1,
+  VOICE_MUTE_REASON_REQUESTED = 2
+};
+TC_PROTO_API bool VoiceMuteReason_IsValid(int value);
+const VoiceMuteReason VoiceMuteReason_MIN = VOICE_MUTE_REASON_NONE;
+const VoiceMuteReason VoiceMuteReason_MAX = VOICE_MUTE_REASON_REQUESTED;
+const int VoiceMuteReason_ARRAYSIZE = VoiceMuteReason_MAX + 1;
+
+TC_PROTO_API const ::google::protobuf::EnumDescriptor* VoiceMuteReason_descriptor();
+inline const ::std::string& VoiceMuteReason_Name(VoiceMuteReason value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    VoiceMuteReason_descriptor(), value);
+}
+inline bool VoiceMuteReason_Parse(
+    const ::std::string& name, VoiceMuteReason* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<VoiceMuteReason>(
+    VoiceMuteReason_descriptor(), name, value);
+}
+// ===================================================================
+
+class TC_PROTO_API VoiceCredentials : public ::google::protobuf::Message {
+ public:
+  VoiceCredentials();
+  virtual ~VoiceCredentials();
+
+  VoiceCredentials(const VoiceCredentials& from);
+
+  inline VoiceCredentials& operator=(const VoiceCredentials& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const VoiceCredentials& default_instance();
+
+  void Swap(VoiceCredentials* other);
+
+  // implements Message ----------------------------------------------
+
+  VoiceCredentials* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const VoiceCredentials& from);
+  void MergeFrom(const VoiceCredentials& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string voice_id = 1;
+  inline bool has_voice_id() const;
+  inline void clear_voice_id();
+  static const int kVoiceIdFieldNumber = 1;
+  inline const ::std::string& voice_id() const;
+  inline void set_voice_id(const ::std::string& value);
+  inline void set_voice_id(const char* value);
+  inline void set_voice_id(const char* value, size_t size);
+  inline ::std::string* mutable_voice_id();
+  inline ::std::string* release_voice_id();
+  inline void set_allocated_voice_id(::std::string* voice_id);
+
+  // optional string token = 2;
+  inline bool has_token() const;
+  inline void clear_token();
+  static const int kTokenFieldNumber = 2;
+  inline const ::std::string& token() const;
+  inline void set_token(const ::std::string& value);
+  inline void set_token(const char* value);
+  inline void set_token(const char* value, size_t size);
+  inline ::std::string* mutable_token();
+  inline ::std::string* release_token();
+  inline void set_allocated_token(::std::string* token);
+
+  // optional string url = 3;
+  inline bool has_url() const;
+  inline void clear_url();
+  static const int kUrlFieldNumber = 3;
+  inline const ::std::string& url() const;
+  inline void set_url(const ::std::string& value);
+  inline void set_url(const char* value);
+  inline void set_url(const char* value, size_t size);
+  inline ::std::string* mutable_url();
+  inline ::std::string* release_url();
+  inline void set_allocated_url(::std::string* url);
+
+  // optional .bgs.protocol.VoiceJoinType join_type = 4;
+  inline bool has_join_type() const;
+  inline void clear_join_type();
+  static const int kJoinTypeFieldNumber = 4;
+  inline ::bgs::protocol::VoiceJoinType join_type() const;
+  inline void set_join_type(::bgs::protocol::VoiceJoinType value);
+
+  // optional .bgs.protocol.VoiceMuteReason mute_reason = 5;
+  inline bool has_mute_reason() const;
+  inline void clear_mute_reason();
+  static const int kMuteReasonFieldNumber = 5;
+  inline ::bgs::protocol::VoiceMuteReason mute_reason() const;
+  inline void set_mute_reason(::bgs::protocol::VoiceMuteReason value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.VoiceCredentials)
+ private:
+  inline void set_has_voice_id();
+  inline void clear_has_voice_id();
+  inline void set_has_token();
+  inline void clear_has_token();
+  inline void set_has_url();
+  inline void clear_has_url();
+  inline void set_has_join_type();
+  inline void clear_has_join_type();
+  inline void set_has_mute_reason();
+  inline void clear_has_mute_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* voice_id_;
+  ::std::string* token_;
+  ::std::string* url_;
+  int join_type_;
+  int mute_reason_;
+  friend void TC_PROTO_API protobuf_AddDesc_voice_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_voice_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_voice_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static VoiceCredentials* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// VoiceCredentials
+
+// optional string voice_id = 1;
+inline bool VoiceCredentials::has_voice_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void VoiceCredentials::set_has_voice_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void VoiceCredentials::clear_has_voice_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void VoiceCredentials::clear_voice_id() {
+  if (voice_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    voice_id_->clear();
+  }
+  clear_has_voice_id();
+}
+inline const ::std::string& VoiceCredentials::voice_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.VoiceCredentials.voice_id)
+  return *voice_id_;
+}
+inline void VoiceCredentials::set_voice_id(const ::std::string& value) {
+  set_has_voice_id();
+  if (voice_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    voice_id_ = new ::std::string;
+  }
+  voice_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.VoiceCredentials.voice_id)
+}
+inline void VoiceCredentials::set_voice_id(const char* value) {
+  set_has_voice_id();
+  if (voice_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    voice_id_ = new ::std::string;
+  }
+  voice_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.VoiceCredentials.voice_id)
+}
+inline void VoiceCredentials::set_voice_id(const char* value, size_t size) {
+  set_has_voice_id();
+  if (voice_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    voice_id_ = new ::std::string;
+  }
+  voice_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.VoiceCredentials.voice_id)
+}
+inline ::std::string* VoiceCredentials::mutable_voice_id() {
+  set_has_voice_id();
+  if (voice_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    voice_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.VoiceCredentials.voice_id)
+  return voice_id_;
+}
+inline ::std::string* VoiceCredentials::release_voice_id() {
+  clear_has_voice_id();
+  if (voice_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = voice_id_;
+    voice_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void VoiceCredentials::set_allocated_voice_id(::std::string* voice_id) {
+  if (voice_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete voice_id_;
+  }
+  if (voice_id) {
+    set_has_voice_id();
+    voice_id_ = voice_id;
+  } else {
+    clear_has_voice_id();
+    voice_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.VoiceCredentials.voice_id)
+}
+
+// optional string token = 2;
+inline bool VoiceCredentials::has_token() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void VoiceCredentials::set_has_token() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void VoiceCredentials::clear_has_token() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void VoiceCredentials::clear_token() {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_->clear();
+  }
+  clear_has_token();
+}
+inline const ::std::string& VoiceCredentials::token() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.VoiceCredentials.token)
+  return *token_;
+}
+inline void VoiceCredentials::set_token(const ::std::string& value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.VoiceCredentials.token)
+}
+inline void VoiceCredentials::set_token(const char* value) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.VoiceCredentials.token)
+}
+inline void VoiceCredentials::set_token(const char* value, size_t size) {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  token_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.VoiceCredentials.token)
+}
+inline ::std::string* VoiceCredentials::mutable_token() {
+  set_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    token_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.VoiceCredentials.token)
+  return token_;
+}
+inline ::std::string* VoiceCredentials::release_token() {
+  clear_has_token();
+  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = token_;
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void VoiceCredentials::set_allocated_token(::std::string* token) {
+  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete token_;
+  }
+  if (token) {
+    set_has_token();
+    token_ = token;
+  } else {
+    clear_has_token();
+    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.VoiceCredentials.token)
+}
+
+// optional string url = 3;
+inline bool VoiceCredentials::has_url() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void VoiceCredentials::set_has_url() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void VoiceCredentials::clear_has_url() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void VoiceCredentials::clear_url() {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_->clear();
+  }
+  clear_has_url();
+}
+inline const ::std::string& VoiceCredentials::url() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.VoiceCredentials.url)
+  return *url_;
+}
+inline void VoiceCredentials::set_url(const ::std::string& value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.VoiceCredentials.url)
+}
+inline void VoiceCredentials::set_url(const char* value) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.VoiceCredentials.url)
+}
+inline void VoiceCredentials::set_url(const char* value, size_t size) {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.VoiceCredentials.url)
+}
+inline ::std::string* VoiceCredentials::mutable_url() {
+  set_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.VoiceCredentials.url)
+  return url_;
+}
+inline ::std::string* VoiceCredentials::release_url() {
+  clear_has_url();
+  if (url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = url_;
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void VoiceCredentials::set_allocated_url(::std::string* url) {
+  if (url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete url_;
+  }
+  if (url) {
+    set_has_url();
+    url_ = url;
+  } else {
+    clear_has_url();
+    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.VoiceCredentials.url)
+}
+
+// optional .bgs.protocol.VoiceJoinType join_type = 4;
+inline bool VoiceCredentials::has_join_type() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void VoiceCredentials::set_has_join_type() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void VoiceCredentials::clear_has_join_type() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void VoiceCredentials::clear_join_type() {
+  join_type_ = 0;
+  clear_has_join_type();
+}
+inline ::bgs::protocol::VoiceJoinType VoiceCredentials::join_type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.VoiceCredentials.join_type)
+  return static_cast< ::bgs::protocol::VoiceJoinType >(join_type_);
+}
+inline void VoiceCredentials::set_join_type(::bgs::protocol::VoiceJoinType value) {
+  assert(::bgs::protocol::VoiceJoinType_IsValid(value));
+  set_has_join_type();
+  join_type_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.VoiceCredentials.join_type)
+}
+
+// optional .bgs.protocol.VoiceMuteReason mute_reason = 5;
+inline bool VoiceCredentials::has_mute_reason() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void VoiceCredentials::set_has_mute_reason() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void VoiceCredentials::clear_has_mute_reason() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void VoiceCredentials::clear_mute_reason() {
+  mute_reason_ = 0;
+  clear_has_mute_reason();
+}
+inline ::bgs::protocol::VoiceMuteReason VoiceCredentials::mute_reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.VoiceCredentials.mute_reason)
+  return static_cast< ::bgs::protocol::VoiceMuteReason >(mute_reason_);
+}
+inline void VoiceCredentials::set_mute_reason(::bgs::protocol::VoiceMuteReason value) {
+  assert(::bgs::protocol::VoiceMuteReason_IsValid(value));
+  set_has_mute_reason();
+  mute_reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.VoiceCredentials.mute_reason)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::VoiceJoinType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::VoiceJoinType>() {
+  return ::bgs::protocol::VoiceJoinType_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::VoiceMuteReason> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::VoiceMuteReason>() {
+  return ::bgs::protocol::VoiceMuteReason_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_voice_5ftypes_2eproto__INCLUDED
diff --git a/src/server/scripts/Commands/cs_character.cpp b/src/server/scripts/Commands/cs_character.cpp
index f62ae5f45ca..e2a29b62bea 100644
--- a/src/server/scripts/Commands/cs_character.cpp
+++ b/src/server/scripts/Commands/cs_character.cpp
@@ -235,7 +235,7 @@ public:
         {
             player->GiveLevel(newLevel);
             player->InitTalentForLevel();
-            player->SetUInt32Value(PLAYER_XP, 0);
+            player->SetUInt32Value(ACTIVE_PLAYER_FIELD_XP, 0);
 
             if (handler->needReportToTarget(player))
             {
diff --git a/src/server/scripts/Commands/cs_cheat.cpp b/src/server/scripts/Commands/cs_cheat.cpp
index b9c2e78b98a..c4100d84438 100644
--- a/src/server/scripts/Commands/cs_cheat.cpp
+++ b/src/server/scripts/Commands/cs_cheat.cpp
@@ -276,9 +276,9 @@ public:
         for (uint16 i = 0; i < PLAYER_EXPLORED_ZONES_SIZE; ++i)
         {
             if (flag != 0)
-                handler->GetSession()->GetPlayer()->SetFlag(PLAYER_EXPLORED_ZONES_1+i, 0xFFFFFFFF);
+                handler->GetSession()->GetPlayer()->SetFlag(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + i, 0xFFFFFFFF);
             else
-                handler->GetSession()->GetPlayer()->SetFlag(PLAYER_EXPLORED_ZONES_1+i, 0);
+                handler->GetSession()->GetPlayer()->SetFlag(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + i, 0);
         }
 
         return true;
diff --git a/src/server/scripts/Commands/cs_debug.cpp b/src/server/scripts/Commands/cs_debug.cpp
index f29a12eb029..ef9007bac85 100644
--- a/src/server/scripts/Commands/cs_debug.cpp
+++ b/src/server/scripts/Commands/cs_debug.cpp
@@ -985,7 +985,7 @@ public:
 
         if (m)
             if (uint32 um = (uint32)atoi(m))
-                phaseShift.AddUiWorldMapAreaIdSwap(um);
+                phaseShift.AddUiMapPhaseId(um);
 
         PhasingHandler::SendToPlayer(handler->GetSession()->GetPlayer(), phaseShift);
         return true;
diff --git a/src/server/scripts/Commands/cs_lookup.cpp b/src/server/scripts/Commands/cs_lookup.cpp
index 1c235bb8483..d1eaa9198f5 100644
--- a/src/server/scripts/Commands/cs_lookup.cpp
+++ b/src/server/scripts/Commands/cs_lookup.cpp
@@ -658,7 +658,11 @@ public:
                             }
 
                             if (handler->GetSession())
-                                handler->PSendSysMessage(LANG_QUEST_LIST_CHAT, qInfo->GetQuestId(), qInfo->GetQuestId(), qInfo->GetQuestLevel(), title.c_str(), statusStr);
+                                handler->PSendSysMessage(LANG_QUEST_LIST_CHAT, qInfo->GetQuestId(), qInfo->GetQuestId(),
+                                    handler->GetSession()->GetPlayer()->GetQuestLevel(qInfo),
+                                    handler->GetSession()->GetPlayer()->GetQuestMinLevel(qInfo),
+                                    qInfo->GetQuestMaxScalingLevel(), qInfo->GetQuestScalingFactionGroup(),
+                                    title.c_str(), statusStr);
                             else
                                 handler->PSendSysMessage(LANG_QUEST_LIST_CONSOLE, qInfo->GetQuestId(), title.c_str(), statusStr);
 
@@ -706,7 +710,11 @@ public:
                 }
 
                 if (handler->GetSession())
-                    handler->PSendSysMessage(LANG_QUEST_LIST_CHAT, qInfo->GetQuestId(), qInfo->GetQuestId(), qInfo->GetQuestLevel(), title.c_str(), statusStr);
+                    handler->PSendSysMessage(LANG_QUEST_LIST_CHAT, qInfo->GetQuestId(), qInfo->GetQuestId(),
+                        handler->GetSession()->GetPlayer()->GetQuestLevel(qInfo),
+                        handler->GetSession()->GetPlayer()->GetQuestMinLevel(qInfo),
+                        qInfo->GetQuestMaxScalingLevel(), qInfo->GetQuestScalingFactionGroup(),
+                        title.c_str(), statusStr);
                 else
                     handler->PSendSysMessage(LANG_QUEST_LIST_CONSOLE, qInfo->GetQuestId(), title.c_str(), statusStr);
 
diff --git a/src/server/scripts/Commands/cs_misc.cpp b/src/server/scripts/Commands/cs_misc.cpp
index 9be3ff64559..a5a3fe831b2 100644
--- a/src/server/scripts/Commands/cs_misc.cpp
+++ b/src/server/scripts/Commands/cs_misc.cpp
@@ -1203,8 +1203,8 @@ public:
         }
 
         uint32 val = uint32((1 << (area->AreaBit % 32)));
-        uint32 currFields = playerTarget->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
-        playerTarget->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, uint32((currFields | val)));
+        uint32 currFields = playerTarget->GetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + offset);
+        playerTarget->SetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + offset, uint32((currFields | val)));
 
         handler->SendSysMessage(LANG_EXPLORE_AREA);
         return true;
@@ -1247,8 +1247,8 @@ public:
         }
 
         uint32 val = uint32((1 << (area->AreaBit % 32)));
-        uint32 currFields = playerTarget->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
-        playerTarget->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, uint32((currFields ^ val)));
+        uint32 currFields = playerTarget->GetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + offset);
+        playerTarget->SetUInt32Value(ACTIVE_PLAYER_FIELD_EXPLORED_ZONES + offset, uint32((currFields ^ val)));
 
         handler->SendSysMessage(LANG_UNEXPLORE_AREA);
         return true;
diff --git a/src/server/scripts/Commands/cs_modify.cpp b/src/server/scripts/Commands/cs_modify.cpp
index a17824a0127..6dc2d9b84f2 100644
--- a/src/server/scripts/Commands/cs_modify.cpp
+++ b/src/server/scripts/Commands/cs_modify.cpp
@@ -493,7 +493,10 @@ public:
         if (CheckModifySpeed(handler, args, target, Scale, 0.1f, 10.0f, false))
         {
             NotifyModification(handler, target, LANG_YOU_CHANGE_SIZE, LANG_YOURS_SIZE_CHANGED, Scale);
-            target->SetObjectScale(Scale);
+            if (Creature* creatureTarget = target->ToCreature())
+                creatureTarget->SetFloatValue(UNIT_FIELD_DISPLAY_SCALE, Scale);
+            else
+                target->SetObjectScale(Scale);
             return true;
         }
         return false;
diff --git a/src/server/scripts/Commands/cs_quest.cpp b/src/server/scripts/Commands/cs_quest.cpp
index 6691158360c..cb9cacdcc7b 100644
--- a/src/server/scripts/Commands/cs_quest.cpp
+++ b/src/server/scripts/Commands/cs_quest.cpp
@@ -64,7 +64,7 @@ public:
         }
 
         // .addquest #entry'
-        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
+        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level:min_level:max_level:scaling_faction|h[name]|h|r
         char* cId = handler->extractKeyFromLink((char*)args, "Hquest");
         if (!cId)
             return false;
@@ -112,7 +112,7 @@ public:
         }
 
         // .removequest #entry'
-        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
+        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level:min_level:max_level:scaling_faction|h[name]|h|r
         char* cId = handler->extractKeyFromLink((char*)args, "Hquest");
         if (!cId)
             return false;
@@ -170,7 +170,7 @@ public:
         }
 
         // .quest complete #entry
-        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
+        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level:min_level:max_level:scaling_faction|h[name]|h|r
         char* cId = handler->extractKeyFromLink((char*)args, "Hquest");
         if (!cId)
             return false;
@@ -268,7 +268,7 @@ public:
         }
 
         // .quest reward #entry
-        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level|h[name]|h|r
+        // number or [name] Shift-click form |color|Hquest:quest_id:quest_level:min_level:max_level:scaling_faction|h[name]|h|r
         char* cId = handler->extractKeyFromLink((char*)args, "Hquest");
         if (!cId)
             return false;
diff --git a/src/server/scripts/Commands/cs_reset.cpp b/src/server/scripts/Commands/cs_reset.cpp
index 10c924b89ed..1c62712f5bd 100644
--- a/src/server/scripts/Commands/cs_reset.cpp
+++ b/src/server/scripts/Commands/cs_reset.cpp
@@ -83,8 +83,8 @@ public:
         if (!handler->extractPlayerTarget((char*)args, &target))
             return false;
 
-        target->SetUInt32Value(PLAYER_FIELD_KILLS, 0);
-        target->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, 0);
+        target->SetUInt32Value(ACTIVE_PLAYER_FIELD_KILLS, 0);
+        target->SetUInt32Value(ACTIVE_PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, 0);
         target->UpdateCriteria(CRITERIA_TYPE_EARN_HONORABLE_KILL);
 
         return true;
@@ -117,7 +117,7 @@ public:
         player->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
 
         //-1 is default value
-        player->SetUInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, uint32(-1));
+        player->SetUInt32Value(ACTIVE_PLAYER_FIELD_WATCHED_FACTION_INDEX, uint32(-1));
         return true;
     }
 
@@ -143,7 +143,7 @@ public:
         target->InitStatsForLevel(true);
         target->InitTaxiNodesForLevel();
         target->InitTalentForLevel();
-        target->SetUInt32Value(PLAYER_XP, 0);
+        target->SetUInt32Value(ACTIVE_PLAYER_FIELD_XP, 0);
 
         target->_ApplyAllLevelScaleItemMods(true);
 
diff --git a/src/server/scripts/Commands/cs_titles.cpp b/src/server/scripts/Commands/cs_titles.cpp
index b493f810e13..c910d9ca8ce 100644
--- a/src/server/scripts/Commands/cs_titles.cpp
+++ b/src/server/scripts/Commands/cs_titles.cpp
@@ -234,7 +234,7 @@ public:
 
         titles &= ~titles2;                                     // remove non-existing titles
 
-        target->SetUInt64Value(PLAYER__FIELD_KNOWN_TITLES, titles);
+        target->SetUInt64Value(ACTIVE_PLAYER_FIELD_KNOWN_TITLES, titles);
         handler->SendSysMessage(LANG_DONE);
 
         if (!target->HasTitle(target->GetInt32Value(PLAYER_CHOSEN_TITLE)))
diff --git a/src/server/scripts/EasternKingdoms/MagistersTerrace/boss_vexallus.cpp b/src/server/scripts/EasternKingdoms/MagistersTerrace/boss_vexallus.cpp
index 8bd6650b1ad..e0963b46057 100644
--- a/src/server/scripts/EasternKingdoms/MagistersTerrace/boss_vexallus.cpp
+++ b/src/server/scripts/EasternKingdoms/MagistersTerrace/boss_vexallus.cpp
@@ -203,7 +203,7 @@ class npc_pure_energy : public CreatureScript
         {
             npc_pure_energyAI(Creature* creature) : ScriptedAI(creature)
             {
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
             }
 
             void JustDied(Unit* killer) override
diff --git a/src/server/scripts/EasternKingdoms/ScarletEnclave/chapter1.cpp b/src/server/scripts/EasternKingdoms/ScarletEnclave/chapter1.cpp
index 9c1ff991279..c69a3287134 100644
--- a/src/server/scripts/EasternKingdoms/ScarletEnclave/chapter1.cpp
+++ b/src/server/scripts/EasternKingdoms/ScarletEnclave/chapter1.cpp
@@ -370,7 +370,7 @@ class npc_eye_of_acherus : public CreatureScript
         {
             npc_eye_of_acherusAI(Creature* creature) : ScriptedAI(creature)
             {
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid1);
+                me->SetDisplayFromModel(0);
                 if (Player* owner = me->GetCharmerOrOwner()->ToPlayer())
                 {
                     me->GetCharmInfo()->InitPossessCreateSpells();
@@ -1023,7 +1023,7 @@ class npc_scarlet_miner_cart : public CreatureScript
         {
             npc_scarlet_miner_cartAI(Creature* creature) : PassiveAI(creature)
             {
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid1); // Modelid2 is a horse.
+                me->SetDisplayFromModel(0); // Modelid2
             }
 
             void JustSummoned(Creature* summon) override
diff --git a/src/server/scripts/EasternKingdoms/SunwellPlateau/boss_muru.cpp b/src/server/scripts/EasternKingdoms/SunwellPlateau/boss_muru.cpp
index 33c745c63c2..e36fb0ac437 100644
--- a/src/server/scripts/EasternKingdoms/SunwellPlateau/boss_muru.cpp
+++ b/src/server/scripts/EasternKingdoms/SunwellPlateau/boss_muru.cpp
@@ -402,7 +402,7 @@ public:
 
         void Initialize()
         {
-            me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+            me->SetDisplayFromModel(1);
             me->SetReactState(REACT_PASSIVE);
             DoCast(me, SPELL_DARKFIEND_SKIN, true);
 
diff --git a/src/server/scripts/EasternKingdoms/ZulAman/zulaman.cpp b/src/server/scripts/EasternKingdoms/ZulAman/zulaman.cpp
index fca2d98002a..4822c5138e5 100644
--- a/src/server/scripts/EasternKingdoms/ZulAman/zulaman.cpp
+++ b/src/server/scripts/EasternKingdoms/ZulAman/zulaman.cpp
@@ -91,7 +91,7 @@ class npc_voljin_zulaman : public CreatureScript
         {
             npc_voljin_zulamanAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript())
             {
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid1);
+                me->SetDisplayFromModel(0);
                 if (_instance->GetData(DATA_ZULAMAN_STATE) == NOT_STARTED)
                     me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
             }
diff --git a/src/server/scripts/EasternKingdoms/zone_redridge_mountains.cpp b/src/server/scripts/EasternKingdoms/zone_redridge_mountains.cpp
index d437ec8dba9..82282ed3613 100644
--- a/src/server/scripts/EasternKingdoms/zone_redridge_mountains.cpp
+++ b/src/server/scripts/EasternKingdoms/zone_redridge_mountains.cpp
@@ -324,7 +324,6 @@ public:
         {
             _events.Reset();
             _events.ScheduleEvent(EVENT_DETERMINE_EVENT, Seconds(2));
-            me->SetDisplayId(me->GetCreatureTemplate()->GetRandomValidModelId());
         }
 
         void UpdateAI(uint32 diff) override
diff --git a/src/server/scripts/Kalimdor/zone_bloodmyst_isle.cpp b/src/server/scripts/Kalimdor/zone_bloodmyst_isle.cpp
index 705c82b799b..8e5dc67299e 100644
--- a/src/server/scripts/Kalimdor/zone_bloodmyst_isle.cpp
+++ b/src/server/scripts/Kalimdor/zone_bloodmyst_isle.cpp
@@ -248,7 +248,7 @@ public:
         void Reset() override
         {
             _events.Reset();
-            me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+            me->SetDisplayFromModel(1);
         }
 
         void EnterCombat(Unit* /*who*/) override
diff --git a/src/server/scripts/Northrend/AzjolNerub/Ahnkahet/boss_amanitar.cpp b/src/server/scripts/Northrend/AzjolNerub/Ahnkahet/boss_amanitar.cpp
index 934143da40e..69f6d3ce2c1 100644
--- a/src/server/scripts/Northrend/AzjolNerub/Ahnkahet/boss_amanitar.cpp
+++ b/src/server/scripts/Northrend/AzjolNerub/Ahnkahet/boss_amanitar.cpp
@@ -173,7 +173,7 @@ public:
             events.Reset();
             events.ScheduleEvent(EVENT_AURA, 1 * IN_MILLISECONDS);
 
-            me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+            me->SetDisplayFromModel(1);
             DoCast(SPELL_PUTRID_MUSHROOM);
 
             if (me->GetEntry() == NPC_POISONOUS_MUSHROOM)
diff --git a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_anubarak_trial.cpp b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_anubarak_trial.cpp
index ce900cef73c..2be65088628 100644
--- a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_anubarak_trial.cpp
+++ b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_anubarak_trial.cpp
@@ -254,10 +254,10 @@ class boss_anubarak_trial : public CreatureScript
                         _burrowGUID.push_back(summoned->GetGUID());
                         summoned->SetReactState(REACT_PASSIVE);
                         summoned->CastSpell(summoned, SPELL_CHURNING_GROUND, false);
-                        summoned->SetDisplayId(summoned->GetCreatureTemplate()->Modelid2);
+                        summoned->SetDisplayFromModel(1);
                         break;
                     case NPC_SPIKE:
-                        summoned->SetDisplayId(summoned->GetCreatureTemplate()->Modelid1);
+                        summoned->SetDisplayFromModel(0);
                         if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true))
                         {
                             summoned->CombatStart(target);
@@ -620,7 +620,7 @@ class npc_frost_sphere : public CreatureScript
             {
                 me->SetReactState(REACT_PASSIVE);
                 DoCast(SPELL_FROST_SPHERE);
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
                 me->GetMotionMaster()->MoveRandom(20.0f);
             }
 
diff --git a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_northrend_beasts.cpp b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_northrend_beasts.cpp
index 8cb3f23d346..165e15c61c4 100644
--- a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_northrend_beasts.cpp
+++ b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_northrend_beasts.cpp
@@ -489,7 +489,7 @@ class npc_firebomb : public CreatureScript
                 DoCast(me, SPELL_FIRE_BOMB_DOT, true);
                 SetCombatMovement(false);
                 me->SetReactState(REACT_PASSIVE);
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
             }
 
             void UpdateAI(uint32 /*diff*/) override
diff --git a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/trial_of_the_crusader.cpp b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/trial_of_the_crusader.cpp
index b147ce86fcc..9dde78ac1e2 100644
--- a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/trial_of_the_crusader.cpp
+++ b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/trial_of_the_crusader.cpp
@@ -306,7 +306,7 @@ class boss_lich_king_toc : public CreatureScript
                 if (Creature* summoned = me->SummonCreature(NPC_TRIGGER, ToCCommonLoc[2].GetPositionX(), ToCCommonLoc[2].GetPositionY(), ToCCommonLoc[2].GetPositionZ(), 5, TEMPSUMMON_TIMED_DESPAWN, 1*MINUTE*IN_MILLISECONDS))
                 {
                     summoned->CastSpell(summoned, 51807, false);
-                    summoned->SetDisplayId(summoned->GetCreatureTemplate()->Modelid2);
+                    summoned->SetDisplayFromModel(1);
                 }
 
                 _instance->SetBossState(BOSS_LICH_KING, IN_PROGRESS);
@@ -497,11 +497,11 @@ class npc_fizzlebang_toc : public CreatureScript
                             me->GetMotionMaster()->MovementExpired();
                             Talk(SAY_STAGE_1_03);
                             me->HandleEmoteCommand(EMOTE_ONESHOT_SPELL_CAST_OMNI);
-                            if (Unit* pTrigger =  me->SummonCreature(NPC_TRIGGER, ToCCommonLoc[1].GetPositionX(), ToCCommonLoc[1].GetPositionY(), ToCCommonLoc[1].GetPositionZ(), 4.69494f, TEMPSUMMON_MANUAL_DESPAWN))
+                            if (Creature* pTrigger = me->SummonCreature(NPC_TRIGGER, ToCCommonLoc[1].GetPositionX(), ToCCommonLoc[1].GetPositionY(), ToCCommonLoc[1].GetPositionZ(), 4.69494f, TEMPSUMMON_MANUAL_DESPAWN))
                             {
                                 _triggerGUID = pTrigger->GetGUID();
                                 pTrigger->SetObjectScale(2.0f);
-                                pTrigger->SetDisplayId(pTrigger->ToCreature()->GetCreatureTemplate()->Modelid1);
+                                pTrigger->SetDisplayFromModel(0);
                                 pTrigger->CastSpell(pTrigger, SPELL_WILFRED_PORTAL, false);
                             }
                             _instance->SetData(TYPE_EVENT, 1132);
diff --git a/src/server/scripts/Northrend/FrozenHalls/HallsOfReflection/halls_of_reflection.cpp b/src/server/scripts/Northrend/FrozenHalls/HallsOfReflection/halls_of_reflection.cpp
index ab78e9a3cea..612d4b9316f 100644
--- a/src/server/scripts/Northrend/FrozenHalls/HallsOfReflection/halls_of_reflection.cpp
+++ b/src/server/scripts/Northrend/FrozenHalls/HallsOfReflection/halls_of_reflection.cpp
@@ -2587,7 +2587,7 @@ class npc_quel_delar_sword : public CreatureScript
             npc_quel_delar_swordAI(Creature* creature) : ScriptedAI(creature)
             {
                 _instance = me->GetInstanceScript();
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
                 _intro = true;
             }
 
diff --git a/src/server/scripts/Northrend/FrozenHalls/PitOfSaron/pit_of_saron.cpp b/src/server/scripts/Northrend/FrozenHalls/PitOfSaron/pit_of_saron.cpp
index 1290d417189..a73a3a2fa0d 100644
--- a/src/server/scripts/Northrend/FrozenHalls/PitOfSaron/pit_of_saron.cpp
+++ b/src/server/scripts/Northrend/FrozenHalls/PitOfSaron/pit_of_saron.cpp
@@ -272,7 +272,7 @@ class npc_pit_of_saron_icicle : public CreatureScript
         {
             npc_pit_of_saron_icicleAI(Creature* creature) : PassiveAI(creature)
             {
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid1);
+                me->SetDisplayFromModel(0);
             }
 
             void IsSummonedBy(Unit* summoner) override
diff --git a/src/server/scripts/Northrend/Naxxramas/boss_sapphiron.cpp b/src/server/scripts/Northrend/Naxxramas/boss_sapphiron.cpp
index 4acf2099f51..e869ee3e6c1 100644
--- a/src/server/scripts/Northrend/Naxxramas/boss_sapphiron.cpp
+++ b/src/server/scripts/Northrend/Naxxramas/boss_sapphiron.cpp
@@ -173,7 +173,7 @@ class boss_sapphiron : public CreatureScript
                 switch(spell->Id)
                 {
                     case SPELL_CHECK_RESISTS:
-                        if (target && target->GetResistance(SPELL_SCHOOL_FROST) > MAX_FROST_RESISTANCE)
+                        if (target && target->GetResistance(SPELL_SCHOOL_MASK_FROST) > MAX_FROST_RESISTANCE)
                             _canTheHundredClub = false;
                         break;
                 }
diff --git a/src/server/scripts/Northrend/Nexus/Nexus/boss_anomalus.cpp b/src/server/scripts/Northrend/Nexus/Nexus/boss_anomalus.cpp
index c4982c126f0..99513317306 100644
--- a/src/server/scripts/Northrend/Nexus/Nexus/boss_anomalus.cpp
+++ b/src/server/scripts/Northrend/Nexus/Nexus/boss_anomalus.cpp
@@ -224,7 +224,7 @@ class npc_chaotic_rift : public CreatureScript
             void Reset() override
             {
                 Initialize();
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
                 DoCast(me, SPELL_ARCANEFORM, false);
             }
 
diff --git a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_flame_leviathan.cpp b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_flame_leviathan.cpp
index 93f1f515409..7ca0d014c8a 100644
--- a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_flame_leviathan.cpp
+++ b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_flame_leviathan.cpp
@@ -586,7 +586,7 @@ class boss_flame_leviathan_seat : public CreatureScript
             boss_flame_leviathan_seatAI(Creature* creature) : ScriptedAI(creature)
             {
                 me->SetReactState(REACT_PASSIVE);
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
                 instance = creature->GetInstanceScript();
             }
 
diff --git a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_hodir.cpp b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_hodir.cpp
index 5a85d720eea..fbcca717df6 100644
--- a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_hodir.cpp
+++ b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_hodir.cpp
@@ -188,7 +188,7 @@ class npc_flash_freeze : public CreatureScript
             {
                 Initialize();
                 instance = me->GetInstanceScript();
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
                 me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED | UNIT_FLAG_PACIFIED);
                 me->SetControlled(true, UNIT_STATE_ROOT);
             }
@@ -264,7 +264,7 @@ class npc_ice_block : public CreatureScript
             npc_ice_blockAI(Creature* creature) : ScriptedAI(creature)
             {
                 instance = me->GetInstanceScript();
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
                 me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED | UNIT_FLAG_PACIFIED);
                 me->SetControlled(true, UNIT_STATE_ROOT);
             }
@@ -557,7 +557,7 @@ class npc_icicle : public CreatureScript
             npc_icicleAI(Creature* creature) : ScriptedAI(creature)
             {
                 Initialize();
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid1);
+                me->SetDisplayFromModel(0);
                 me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_PACIFIED | UNIT_FLAG_NOT_SELECTABLE);
                 me->SetControlled(true, UNIT_STATE_ROOT);
                 me->SetReactState(REACT_PASSIVE);
@@ -612,7 +612,7 @@ class npc_snowpacked_icicle : public CreatureScript
             npc_snowpacked_icicleAI(Creature* creature) : ScriptedAI(creature)
             {
                 Initialize();
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
                 me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_PACIFIED);
                 me->SetControlled(true, UNIT_STATE_ROOT);
                 me->SetReactState(REACT_PASSIVE);
@@ -954,7 +954,7 @@ class npc_toasty_fire : public CreatureScript
         {
             npc_toasty_fireAI(Creature* creature) : ScriptedAI(creature)
             {
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
             }
 
             void Reset() override
diff --git a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_razorscale.cpp b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_razorscale.cpp
index cc1c3219bca..4a1a41bcbf6 100644
--- a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_razorscale.cpp
+++ b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_razorscale.cpp
@@ -193,7 +193,7 @@ class boss_razorscale_controller : public CreatureScript
         {
             boss_razorscale_controllerAI(Creature* creature) : BossAI(creature, DATA_RAZORSCALE_CONTROL)
             {
-                me->SetDisplayId(me->GetCreatureTemplate()->Modelid2);
+                me->SetDisplayFromModel(1);
             }
 
             void Reset() override
diff --git a/src/server/scripts/Outland/TempestKeep/Eye/boss_astromancer.cpp b/src/server/scripts/Outland/TempestKeep/Eye/boss_astromancer.cpp
index a1376de652f..8649c4c1601 100644
--- a/src/server/scripts/Outland/TempestKeep/Eye/boss_astromancer.cpp
+++ b/src/server/scripts/Outland/TempestKeep/Eye/boss_astromancer.cpp
@@ -150,7 +150,7 @@ class boss_high_astromancer_solarian : public CreatureScript
             {
                 Initialize();
                 _Reset();
-                me->SetArmor(defaultarmor);
+                me->SetArmor(defaultarmor, 0);
                 me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                 me->SetVisible(true);
                 me->SetObjectScale(defaultsize);
@@ -403,7 +403,7 @@ class boss_high_astromancer_solarian : public CreatureScript
                     me->SetVisible(true);
                     Talk(SAY_VOIDA);
                     Talk(SAY_VOIDB);
-                    me->SetArmor(WV_ARMOR);
+                    me->SetArmor(WV_ARMOR, 0);
                     me->SetDisplayId(MODEL_VOIDWALKER);
                     me->SetObjectScale(defaultsize*2.5f);
                 }
diff --git a/src/server/scripts/Spells/spell_pet.cpp b/src/server/scripts/Spells/spell_pet.cpp
index 81bfe4fcd0c..5e46c2dfda4 100644
--- a/src/server/scripts/Spells/spell_pet.cpp
+++ b/src/server/scripts/Spells/spell_pet.cpp
@@ -300,8 +300,8 @@ public:
 
                 if (Unit* owner = pet->ToPet()->GetOwner())
                 {
-                    int32 fire  = owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE) - owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);
-                    int32 shadow = owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW) - owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_SHADOW);
+                    int32 fire  = owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE) - owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);
+                    int32 shadow = owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW) - owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_SHADOW);
                     int32 maximum  = (fire > shadow) ? fire : shadow;
                     if (maximum < 0)
                         maximum = 0;
@@ -328,8 +328,8 @@ public:
                     if (Unit* owner = pet->ToPet()->GetOwner())
                     {
                         //the damage bonus used for pets is either fire or shadow damage, whatever is higher
-                        int32 fire  = owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE) - owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);
-                        int32 shadow = owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW) - owner->GetInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_SHADOW);
+                        int32 fire  = owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_FIRE) - owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_FIRE);
+                        int32 shadow = owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_POS + SPELL_SCHOOL_SHADOW) - owner->GetInt32Value(ACTIVE_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG + SPELL_SCHOOL_SHADOW);
                         int32 maximum  = (fire > shadow) ? fire : shadow;
                         float bonusDamage = 0.0f;
 
@@ -450,7 +450,7 @@ public:
                 if (pet->IsPet())
                     if (Unit* owner = pet->ToPet()->GetOwner())
                     {
-                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_FIRE), 40);
+                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_FIRE), 40);
                         amount += ownerBonus;
                     }
         }
@@ -496,7 +496,7 @@ public:
                 if (pet->IsPet())
                     if (Unit* owner = pet->ToPet()->GetOwner())
                     {
-                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_FROST), 40);
+                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_FROST), 40);
                         amount += ownerBonus;
                     }
         }
@@ -507,7 +507,7 @@ public:
                 if (pet->IsPet())
                     if (Unit* owner = pet->ToPet()->GetOwner())
                     {
-                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_ARCANE), 40);
+                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_ARCANE), 40);
                         amount += ownerBonus;
                     }
         }
@@ -518,7 +518,7 @@ public:
                 if (pet->IsPet())
                     if (Unit* owner = pet->ToPet()->GetOwner())
                     {
-                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_NATURE), 40);
+                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_NATURE), 40);
                         amount += ownerBonus;
                     }
         }
@@ -559,7 +559,7 @@ public:
                 if (pet->IsPet())
                     if (Unit* owner = pet->ToPet()->GetOwner())
                     {
-                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_SHADOW), 40);
+                        int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_SHADOW), 40);
                         amount += ownerBonus;
                     }
         }
@@ -1025,7 +1025,7 @@ public:
                 if (!owner)
                     return;
 
-                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_FROST), 40);
+                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_FROST), 40);
                 amount += ownerBonus;
             }
         }
@@ -1041,7 +1041,7 @@ public:
                 if (!owner)
                     return;
 
-                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_FIRE), 40);
+                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_FIRE), 40);
                 amount += ownerBonus;
             }
         }
@@ -1057,7 +1057,7 @@ public:
                 if (!owner)
                     return;
 
-                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_NATURE), 40);
+                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_NATURE), 40);
                 amount += ownerBonus;
             }
         }
@@ -1103,7 +1103,7 @@ public:
                 if (!owner)
                     return;
 
-                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_SHADOW), 40);
+                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_SHADOW), 40);
                 amount += ownerBonus;
             }
         }
@@ -1119,7 +1119,7 @@ public:
                 if (!owner)
                     return;
 
-                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_ARCANE), 40);
+                int32 const ownerBonus = CalculatePct(owner->GetResistance(SPELL_SCHOOL_MASK_ARCANE), 40);
                 amount += ownerBonus;
             }
         }
diff --git a/src/server/scripts/World/npcs_special.cpp b/src/server/scripts/World/npcs_special.cpp
index 8b8e47245e0..e0c648bcfc4 100644
--- a/src/server/scripts/World/npcs_special.cpp
+++ b/src/server/scripts/World/npcs_special.cpp
@@ -2606,8 +2606,8 @@ public:
             init.SetFacing(o);
             init.Launch();
             who->m_Events.AddEvent(new CastFoodSpell(who, _chairSpells.at(who->GetEntry())), who->m_Events.CalculateTime(1000));
-            if (who->GetTypeId() == TYPEID_UNIT)
-                who->SetDisplayId(who->ToCreature()->GetCreatureTemplate()->Modelid1);
+            if (Creature* creature = who->ToCreature())
+                creature->SetDisplayFromModel(0);
         }
     };
 
diff --git a/src/server/shared/DataStores/DB2DatabaseLoader.cpp b/src/server/shared/DataStores/DB2DatabaseLoader.cpp
index 3619920c0c0..ec99537c066 100644
--- a/src/server/shared/DataStores/DB2DatabaseLoader.cpp
+++ b/src/server/shared/DataStores/DB2DatabaseLoader.cpp
@@ -112,7 +112,7 @@ char* DB2DatabaseLoader::Load(uint32& records, char**& indexTable, char*& string
 
         for (uint32 x = 0; x < _loadInfo->Meta->FieldCount; ++x)
         {
-            for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z)
+            for (uint32 z = 0; z < _loadInfo->Meta->Fields[x].ArraySize; ++z)
             {
                 switch (_loadInfo->TypesString[f])
                 {
@@ -165,7 +165,8 @@ char* DB2DatabaseLoader::Load(uint32& records, char**& indexTable, char*& string
                         break;
                     }
                     default:
-                        ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _storageName.c_str());
+                        ASSERT(false, "Unknown format character '%c' found in %s meta for field %s",
+                            _loadInfo->TypesString[f], _storageName.c_str(), _loadInfo->Fields[f].Name);
                         break;
                 }
                 ++f;
@@ -236,7 +237,7 @@ void DB2DatabaseLoader::LoadStrings(uint32 locale, uint32 records, char** indexT
 
             for (uint32 x = 0; x < fieldCount; ++x)
             {
-                for (uint32 z = 0; z < _loadInfo->Meta->ArraySizes[x]; ++z)
+                for (uint32 z = 0; z < _loadInfo->Meta->Fields[x].ArraySize; ++z)
                 {
                     switch (_loadInfo->TypesString[fieldIndex])
                     {
@@ -269,7 +270,8 @@ void DB2DatabaseLoader::LoadStrings(uint32 locale, uint32 records, char** indexT
                             offset += sizeof(char*);
                             break;
                         default:
-                            ASSERT(false, "Unknown format character '%c' found in %s meta", _loadInfo->TypesString[x], _storageName.c_str());
+                            ASSERT(false, "Unknown format character '%c' found in %s meta for field %s",
+                                _loadInfo->TypesString[fieldIndex], _storageName.c_str(), _loadInfo->Fields[fieldIndex].Name);
                             break;
                     }
                     ++fieldIndex;
diff --git a/src/server/shared/Packets/ByteBuffer.h b/src/server/shared/Packets/ByteBuffer.h
index fdd3667a3a6..c7009028e9c 100644
--- a/src/server/shared/Packets/ByteBuffer.h
+++ b/src/server/shared/Packets/ByteBuffer.h
@@ -123,9 +123,10 @@ class TC_SHARED_API ByteBuffer
             _storage.clear();
         }
 
-        template <typename T> void append(T value)
+        template <typename T>
+        void append(T value)
         {
-            static_assert(std::is_fundamental<T>::value, "append(compound)");
+            static_assert(std::is_trivially_copyable<T>::value, "append(T) must be used with trivially copyable types");
             EndianConvert(value);
             append((uint8 *)&value, sizeof(value));
         }
@@ -210,7 +211,7 @@ class TC_SHARED_API ByteBuffer
         template <typename T>
         void put(std::size_t pos, T value)
         {
-            static_assert(std::is_fundamental<T>::value, "append(compound)");
+            static_assert(std::is_trivially_copyable<T>::value, "put(size_t, T) must be used with trivially copyable types");
             EndianConvert(value);
             put(pos, (uint8 *)&value, sizeof(value));
         }
@@ -435,7 +436,8 @@ class TC_SHARED_API ByteBuffer
             _rpos += skip;
         }
 
-        template <typename T> T read()
+        template <typename T>
+        T read()
         {
             ResetBitPos();
             T r = read<T>(_rpos);
@@ -443,7 +445,8 @@ class TC_SHARED_API ByteBuffer
             return r;
         }
 
-        template <typename T> T read(size_t pos) const
+        template <typename T>
+        T read(size_t pos) const
         {
             if (pos + sizeof(T) > size())
                 throw ByteBufferPositionException(pos, sizeof(T), size());
@@ -452,6 +455,13 @@ class TC_SHARED_API ByteBuffer
             return val;
         }
 
+        template<class T>
+        void read(T* dest, size_t count)
+        {
+            static_assert(std::is_trivially_copyable<T>::value, "read(T*, size_t) must be used with trivially copyable types");
+            return read(reinterpret_cast<uint8*>(dest), count * sizeof(T));
+        }
+
         void read(uint8 *dest, size_t len)
         {
             if (_rpos + len > size())
@@ -540,7 +550,8 @@ class TC_SHARED_API ByteBuffer
             return append((const uint8 *)src, cnt);
         }
 
-        template<class T> void append(const T *src, size_t cnt)
+        template<class T>
+        void append(const T *src, size_t cnt)
         {
             return append((const uint8 *)src, cnt * sizeof(T));
         }
diff --git a/src/server/worldserver/worldserver.conf.dist b/src/server/worldserver/worldserver.conf.dist
index 61a0df25d5a..8c9fc12ea18 100644
--- a/src/server/worldserver/worldserver.conf.dist
+++ b/src/server/worldserver/worldserver.conf.dist
@@ -671,7 +671,8 @@ DeclinedNames = 0
 #    Expansion
 #        Description: Allow server to use content from expansions. Checks for expansion-related
 #                     map files, client compatibility and class/race character creation.
-#        Default:     6 - (Expansion 6)
+#        Default:     7 - (Expansion 7)
+#                     6 - (Expansion 6)
 #                     5 - (Expansion 5)
 #                     4 - (Expansion 4)
 #                     3 - (Expansion 3)
@@ -679,7 +680,7 @@ DeclinedNames = 0
 #                     1 - (Expansion 1)
 #                     0 - (Disabled, Ignore and disable expansion content (maps, races, classes)
 
-Expansion = 6
+Expansion = 7
 
 #
 #    MinPlayerName
@@ -830,9 +831,9 @@ SkipCinematics = 0
 #        Description: Maximum level that can be reached by players.
 #        Important:   Levels beyond 110 are not recommended at all.
 #        Range:       1-255
-#        Default:     110
+#        Default:     120
 
-MaxPlayerLevel = 110
+MaxPlayerLevel = 120
 
 #
 #    MinDualSpecLevel
@@ -3956,14 +3957,6 @@ Currency.StartJusticePoints = 0
 Currency.MaxJusticePoints = 4000
 
 #
-#    Currency.StartArtifactKnowledge
-#        Amount artifact knowledge that new players will start with
-#        Default: 55 (max)
-#
-
-Currency.StartArtifactKnowledge = 55
-
-#
 ###################################################################################################
 
 ###################################################################################################
diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt
index 535a63f7ab5..608a0e82020 100644
--- a/src/tools/CMakeLists.txt
+++ b/src/tools/CMakeLists.txt
@@ -8,7 +8,6 @@
 # WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-add_subdirectory(connection_patcher)
 add_subdirectory(extractor_common)
 add_subdirectory(map_extractor)
 add_subdirectory(vmap4_assembler)
diff --git a/src/tools/connection_patcher/CMakeLists.txt b/src/tools/connection_patcher/CMakeLists.txt
deleted file mode 100644
index 67fd67d8278..00000000000
--- a/src/tools/connection_patcher/CMakeLists.txt
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
-#
-# This file is free software; as a special exception the author gives
-# unlimited permission to copy and/or distribute it, with or without
-# modifications, as long as this notice is preserved.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-CollectSourceFiles(${CMAKE_CURRENT_SOURCE_DIR} PRIVATE_SOURCES)
-
-if (WIN32)
-  list(APPEND PRIVATE_SOURCES ${sources_windows})
-endif()
-
-GroupSources(${CMAKE_CURRENT_SOURCE_DIR})
-
-add_executable(connection_patcher ${PRIVATE_SOURCES})
-
-target_link_libraries(connection_patcher
-  PRIVATE
-    trinity-core-interface
-  PUBLIC
-    common
-)
-
-if (UNIX)
-  install(TARGETS connection_patcher DESTINATION bin)
-elseif (WIN32)
-  install(TARGETS connection_patcher DESTINATION "${CMAKE_INSTALL_PREFIX}")
-endif ()
diff --git a/src/tools/connection_patcher/Constants/BinaryTypes.hpp b/src/tools/connection_patcher/Constants/BinaryTypes.hpp
deleted file mode 100644
index 98695503341..00000000000
--- a/src/tools/connection_patcher/Constants/BinaryTypes.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CONNECTION_PATCHER_CONSTANTS_BINARYTYPES_HPP
-#define CONNECTION_PATCHER_CONSTANTS_BINARYTYPES_HPP
-
-#include <cstdint>
-
-namespace Connection_Patcher
-{
-    namespace Constants
-    {
-        enum class BinaryTypes : uint32_t
-        {
-            Pe32   = 0x0000014C,
-            Pe64   = 0x00008664,
-            Mach64 = 0xFEEDFACF
-        };
-    }
-}
-
-#endif
diff --git a/src/tools/connection_patcher/Helper.cpp b/src/tools/connection_patcher/Helper.cpp
deleted file mode 100644
index 6a4f0d0f07d..00000000000
--- a/src/tools/connection_patcher/Helper.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "Helper.hpp"
-#include "Patterns/Common.hpp"
-
-namespace Connection_Patcher
-{
-    namespace Helper
-    {
-        // adapted from http://stackoverflow.com/questions/8593608/how-can-i-copy-a-directory-using-boost-filesystem
-        void CopyDir(boost::filesystem::path const & source, boost::filesystem::path const & destination)
-        {
-            namespace fs = boost::filesystem;
-            if (!fs::exists(source) || !fs::is_directory(source))
-                throw std::invalid_argument("Source directory " + source.string() + " does not exist or is not a directory.");
-
-            if (fs::exists(destination))
-                throw std::invalid_argument("Destination directory " + destination.string() + " already exists.");
-
-            if (!fs::create_directory(destination))
-                throw std::runtime_error("Unable to create destination directory" + destination.string());
-
-            for (fs::directory_iterator file(source); file != fs::directory_iterator(); ++file)
-            {
-                fs::path current(file->path());
-                if (fs::is_directory(current))
-                    CopyDir(current, destination / current.filename());
-                else
-                    fs::copy_file(current, destination / current.filename());
-            }
-        }
-
-        Constants::BinaryTypes GetBinaryType(std::vector<unsigned char> const& data)
-        {
-            // Check MS-DOS magic
-            if (*reinterpret_cast<uint16_t const*>(data.data()) == 0x5A4D)
-            {
-                uint32_t const peOffset(*reinterpret_cast<uint32_t const*>(data.data() + 0x3C));
-
-                // Check PE magic
-                if (*reinterpret_cast<uint32_t const*>(data.data() + peOffset) != 0x4550)
-                    throw std::invalid_argument("Not a PE file!");
-
-                return Constants::BinaryTypes(*reinterpret_cast<uint16_t const*>(data.data() + peOffset + 4));
-            }
-            else
-                return Constants::BinaryTypes(*reinterpret_cast<uint32_t const*>(data.data()));
-        }
-
-        std::set<size_t> SearchOffset(std::vector<unsigned char> const& binary, std::vector<unsigned char> const& pattern)
-        {
-            std::set<size_t> offsets;
-            for (size_t i = 0; (i + pattern.size()) < binary.size(); i++)
-            {
-                size_t matches = 0;
-
-                for (size_t j = 0; j < pattern.size(); j++)
-                {
-                    if (binary[i + j] != pattern[j])
-                        break;
-
-                    matches++;
-                }
-
-                if (matches == pattern.size())
-                {
-                    offsets.insert(i);
-                    i += matches;
-                }
-            }
-
-            return offsets.empty() ? throw std::runtime_error("unable to find pattern") : offsets;
-        }
-
-        uint32_t GetBuildNumber(std::vector<unsigned char> const& binary)
-        {
-            std::set<size_t> offsets = SearchOffset(binary, Patterns::Common::BinaryVersion());
-
-            if (!offsets.empty())
-            {
-                size_t const verOffset = (*offsets.begin());
-                std::string ver(&binary[verOffset + 16], &binary[verOffset + 21]);
-
-                return std::stoi(ver);
-            }
-            return 0;
-        }
-    }
-}
diff --git a/src/tools/connection_patcher/Helper.hpp b/src/tools/connection_patcher/Helper.hpp
deleted file mode 100644
index e847e911a3f..00000000000
--- a/src/tools/connection_patcher/Helper.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CONNECTION_PATCHER_HELPER_HPP
-#define CONNECTION_PATCHER_HELPER_HPP
-
-#include "Constants/BinaryTypes.hpp"
-
-#include <boost/filesystem.hpp>
-#include <vector>
-#include <set>
-
-namespace Connection_Patcher
-{
-    namespace Helper
-    {
-        void CopyDir(boost::filesystem::path const & source, boost::filesystem::path const & destination);
-        Constants::BinaryTypes GetBinaryType(std::vector<unsigned char> const& data);
-        std::set<size_t> SearchOffset(std::vector<unsigned char> const& binary, std::vector<unsigned char> const& pattern);
-        uint32_t GetBuildNumber(std::vector<unsigned char> const& binary);
-    }
-}
-
-#endif
diff --git a/src/tools/connection_patcher/Patcher.cpp b/src/tools/connection_patcher/Patcher.cpp
deleted file mode 100644
index 78fb87bd3ea..00000000000
--- a/src/tools/connection_patcher/Patcher.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * asize_t with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "Patcher.hpp"
-
-namespace Connection_Patcher
-{
-    Patcher::Patcher(boost::filesystem::path file)
-        : filePath(file)
-    {
-        ReadFile();
-        binaryType = Helper::GetBinaryType(binary);
-    }
-
-    void Patcher::ReadFile()
-    {
-        std::ifstream ifs(filePath.string(), std::ifstream::binary);
-        if (!ifs)
-            throw std::runtime_error("could not open " + filePath.string());
-
-        binary.clear();
-        ifs >> std::noskipws;
-        ifs.seekg(0, std::ios_base::end);
-        binary.reserve(ifs.tellg());
-        ifs.seekg(0, std::ios_base::beg);
-
-        std::copy(std::istream_iterator<unsigned char>(ifs), std::istream_iterator<unsigned char>(), std::back_inserter(binary));
-    }
-
-    void Patcher::WriteFile(boost::filesystem::path const& path)
-    {
-        std::ofstream ofs(path.string(), std::ofstream::binary);
-        if (!ofs)
-            throw std::runtime_error("could not open " + path.string());
-
-        ofs << std::noskipws;
-
-        std::copy(binary.begin(), binary.end(), std::ostream_iterator<unsigned char>(ofs));
-    }
-
-    void Patcher::Patch(std::vector<unsigned char> const& bytes, std::vector<unsigned char> const& pattern)
-    {
-        if (binary.size() < pattern.size())
-            throw std::logic_error("pattern larger than binary");
-
-        if (pattern.empty())
-            return;
-
-        for (size_t const offset : Helper::SearchOffset(binary, pattern))
-        {
-            std::cout << "Found offset " << offset << std::endl;
-
-            if (offset != 0 && binary.size() >= bytes.size())
-                for (size_t i = 0; i < bytes.size(); i++)
-                    binary[offset + i] = bytes[i];
-        }
-    }
-
-    void Patcher::Finish(boost::filesystem::path out)
-    {
-        if (boost::filesystem::exists(out))
-            boost::filesystem::remove(out);
-
-        WriteFile(out);
-    }
-}
diff --git a/src/tools/connection_patcher/Patcher.hpp b/src/tools/connection_patcher/Patcher.hpp
deleted file mode 100644
index 0dbc2a10f22..00000000000
--- a/src/tools/connection_patcher/Patcher.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CONNECTION_PATCHER_PATCHER_HPP
-#define CONNECTION_PATCHER_PATCHER_HPP
-
-#include "Helper.hpp"
-
-#include <fstream>
-#include <iostream>
-#include <iterator>
-
-namespace Connection_Patcher
-{
-    class Patcher
-    {
-    public:
-        Patcher(boost::filesystem::path file);
-
-        void Patch(std::vector<unsigned char> const& bytes, std::vector<unsigned char> const& pattern);
-        void Finish(boost::filesystem::path out);
-        Constants::BinaryTypes GetType() const { return binaryType; }
-        std::vector<unsigned char> const& GetBinary() const { return binary; }
-
-    private:
-        void ReadFile();
-        void WriteFile(boost::filesystem::path const& path);
-
-        boost::filesystem::path filePath;
-        std::vector<unsigned char> binary;
-        Constants::BinaryTypes binaryType;
-
-
-    };
-}
-
-#endif
diff --git a/src/tools/connection_patcher/Patches/Common.hpp b/src/tools/connection_patcher/Patches/Common.hpp
deleted file mode 100644
index 1521c20befb..00000000000
--- a/src/tools/connection_patcher/Patches/Common.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CONNECTION_PATCHER_PATCHES_COMMON_HPP
-#define CONNECTION_PATCHER_PATCHES_COMMON_HPP
-
-#include <vector>
-
-namespace Connection_Patcher
-{
-    namespace Patches
-    {
-        struct Common
-        {
-            static std::vector<unsigned char> Portal() { return { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; }
-            static std::vector<unsigned char> Modulus()
-            {
-                return
-                {
-                    0x5F, 0xD6, 0x80, 0x0B, 0xA7, 0xFF, 0x01, 0x40, 0xC7, 0xBC, 0x8E, 0xF5, 0x6B, 0x27, 0xB0, 0xBF,
-                    0xF0, 0x1D, 0x1B, 0xFE, 0xDD, 0x0B, 0x1F, 0x3D, 0xB6, 0x6F, 0x1A, 0x48, 0x0D, 0xFB, 0x51, 0x08,
-                    0x65, 0x58, 0x4F, 0xDB, 0x5C, 0x6E, 0xCF, 0x64, 0xCB, 0xC1, 0x6B, 0x2E, 0xB8, 0x0F, 0x5D, 0x08,
-                    0x5D, 0x89, 0x06, 0xA9, 0x77, 0x8B, 0x9E, 0xAA, 0x04, 0xB0, 0x83, 0x10, 0xE2, 0x15, 0x4D, 0x08,
-                    0x77, 0xD4, 0x7A, 0x0E, 0x5A, 0xB0, 0xBB, 0x00, 0x61, 0xD7, 0xA6, 0x75, 0xDF, 0x06, 0x64, 0x88,
-                    0xBB, 0xB9, 0xCA, 0xB0, 0x18, 0x8B, 0x54, 0x13, 0xE2, 0xCB, 0x33, 0xDF, 0x17, 0xD8, 0xDA, 0xA9,
-                    0xA5, 0x60, 0xA3, 0x1F, 0x4E, 0x27, 0x05, 0x98, 0x6F, 0xAA, 0xEE, 0x14, 0x3B, 0xF3, 0x97, 0xA8,
-                    0x12, 0x02, 0x94, 0x0D, 0x84, 0xDC, 0x0E, 0xF1, 0x76, 0x23, 0x95, 0x36, 0x13, 0xF9, 0xA9, 0xC5,
-                    0x48, 0xDB, 0xDA, 0x86, 0xBE, 0x29, 0x22, 0x54, 0x44, 0x9D, 0x9F, 0x80, 0x7B, 0x07, 0x80, 0x30,
-                    0xEA, 0xD2, 0x83, 0xCC, 0xCE, 0x37, 0xD1, 0xD1, 0xCF, 0x85, 0xBE, 0x91, 0x25, 0xCE, 0xC0, 0xCC,
-                    0x55, 0xC8, 0xC0, 0xFB, 0x38, 0xC5, 0x49, 0x03, 0x6A, 0x02, 0xA9, 0x9F, 0x9F, 0x86, 0xFB, 0xC7,
-                    0xCB, 0xC6, 0xA5, 0x82, 0xA2, 0x30, 0xC2, 0xAC, 0xE6, 0x98, 0xDA, 0x83, 0x64, 0x43, 0x7F, 0x0D,
-                    0x13, 0x18, 0xEB, 0x90, 0x53, 0x5B, 0x37, 0x6B, 0xE6, 0x0D, 0x80, 0x1E, 0xEF, 0xED, 0xC7, 0xB8,
-                    0x68, 0x9B, 0x4C, 0x09, 0x7B, 0x60, 0xB2, 0x57, 0xD8, 0x59, 0x8D, 0x7F, 0xEA, 0xCD, 0xEB, 0xC4,
-                    0x60, 0x9F, 0x45, 0x7A, 0xA9, 0x26, 0x8A, 0x2F, 0x85, 0x0C, 0xF2, 0x19, 0xC6, 0x53, 0x92, 0xF7,
-                    0xF0, 0xB8, 0x32, 0xCB, 0x5B, 0x66, 0xCE, 0x51, 0x54, 0xB4, 0xC3, 0xD3, 0xD4, 0xDC, 0xB3, 0xEE
-                };
-            }
-            static std::string VersionsFile() { return "trinity6.github.io/%s/%s/build/versi"; };
-            static std::vector<unsigned char> CertBundleUrl() { return { 'h', 't', 't', 'p', 's', ':', '/', '/', 't', 'r', 'i', 'n', 'i', 't', 'y', '6', '.', 'g', 'i', 't', 'h', 'u', 'b', '.', 'i', 'o', '/', 'B', 'n', 'e', 't', '/', 'z', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', '/', 'c', 'l', 'i', 'e', 'n', 't', '/', 'b', 'g', 's', '-', 'k', 'e', 'y', '-', 'f', 'i', 'n', 'g', 'e', 'r', 'p', 'r', 'i', 'n', 't' }; }
-            static std::string CertificateBundle()
-            {
-                return
-R"({
-    "Created": 1455065214,
-    "Certificates": [
-        { "Uri": "*.*", "ShaHashPublicKeyInfo": "B1241D831999D4A67B0C6F9A687331C87FBA9B2CDC4CAC3694ADAD622F01952B" }
-    ],
-    "PublicKeys": [
-        { "Uri": "*.*", "ShaHashPublicKeyInfo": "B1241D831999D4A67B0C6F9A687331C87FBA9B2CDC4CAC3694ADAD622F01952B" }
-    ],
-    "SigningCertificates": [
-        { "RawData": "-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----" }
-    ]
-})";
-            }
-            static std::string CertificatePrivateKey()
-            {
-                return
-R"(-----BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAwN3EYmKhDGawGrh62wAgjh3wr4CcV6lp61Ev39jzTkgetXDB
-F2SWC9s/pzS/h10HQwL9P0cYlqbZHj/darOphcqplK05WsJC876lUASSeVWVPiHs
-mfpSzjx65qV2PfmcNE1SUEizOOfpaoxvLfVqh5y4MkuSxXxOXCXS9CnQBwQo8f/4
-uV6czHZgigi7CSID75VK3VhqvlTaLYFoEiOpjWNAQ7x/18sv+VoSVuX+alYez2PD
-wU+hl0CpzEIqtaavntce9sQ3uEd3eXYGAJp6X+bOVItRmUhb3WXoIXmHMaLe5oSc
-cINa17ZL7H2ISOqr/1Pfq84Ck/VStbzEfJdTZwIDAQABAoIBAHcu1DQERQd30a3B
-gNIi4vtPzzN1I6gcXgL3+cC3vasLcEapdflxxDNxeoVmWFFbEKi9iSf4VF6MnrFN
-wBM3ETRHh8IDxeSrFVqw3lFzcdyfIYnyxtZkVZVy1HQBne8wd/HuMkbAllg9IAYi
-4HWjKgDBvSX/g6Sca4QQL6uIxy/9s3Z4K2vU8KbvUpwo+ON4HMt61fgrIrbEUVCl
-TMCVEf8UphwHctmQJb/Pr0+BCTdiv04ga1dkt+ZyR2o0VN6T/zKDqk4m1sSl0GZz
-8sn63GbuTlwHcm9GgkaxoeeZJK1/sdOSIZN8W3PpnyHrAZJlNOY7G684F1mBaWV1
-PGCcVtkCgYEA8jCDTGub7ZyMk48x+8L3Devja3TQz7YNIGkVEbQBpNw4gDV8j1m6
-EgqFdzowkY+gbA76ylNfm6Aa66RDR/LbTbXlsNd8YkXcbU3xDQ96F6cS51VBkled
-hq+iAuGJB9VYN5yP1P/Oswg/AFMjOnsfBL/1zFo26364z9x8zazw0wsCgYEAy907
-mpkk59AQ4YIDSR9wK2YpXv6HoBPFld6m7PAnBWFO0uNtQ0YppbYbrhmDqrxUoFud
-ZiEHIa0gLlp9lHr+UdUAMPDlJ6gbMnJW3U5qiVuuZA13tiZFlv11qUeU1tQUzTUv
-ZoIISN15Im0PQzUFbTxSFbS+vTYjsedv1C9UOpUCgYEAkTaTUzvmV3cZNtSSFLFW
-ros0Zda56QDwJ/G5x06V+cJtQjpPwCf9kBms4ssKGgzzFDd7GdsZpVc/LPDlwnsU
-ESkyWnEpzEa1HvivwrP38bykcf5Ffbh45CvkyTNvlTnPVjDScNUcm24jUE+I/OSb
-uZ5bg7bH3TWzHDbIwg2iq/cCgYB+DPqvqoVhOAtYBBWX/vJSQ0bNT7/4QIFpG1RH
-KG5YK0SbrLeAYz+ZELKowWniBbSluj/mSAGq1usQ/i6rwijB3FvT5v8puA2o8X24
-NKY27BM2FgWxAJUCuREpa/Mhqdx6zanTTg9lTlt558kKGxyR4Dw445sUTwdfFuTU
-Y7dGyQKBgAG0vyOdfku9TlPX2a3LasM5jkbxljeTlCJUlahW7LSoQEmLoEhOM4Ja
-6CA5PADhA16pOUweKjOtSkNEcVEorFNjlH34PpnsysF+NsDBP5HEy0eYyHSYwg1Y
-7BGwQxUOoBaUKMu7jVQcffrKiWOGEXzBDSEZ3A30t7+JIS7qy1d1
------END RSA PRIVATE KEY-----
-)";
-            }
-        };
-    }
-}
-
-#endif
diff --git a/src/tools/connection_patcher/Patches/Mac.hpp b/src/tools/connection_patcher/Patches/Mac.hpp
deleted file mode 100644
index 503e21fd4ca..00000000000
--- a/src/tools/connection_patcher/Patches/Mac.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CONNECTION_PATCHER_PATCHES_MAC_HPP
-#define CONNECTION_PATCHER_PATCHES_MAC_HPP
-
-#include <vector>
-
-namespace Connection_Patcher
-{
-    namespace Patches
-    {
-        struct Mac
-        {
-            static std::vector<unsigned char> LauncherLoginParametersLocation()
-            {
-                char const path[] = "org.trnity"; // not a typo, length must match original
-                return std::vector<unsigned char>(std::begin(path), std::end(path));
-            }
-        };
-    }
-}
-
-#endif
diff --git a/src/tools/connection_patcher/Patches/Windows.hpp b/src/tools/connection_patcher/Patches/Windows.hpp
deleted file mode 100644
index 55fe74c6e8e..00000000000
--- a/src/tools/connection_patcher/Patches/Windows.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CONNECTION_PATCHER_PATCHES_WINDOWS_HPP
-#define CONNECTION_PATCHER_PATCHES_WINDOWS_HPP
-
-#include <vector>
-
-namespace Connection_Patcher
-{
-    namespace Patches
-    {
-        struct Windows
-        {
-            static std::vector<unsigned char> LauncherLoginParametersLocation()
-            {
-                char const path[] = R"(Software\TrinityCore Developers\Battle.net\Launch Options\)";
-                return std::vector<unsigned char>(std::begin(path), std::end(path));
-            }
-        };
-    }
-}
-
-#endif
diff --git a/src/tools/connection_patcher/Patterns/Common.hpp b/src/tools/connection_patcher/Patterns/Common.hpp
deleted file mode 100644
index 95bb1b6996c..00000000000
--- a/src/tools/connection_patcher/Patterns/Common.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CONNECTION_PATCHER_PATTERNS_COMMON_HPP
-#define CONNECTION_PATCHER_PATTERNS_COMMON_HPP
-
-#include <vector>
-
-namespace Connection_Patcher
-{
-    namespace Patterns
-    {
-        struct Common
-        {
-            static std::vector<unsigned char> Portal() { return { '.', 'a', 'c', 't', 'u', 'a' , 'l', '.', 'b', 'a', 't', 't', 'l', 'e', '.', 'n', 'e', 't', 0x00 }; }
-            static std::vector<unsigned char> Modulus() { return { 0x91, 0xD5, 0x9B, 0xB7, 0xD4, 0xE1, 0x83, 0xA5 }; }
-            static std::vector<unsigned char> BinaryVersion() { return { 0x3C, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x3E }; }
-            static std::vector<unsigned char> VersionsFile() { return { '%', 's', '.', 'p', 'a', 't', 'c', 'h', '.', 'b', 'a', 't', 't', 'l', 'e', '.', 'n', 'e', 't', ':', '1', '1', '1', '9', '/', '%', 's', '/', 'v', 'e', 'r', 's', 'i', 'o', 'n', 's' }; }
-            static std::vector<unsigned char> CertBundleUrl() { return { 'h', 't', 't', 'p', ':', '/', '/', 'n', 'y', 'd', 'u', 's', '-', 'q', 'a', '.', 'w', 'e', 'b', '.', 'b', 'l', 'i', 'z', 'z', 'a', 'r', 'd', '.', 'n', 'e', 't', '/', 'B', 'n', 'e', 't', '/', 'z', 'x', 'x', '/', 'c', 'l', 'i', 'e', 'n', 't', '/', 'b', 'g', 's', '-', 'k', 'e', 'y', '-', 'f', 'i', 'n', 'g', 'e', 'r', 'p', 'r', 'i', 'n', 't' }; }
-            static std::vector<unsigned char> CertSignatureModulus() { return { 0x85, 0xF3, 0x7B, 0x14, 0x5A, 0x9C, 0x48, 0xF6 }; }
-        };
-    }
-}
-
-#endif
diff --git a/src/tools/connection_patcher/Patterns/Mac.hpp b/src/tools/connection_patcher/Patterns/Mac.hpp
deleted file mode 100644
index 15ec673be3e..00000000000
--- a/src/tools/connection_patcher/Patterns/Mac.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CONNECTION_PATCHER_PATTERNS_MAC_HPP
-#define CONNECTION_PATCHER_PATTERNS_MAC_HPP
-
-#include <vector>
-
-namespace Connection_Patcher
-{
-    namespace Patterns
-    {
-        struct Mac
-        {
-            static std::vector<unsigned char> LauncherLoginParametersLocation() { return { 'n','e','t','.','b','a','t','t','l','e',0 }; }
-        };
-    }
-}
-
-#endif
diff --git a/src/tools/connection_patcher/Patterns/Windows.hpp b/src/tools/connection_patcher/Patterns/Windows.hpp
deleted file mode 100644
index f0764227b73..00000000000
--- a/src/tools/connection_patcher/Patterns/Windows.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef CONNECTION_PATCHER_PATTERNS_WINDOWS_HPP
-#define CONNECTION_PATCHER_PATTERNS_WINDOWS_HPP
-
-#include <vector>
-
-namespace Connection_Patcher
-{
-    namespace Patterns
-    {
-        struct Windows
-        {
-            static std::vector<unsigned char> LauncherLoginParametersLocation()
-            {
-                char const path[] = R"(Software\Blizzard Entertainment\Battle.net\Launch Options\)";
-                return std::vector<unsigned char>(std::begin(path), std::end(path));
-            }
-        };
-    }
-}
-
-#endif
diff --git a/src/tools/connection_patcher/Program.cpp b/src/tools/connection_patcher/Program.cpp
deleted file mode 100644
index b1eff1bda2e..00000000000
--- a/src/tools/connection_patcher/Program.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
- * Copyright (C) 2008-2018 TrinityCore <https://www.trinitycore.org/>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "Helper.hpp"
-#include "Patcher.hpp"
-#include "Patches/Common.hpp"
-#include "Patches/Mac.hpp"
-#include "Patches/Windows.hpp"
-#include "Patterns/Common.hpp"
-#include "Patterns/Mac.hpp"
-#include "Patterns/Windows.hpp"
-
-#include "Banner.h"
-#include "BigNumber.h"
-#include "RSA.h"
-#include "SHA256.h"
-
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/program_options.hpp>
-
-#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
-#include <Shlobj.h>
-#elif TRINITY_PLATFORM == TRINITY_PLATFORM_UNIX
-#include <pwd.h>
-#endif
-
-namespace po = boost::program_options;
-
-namespace Connection_Patcher
-{
-    po::variables_map GetConsoleArguments(int argc, char** argv);
-
-    namespace
-    {
-        template<typename PATCH, typename PATTERN>
-        void do_patches(Patcher* patcher, boost::filesystem::path output, uint32_t buildNumber)
-        {
-            std::cout << "patching Portal\n";
-            // '.actual.battle.net' -> '' to allow for set portal 'host'
-            patcher->Patch(Patches::Common::Portal(), Patterns::Common::Portal());
-
-            std::cout << "patching redirect RSA Modulus\n";
-            // public component of connection signing key to use known key pair
-            patcher->Patch(Patches::Common::Modulus(), Patterns::Common::Modulus());
-
-            std::cout << "patching BNet certificate file location\n";
-            // replace certificate bundle url
-            patcher->Patch(Patches::Common::CertBundleUrl(), Patterns::Common::CertBundleUrl());
-
-            std::cout << "patching BNet certificate file signature\n";
-            Trinity::Crypto::RSA rsa;
-            rsa.LoadFromString(Patches::Common::CertificatePrivateKey(), Trinity::Crypto::RSA::PrivateKey{});
-            std::unique_ptr<uint8[]> modulusArray = rsa.GetModulus().AsByteArray(256);
-            patcher->Patch(std::vector<uint8>(modulusArray.get(), modulusArray.get() + 256), Patterns::Common::CertSignatureModulus());
-
-            std::cout << "patching Versions\n";
-            // sever the connection to blizzard's versions file to stop it from updating and replace with custom version
-            // this is good practice with or without the retail version, just to stop the exe from auto-patching randomly
-            // hardcode %s.patch.battle.net:1119/%s/versions to trinity6.github.io/%s/%s/build/versi
-            std::string verPatch(Patches::Common::VersionsFile());
-            std::string buildPattern = "build";
-
-            boost::algorithm::replace_all(verPatch, buildPattern, std::to_string(buildNumber));
-            std::vector<unsigned char> verVec(verPatch.begin(), verPatch.end());
-            patcher->Patch(verVec, Patterns::Common::VersionsFile());
-
-            std::cout << "patching launcher login parameters location\n";
-            // change registry/CFPreferences path
-            patcher->Patch(PATCH::LauncherLoginParametersLocation(), PATTERN::LauncherLoginParametersLocation());
-
-            patcher->Finish(output);
-
-            std::cout << "Patching done.\n";
-        }
-
-        void WriteCertificateBundle(boost::filesystem::path const& dest)
-        {
-            if (!boost::filesystem::exists(dest.parent_path()) &&
-                !boost::filesystem::create_directories(dest.parent_path()))
-                throw std::runtime_error("could not create " + dest.parent_path().string());
-
-            std::ofstream ofs(dest.string(), std::ofstream::binary);
-            if (!ofs)
-                throw std::runtime_error("could not open " + dest.string());
-
-            ofs << std::noskipws << Patches::Common::CertificateBundle() << "NGIS";
-
-            SHA256Hash signatureHash;
-            signatureHash.UpdateData(Patches::Common::CertificateBundle());
-            signatureHash.UpdateData("Blizzard Certificate Bundle");
-            signatureHash.Finalize();
-            std::array<uint8, 256> signature;
-
-            Trinity::Crypto::RSA rsa;
-            rsa.LoadFromString(Patches::Common::CertificatePrivateKey(), Trinity::Crypto::RSA::PrivateKey{});
-            rsa.Sign(signatureHash.GetDigest(), signatureHash.GetLength(), signature.data(), Trinity::Crypto::RSA::SHA256{});
-
-            ofs.write(reinterpret_cast<char const*>(signature.data()), signature.size());
-        }
-    }
-
-    po::variables_map GetConsoleArguments(int argc, char** argv)
-    {
-        po::options_description all("Allowed options");
-        all.add_options()
-            ("help,h", "print usage message")
-            ("path", po::value<std::string>()->required(), "Path to the Wow.exe")
-            ;
-
-        po::positional_options_description pos;
-        pos.add("path", 1);
-
-        po::variables_map vm;
-        try
-        {
-            po::store(po::command_line_parser(argc, argv).options(all).positional(pos).run(), vm);
-            po::notify(vm);
-        }
-        catch (std::exception& e)
-        {
-            std::cerr << e.what() << "\n";
-        }
-
-        if (vm.count("help"))
-            std::cout << all << "\n";
-
-        if (!vm.count("path"))
-            throw std::invalid_argument("Wrong number of arguments: Missing client file.");
-
-        return vm;
-    }
-}
-
-int main(int argc, char** argv)
-{
-    using namespace Connection_Patcher;
-
-    try
-    {
-        Trinity::Banner::Show("connection_patcher", [](char const* text) { std::cout << text << std::endl; }, nullptr);
-
-        auto vm = GetConsoleArguments(argc, argv);
-
-        // exit if help is enabled
-        if (vm.count("help"))
-        {
-            std::cin.get();
-            return 0;
-        }
-
-        std::string const binary_path(std::move(vm["path"].as<std::string>()));
-        std::string renamed_binary_path(binary_path);
-        std::wstring appDataPath;
-
-#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
-        wchar_t* tempPath(nullptr);
-        SHGetKnownFolderPath(FOLDERID_ProgramData, 0, NULL, &tempPath);
-        appDataPath = std::wstring(tempPath);
-        CoTaskMemFree(tempPath);
-#elif TRINITY_PLATFORM == TRINITY_PLATFORM_UNIX
-        char* tempPath(nullptr);
-        if ((tempPath = getenv("HOME")) == nullptr)
-            tempPath = getpwuid(getuid())->pw_dir;
-        std::string tempPathStr(tempPath);
-        appDataPath.assign(tempPathStr.begin(), tempPathStr.end());
-        appDataPath += std::wstring(L"/.wine/drive_c/users/Public/Application Data");
-#elif TRINITY_PLATFORM == TRINITY_PLATFORM_APPLE
-        appDataPath = L"/Users/Shared";
-#endif
-        std::cout << "Creating patched binary..." << std::endl;
-
-        Patcher patcher(binary_path);
-
-        // always set wowBuild to current build of the .exe files
-        int wowBuild = Helper::GetBuildNumber(patcher.GetBinary());
-
-        // define logical limits in case the exe was tinkered with and the build number was changed
-        if (wowBuild == 0 || wowBuild < 10000 || wowBuild > 65535) // Build number has to be exactly 5 characters long
-            throw std::runtime_error("Build number was out of range. Build: " + std::to_string(wowBuild));
-
-        std::cout << "Determined build number: " << std::to_string(wowBuild) << std::endl;
-
-        switch (patcher.GetType())
-        {
-            case Constants::BinaryTypes::Pe32:
-            case Constants::BinaryTypes::Pe64:
-                std::cout << (patcher.GetType() == Constants::BinaryTypes::Pe64 ? "Win64" : "Win32") << " client...\n";
-
-                boost::algorithm::replace_all(renamed_binary_path, ".exe", "_Patched.exe");
-                do_patches<Patches::Windows, Patterns::Windows>
-                    (&patcher, renamed_binary_path, wowBuild);
-                WriteCertificateBundle(boost::filesystem::path(appDataPath) / L"Blizzard Entertainment/Battle.net/Cache/web_cert_bundle");
-                break;
-            case Constants::BinaryTypes::Mach64:
-                std::cout << "Mac client...\n";
-
-                boost::algorithm::replace_all(renamed_binary_path, ".app", " Patched.app");
-                Helper::CopyDir(boost::filesystem::path(binary_path).parent_path()/*MacOS*/.parent_path()/*Contents*/.parent_path()
-                        , boost::filesystem::path(renamed_binary_path).parent_path()/*MacOS*/.parent_path()/*Contents*/.parent_path()
-                        );
-
-                do_patches<Patches::Mac, Patterns::Mac>
-                    (&patcher, renamed_binary_path, wowBuild);
-
-                {
-                    namespace fs = boost::filesystem;
-                    fs::permissions(renamed_binary_path, fs::add_perms | fs::others_exe | fs::group_exe | fs::owner_exe);
-                }
-                WriteCertificateBundle(boost::filesystem::path(appDataPath) / "Blizzard/Battle.net/Cache/web_cert_bundle");
-                break;
-            default:
-                throw std::runtime_error("Type: " + std::to_string(static_cast<uint32_t>(patcher.GetType())) + " not supported!");
-        }
-
-        std::cout << "Successfully created your patched binaries.\n";
-
-        return 0;
-    }
-    catch (std::exception const& ex)
-    {
-        std::cerr << "EX: " << ex.what() << std::endl;
-        std::cerr << "An error occurred. Press ENTER to continue...";
-        std::cin.get();
-        return 1;
-    }
-}
diff --git a/src/tools/extractor_common/CascHandles.cpp b/src/tools/extractor_common/CascHandles.cpp
index 575f9fe3405..930d8eea420 100644
--- a/src/tools/extractor_common/CascHandles.cpp
+++ b/src/tools/extractor_common/CascHandles.cpp
@@ -127,6 +127,13 @@ DWORD CASC::GetFilePointer(FileHandle const& file)
     return ::CascSetFilePointer(file.get(), 0, nullptr, FILE_CURRENT);
 }
 
+bool CASC::SetFilePointer(FileHandle const& file, LONGLONG position)
+{
+    LONG parts[2];
+    memcpy(parts, &position, sizeof(parts));
+    return ::CascSetFilePointer(file.get(), parts[0], &parts[1], FILE_BEGIN) != CASC_INVALID_POS;
+}
+
 bool CASC::ReadFile(FileHandle const& file, void* buffer, DWORD bytes, PDWORD bytesRead)
 {
     return ::CascReadFile(file.get(), buffer, bytes, bytesRead);
diff --git a/src/tools/extractor_common/CascHandles.h b/src/tools/extractor_common/CascHandles.h
index 0a8a1dd359c..a412976ce10 100644
--- a/src/tools/extractor_common/CascHandles.h
+++ b/src/tools/extractor_common/CascHandles.h
@@ -55,6 +55,7 @@ namespace CASC
     FileHandle OpenFile(StorageHandle const& storage, char const* fileName, DWORD localeMask, bool printErrors = false);
     DWORD GetFileSize(FileHandle const& file, PDWORD fileSizeHigh);
     DWORD GetFilePointer(FileHandle const& file);
+    bool SetFilePointer(FileHandle const& file, LONGLONG position);
     bool ReadFile(FileHandle const& file, void* buffer, DWORD bytes, PDWORD bytesRead);
 }
 
diff --git a/src/tools/extractor_common/DB2CascFileSource.cpp b/src/tools/extractor_common/DB2CascFileSource.cpp
index 5452c3e1518..b09f7f0b90e 100644
--- a/src/tools/extractor_common/DB2CascFileSource.cpp
+++ b/src/tools/extractor_common/DB2CascFileSource.cpp
@@ -40,6 +40,11 @@ std::size_t DB2CascFileSource::GetPosition() const
     return CASC::GetFilePointer(_fileHandle);
 }
 
+bool DB2CascFileSource::SetPosition(std::size_t position)
+{
+    return CASC::SetFilePointer(_fileHandle, position);
+}
+
 std::size_t DB2CascFileSource::GetFileSize() const
 {
     DWORD sizeLow = 0;
diff --git a/src/tools/extractor_common/DB2CascFileSource.h b/src/tools/extractor_common/DB2CascFileSource.h
index 9708fcdcfe3..84376b6791d 100644
--- a/src/tools/extractor_common/DB2CascFileSource.h
+++ b/src/tools/extractor_common/DB2CascFileSource.h
@@ -28,6 +28,7 @@ struct DB2CascFileSource : public DB2FileSource
     bool IsOpen() const override;
     bool Read(void* buffer, std::size_t numBytes) override;
     std::size_t GetPosition() const override;
+    bool SetPosition(std::size_t position) override;
     std::size_t GetFileSize() const override;
     char const* GetFileName() const override;
 
diff --git a/src/tools/extractor_common/ExtractorDB2LoadInfo.h b/src/tools/extractor_common/ExtractorDB2LoadInfo.h
index fccfc924205..26c1fb860d7 100644
--- a/src/tools/extractor_common/ExtractorDB2LoadInfo.h
+++ b/src/tools/extractor_common/ExtractorDB2LoadInfo.h
@@ -26,20 +26,25 @@ struct CinematicCameraLoadInfo
 {
     static DB2FileLoadInfo const* Instance()
     {
-        static DB2FieldMeta const fields[] =
+        static DB2FieldMeta const loadedFields[] =
         {
             { false, FT_INT, "ID" },
-            { false, FT_INT, "SoundID" },
             { false, FT_FLOAT, "OriginX" },
             { false, FT_FLOAT, "OriginY" },
             { false, FT_FLOAT, "OriginZ" },
+            { false, FT_INT, "SoundID" },
             { false, FT_FLOAT, "OriginFacing" },
             { false, FT_INT, "FileDataID" },
         };
-        static char const* types = "iffi";
-        static uint8 const arraySizes[4] = { 1, 3, 1, 1 };
-        static DB2Meta const meta(-1, 4, 0x0062B0F4, types, arraySizes, -1);
-        static DB2FileLoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, &meta);
+        static DB2MetaField const fields[4] =
+        {
+            { FT_FLOAT, 3, true },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_INT, 1, false },
+        };
+        static DB2Meta meta(-1, 4, 0x20C5E540, fields, -1);
+        static DB2FileLoadInfo const loadInfo(&loadedFields[0], std::extent<decltype(loadedFields)>::value, &meta);
         return &loadInfo;
     }
 };
@@ -48,24 +53,30 @@ struct GameobjectDisplayInfoLoadInfo
 {
     static DB2FileLoadInfo const* Instance()
     {
-        static DB2FieldMeta const fields[] =
+        static DB2FieldMeta const loadedFields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_INT, "FileDataID" },
             { false, FT_FLOAT, "GeoBoxMinX" },
             { false, FT_FLOAT, "GeoBoxMinY" },
             { false, FT_FLOAT, "GeoBoxMinZ" },
             { false, FT_FLOAT, "GeoBoxMaxX" },
             { false, FT_FLOAT, "GeoBoxMaxY" },
             { false, FT_FLOAT, "GeoBoxMaxZ" },
+            { true, FT_INT, "FileDataID" },
+            { true, FT_SHORT, "ObjectEffectPackageID" },
             { false, FT_FLOAT, "OverrideLootEffectScale" },
             { false, FT_FLOAT, "OverrideNameScale" },
-            { true, FT_SHORT, "ObjectEffectPackageID" },
         };
-        static char const* types = "ifffh";
-        static uint8 const arraySizes[5] = { 1, 6, 1, 1, 1 };
-        static DB2Meta const meta(-1, 5, 0x9F2098D1, types, arraySizes, -1);
-        static DB2FileLoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, &meta);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 6, true },
+            { FT_INT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+        };
+        static DB2Meta meta(-1, 5, 0x7A816799, fields, -1);
+        static DB2FileLoadInfo const loadInfo(&loadedFields[0], std::extent<decltype(loadedFields)>::value, &meta);
         return &loadInfo;
     }
 };
@@ -74,16 +85,19 @@ struct LiquidMaterialLoadInfo
 {
     static DB2FileLoadInfo const* Instance()
     {
-        static DB2FieldMeta const fields[] =
+        static DB2FieldMeta const loadedFields[] =
         {
             { false, FT_INT, "ID" },
-            { true, FT_BYTE, "LVF" },
             { true, FT_BYTE, "Flags" },
+            { true, FT_BYTE, "LVF" },
         };
-        static char const* types = "bb";
-        static uint8 const arraySizes[2] = { 1, 1 };
-        static DB2Meta meta(-1, 2, 0x62BE0340, types, arraySizes, -1);
-        static DB2FileLoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, &meta);
+        static DB2MetaField const fields[2] =
+        {
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, true },
+        };
+        static DB2Meta meta(-1, 2, 0x6A7287A2, fields, -1);
+        static DB2FileLoadInfo const loadInfo(&loadedFields[0], std::extent<decltype(loadedFields)>::value, &meta);
         return &loadInfo;
     }
 };
@@ -92,7 +106,7 @@ struct LiquidObjectLoadInfo
 {
     static DB2FileLoadInfo const* Instance()
     {
-        static DB2FieldMeta const fields[] =
+        static DB2FieldMeta const loadedFields[] =
         {
             { false, FT_INT, "ID" },
             { false, FT_FLOAT, "FlowDirection" },
@@ -101,10 +115,16 @@ struct LiquidObjectLoadInfo
             { false, FT_BYTE, "Fishable" },
             { false, FT_BYTE, "Reflection" },
         };
-        static char const* types = "ffhbb";
-        static uint8 const arraySizes[5] = { 1, 1, 1, 1, 1 };
-        static DB2Meta meta(-1, 5, 0xACC168A6, types, arraySizes, -1);
-        static DB2FileLoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, &meta);
+        static DB2MetaField const fields[5] =
+        {
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+        };
+        static DB2Meta meta(-1, 5, 0x7AF380AA, fields, -1);
+        static DB2FileLoadInfo const loadInfo(&loadedFields[0], std::extent<decltype(loadedFields)>::value, &meta);
         return &loadInfo;
     }
 };
@@ -113,7 +133,7 @@ struct LiquidTypeLoadInfo
 {
     static DB2FileLoadInfo const* Instance()
     {
-        static DB2FieldMeta const fields[] =
+        static DB2FieldMeta const loadedFields[] =
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING_NOT_LOCALIZED, "Name" },
@@ -123,12 +143,26 @@ struct LiquidTypeLoadInfo
             { false, FT_STRING_NOT_LOCALIZED, "Texture4" },
             { false, FT_STRING_NOT_LOCALIZED, "Texture5" },
             { false, FT_STRING_NOT_LOCALIZED, "Texture6" },
+            { false, FT_SHORT, "Flags" },
+            { false, FT_BYTE, "SoundBank" },
+            { false, FT_INT, "SoundID" },
             { false, FT_INT, "SpellID" },
             { false, FT_FLOAT, "MaxDarkenDepth" },
             { false, FT_FLOAT, "FogDarkenIntensity" },
             { false, FT_FLOAT, "AmbDarkenIntensity" },
             { false, FT_FLOAT, "DirDarkenIntensity" },
+            { false, FT_SHORT, "LightID" },
             { false, FT_FLOAT, "ParticleScale" },
+            { false, FT_BYTE, "ParticleMovement" },
+            { false, FT_BYTE, "ParticleTexSlots" },
+            { false, FT_BYTE, "MaterialID" },
+            { true, FT_INT, "MinimapStaticCol" },
+            { false, FT_BYTE, "FrameCountTexture1" },
+            { false, FT_BYTE, "FrameCountTexture2" },
+            { false, FT_BYTE, "FrameCountTexture3" },
+            { false, FT_BYTE, "FrameCountTexture4" },
+            { false, FT_BYTE, "FrameCountTexture5" },
+            { false, FT_BYTE, "FrameCountTexture6" },
             { true, FT_INT, "Color1" },
             { true, FT_INT, "Color2" },
             { false, FT_FLOAT, "Float1" },
@@ -153,24 +187,37 @@ struct LiquidTypeLoadInfo
             { false, FT_INT, "Int2" },
             { false, FT_INT, "Int3" },
             { false, FT_INT, "Int4" },
-            { false, FT_SHORT, "Flags" },
-            { false, FT_SHORT, "LightID" },
-            { false, FT_BYTE, "SoundBank" },
-            { false, FT_BYTE, "ParticleMovement" },
-            { false, FT_BYTE, "ParticleTexSlots" },
-            { false, FT_BYTE, "MaterialID" },
-            { false, FT_BYTE, "FrameCountTexture1" },
-            { false, FT_BYTE, "FrameCountTexture2" },
-            { false, FT_BYTE, "FrameCountTexture3" },
-            { false, FT_BYTE, "FrameCountTexture4" },
-            { false, FT_BYTE, "FrameCountTexture5" },
-            { false, FT_BYTE, "FrameCountTexture6" },
-            { false, FT_INT, "SoundID" },
+            { false, FT_FLOAT, "Coefficient1" },
+            { false, FT_FLOAT, "Coefficient2" },
+            { false, FT_FLOAT, "Coefficient3" },
+            { false, FT_FLOAT, "Coefficient4" },
+        };
+        static DB2MetaField const fields[21] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING_NOT_LOCALIZED, 6, true },
+            { FT_SHORT, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, false },
+            { FT_INT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, false },
+            { FT_INT, 1, true },
+            { FT_BYTE, 6, false },
+            { FT_INT, 2, true },
+            { FT_FLOAT, 18, true },
+            { FT_INT, 4, false },
+            { FT_FLOAT, 4, true },
         };
-        static char const* types = "ssifffffifihhbbbbbi";
-        static uint8 const arraySizes[19] = { 1, 6, 1, 1, 1, 1, 1, 1, 2, 18, 4, 1, 1, 1, 1, 1, 1, 6, 1 };
-        static DB2Meta const meta(-1, 19, 0x3313BBF3, types, arraySizes, -1);
-        static DB2FileLoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, &meta);
+        static DB2Meta meta(-1, 21, 0x29F8C65E, fields, -1);
+        static DB2FileLoadInfo const loadInfo(&loadedFields[0], std::extent<decltype(loadedFields)>::value, &meta);
         return &loadInfo;
     }
 };
@@ -179,7 +226,7 @@ struct MapLoadInfo
 {
     static DB2FileLoadInfo const* Instance()
     {
-        static DB2FieldMeta const fields[] =
+        static DB2FieldMeta const loadedFields[] =
         {
             { false, FT_INT, "ID" },
             { false, FT_STRING_NOT_LOCALIZED, "Directory" },
@@ -188,28 +235,52 @@ struct MapLoadInfo
             { false, FT_STRING, "MapDescription1" },
             { false, FT_STRING, "PvpShortDescription" },
             { false, FT_STRING, "PvpLongDescription" },
-            { true, FT_INT, "Flags1" },
-            { true, FT_INT, "Flags2" },
-            { false, FT_FLOAT, "MinimapIconScale" },
             { false, FT_FLOAT, "CorpseX" },
             { false, FT_FLOAT, "CorpseY" },
+            { false, FT_BYTE, "MapType" },
+            { true, FT_BYTE, "InstanceType" },
+            { false, FT_BYTE, "ExpansionID" },
             { false, FT_SHORT, "AreaTableID" },
             { true, FT_SHORT, "LoadingScreenID" },
-            { true, FT_SHORT, "CorpseMapID" },
             { true, FT_SHORT, "TimeOfDayOverride" },
             { true, FT_SHORT, "ParentMapID" },
             { true, FT_SHORT, "CosmeticParentMapID" },
-            { true, FT_SHORT, "WindSettingsID" },
-            { false, FT_BYTE, "InstanceType" },
-            { false, FT_BYTE, "MapType" },
-            { false, FT_BYTE, "ExpansionID" },
-            { false, FT_BYTE, "MaxPlayers" },
             { false, FT_BYTE, "TimeOffset" },
+            { false, FT_FLOAT, "MinimapIconScale" },
+            { true, FT_SHORT, "CorpseMapID" },
+            { false, FT_BYTE, "MaxPlayers" },
+            { true, FT_SHORT, "WindSettingsID" },
+            { true, FT_INT, "ZmpFileDataID" },
+            { true, FT_INT, "Flags1" },
+            { true, FT_INT, "Flags2" },
+        };
+        static DB2MetaField const fields[22] =
+        {
+            { FT_STRING_NOT_LOCALIZED, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_STRING, 1, true },
+            { FT_FLOAT, 2, true },
+            { FT_BYTE, 1, false },
+            { FT_BYTE, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_FLOAT, 1, true },
+            { FT_SHORT, 1, true },
+            { FT_BYTE, 1, false },
+            { FT_SHORT, 1, true },
+            { FT_INT, 1, true },
+            { FT_INT, 2, true },
         };
-        static char const* types = "ssssssiffhhhhhhhbbbbb";
-        static uint8 const arraySizes[21] = { 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
-        static DB2Meta const meta(-1, 21, 0xF568DF12, types, arraySizes, -1);
-        static DB2FileLoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, &meta);
+        static DB2Meta meta(-1, 22, 0x503A3E58, fields, -1);
+        static DB2FileLoadInfo const loadInfo(&loadedFields[0], std::extent<decltype(loadedFields)>::value, &meta);
         return &loadInfo;
     }
 };
diff --git a/src/tools/map_extractor/System.cpp b/src/tools/map_extractor/System.cpp
index 3de2f1908fa..ee0bafacd20 100644
--- a/src/tools/map_extractor/System.cpp
+++ b/src/tools/map_extractor/System.cpp
@@ -1247,6 +1247,9 @@ void ExtractGameTables()
         "GameTables\\ArmorMitigationByLvl.txt",
         "GameTables\\ArtifactKnowledgeMultiplier.txt",
         "GameTables\\ArtifactLevelXP.txt",
+        "GameTables\\AzeriteBaseExperiencePerLevel.txt",
+        "GameTables\\AzeriteKnowledgeMultiplier.txt",
+        "GameTables\\AzeriteLevelToItemLevel.txt",
         "GameTables\\BarberShopCostBase.txt",
         "GameTables\\BaseMp.txt",
         "GameTables\\BattlePetTypeDamageMod.txt",
@@ -1257,6 +1260,8 @@ void ExtractGameTables()
         "GameTables\\CombatRatingsMultByILvl.txt",
         "GameTables\\HonorLevel.txt",
         "GameTables\\HpPerSta.txt",
+        "GameTables\\ItemLevelByLevel.txt",
+        "GameTables\\ItemLevelSquish.txt",
         "GameTables\\ItemSocketCostPerLevel.txt",
         "GameTables\\NpcDamageByClass.txt",
         "GameTables\\NpcDamageByClassExp1.txt",
@@ -1265,6 +1270,7 @@ void ExtractGameTables()
         "GameTables\\NpcDamageByClassExp4.txt",
         "GameTables\\NpcDamageByClassExp5.txt",
         "GameTables\\NpcDamageByClassExp6.txt",
+        "GameTables\\NpcDamageByClassExp7.txt",
         "GameTables\\NPCManaCostScaler.txt",
         "GameTables\\NpcTotalHp.txt",
         "GameTables\\NpcTotalHpExp1.txt",
@@ -1273,8 +1279,10 @@ void ExtractGameTables()
         "GameTables\\NpcTotalHpExp4.txt",
         "GameTables\\NpcTotalHpExp5.txt",
         "GameTables\\NpcTotalHpExp6.txt",
+        "GameTables\\NpcTotalHpExp7.txt",
         "GameTables\\SandboxScaling.txt",
         "GameTables\\SpellScaling.txt",
+        "GameTables\\StaminaMultByILvl.txt",
         "GameTables\\xp.txt",
         nullptr
     };
diff --git a/src/tools/map_extractor/loadlib/DBFilesClientList.h b/src/tools/map_extractor/loadlib/DBFilesClientList.h
index bb31f31d6dc..40d24a36258 100644
--- a/src/tools/map_extractor/loadlib/DBFilesClientList.h
+++ b/src/tools/map_extractor/loadlib/DBFilesClientList.h
@@ -37,6 +37,8 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\AnimReplacement.db2",
     "DBFilesClient\\AnimReplacementSet.db2",
     "DBFilesClient\\AnimationData.db2",
+    "DBFilesClient\\AoiBox.db2",
+    "DBFilesClient\\AreaConditionalData.db2",
     "DBFilesClient\\AreaFarClipOverride.db2",
     "DBFilesClient\\AreaGroupMember.db2",
     "DBFilesClient\\AreaPOI.db2",
@@ -45,6 +47,7 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\AreaTrigger.db2",
     "DBFilesClient\\AreaTriggerActionSet.db2",
     "DBFilesClient\\AreaTriggerBox.db2",
+    "DBFilesClient\\AreaTriggerCreateProperties.db2",
     "DBFilesClient\\AreaTriggerCylinder.db2",
     "DBFilesClient\\AreaTriggerSphere.db2",
     "DBFilesClient\\ArmorLocation.db2",
@@ -52,6 +55,7 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\ArtifactAppearance.db2",
     "DBFilesClient\\ArtifactAppearanceSet.db2",
     "DBFilesClient\\ArtifactCategory.db2",
+    "DBFilesClient\\ArtifactItemToTransmog.db2",
     "DBFilesClient\\ArtifactPower.db2",
     "DBFilesClient\\ArtifactPowerLink.db2",
     "DBFilesClient\\ArtifactPowerPicker.db2",
@@ -60,6 +64,12 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\ArtifactTier.db2",
     "DBFilesClient\\ArtifactUnlock.db2",
     "DBFilesClient\\AuctionHouse.db2",
+    "DBFilesClient\\AzeriteEmpoweredItem.db2",
+    "DBFilesClient\\AzeriteItem.db2",
+    "DBFilesClient\\AzeriteItemMilestonePower.db2",
+    "DBFilesClient\\AzeritePower.db2",
+    "DBFilesClient\\AzeritePowerSetMember.db2",
+    "DBFilesClient\\AzeriteTierUnlock.db2",
     "DBFilesClient\\BankBagSlotPrices.db2",
     "DBFilesClient\\BannedAddons.db2",
     "DBFilesClient\\BarberShopStyle.db2",
@@ -81,12 +91,16 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\BeamEffect.db2",
     "DBFilesClient\\BoneWindModifierModel.db2",
     "DBFilesClient\\BoneWindModifiers.db2",
+    "DBFilesClient\\BonusRoll.db2",
     "DBFilesClient\\Bounty.db2",
     "DBFilesClient\\BountySet.db2",
     "DBFilesClient\\BroadcastText.db2",
     "DBFilesClient\\CameraEffect.db2",
     "DBFilesClient\\CameraEffectEntry.db2",
     "DBFilesClient\\CameraMode.db2",
+    "DBFilesClient\\Campaign.db2",
+    "DBFilesClient\\CampaignXCondition.db2",
+    "DBFilesClient\\CampaignXQuestLine.db2",
     "DBFilesClient\\CastableRaidBuffs.db2",
     "DBFilesClient\\CelestialBody.db2",
     "DBFilesClient\\Cfg_Categories.db2",
@@ -123,14 +137,20 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\ChrUpgradeTier.db2",
     "DBFilesClient\\CinematicCamera.db2",
     "DBFilesClient\\CinematicSequences.db2",
+    "DBFilesClient\\ClientSceneEffect.db2",
     "DBFilesClient\\CloakDampening.db2",
+    "DBFilesClient\\CloneEffect.db2",
     "DBFilesClient\\CombatCondition.db2",
     "DBFilesClient\\CommentatorStartLocation.db2",
     "DBFilesClient\\CommentatorTrackedCooldown.db2",
+    "DBFilesClient\\CommunityIcon.db2",
     "DBFilesClient\\ComponentModelFileData.db2",
     "DBFilesClient\\ComponentTextureFileData.db2",
     "DBFilesClient\\ConfigurationWarning.db2",
+    "DBFilesClient\\ContentTuning.db2",
     "DBFilesClient\\Contribution.db2",
+    "DBFilesClient\\ContributionStyle.db2",
+    "DBFilesClient\\ContributionStyleContainer.db2",
     "DBFilesClient\\ConversationLine.db2",
     "DBFilesClient\\Creature.db2",
     "DBFilesClient\\CreatureDifficulty.db2",
@@ -139,6 +159,7 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\CreatureDisplayInfoCond.db2",
     "DBFilesClient\\CreatureDisplayInfoEvt.db2",
     "DBFilesClient\\CreatureDisplayInfoExtra.db2",
+    "DBFilesClient\\CreatureDisplayInfoGeosetData.db2",
     "DBFilesClient\\CreatureDisplayInfoTrn.db2",
     "DBFilesClient\\CreatureFamily.db2",
     "DBFilesClient\\CreatureImmunities.db2",
@@ -147,10 +168,12 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\CreatureSoundData.db2",
     "DBFilesClient\\CreatureType.db2",
     "DBFilesClient\\CreatureXContribution.db2",
+    "DBFilesClient\\CreatureXDisplayInfo.db2",
     "DBFilesClient\\Criteria.db2",
     "DBFilesClient\\CriteriaTree.db2",
     "DBFilesClient\\CriteriaTreeXEffect.db2",
     "DBFilesClient\\CurrencyCategory.db2",
+    "DBFilesClient\\CurrencyContainer.db2",
     "DBFilesClient\\CurrencyTypes.db2",
     "DBFilesClient\\Curve.db2",
     "DBFilesClient\\CurvePoint.db2",
@@ -165,8 +188,6 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\DissolveEffect.db2",
     "DBFilesClient\\DriverBlacklist.db2",
     "DBFilesClient\\DungeonEncounter.db2",
-    "DBFilesClient\\DungeonMap.db2",
-    "DBFilesClient\\DungeonMapChunk.db2",
     "DBFilesClient\\DurabilityCosts.db2",
     "DBFilesClient\\DurabilityQuality.db2",
     "DBFilesClient\\EdgeGlowEffect.db2",
@@ -176,6 +197,8 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\EmotesTextSound.db2",
     "DBFilesClient\\EnvironmentalDamage.db2",
     "DBFilesClient\\Exhaustion.db2",
+    "DBFilesClient\\ExpectedStat.db2",
+    "DBFilesClient\\ExpectedStatMod.db2",
     "DBFilesClient\\Faction.db2",
     "DBFilesClient\\FactionGroup.db2",
     "DBFilesClient\\FactionTemplate.db2",
@@ -259,7 +282,7 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\HolidayDescriptions.db2",
     "DBFilesClient\\HolidayNames.db2",
     "DBFilesClient\\Holidays.db2",
-    "DBFilesClient\\Hotfix.db2",
+    "DBFilesClient\\Hotfixes.db2",
     "DBFilesClient\\ImportPriceArmor.db2",
     "DBFilesClient\\ImportPriceQuality.db2",
     "DBFilesClient\\ImportPriceShield.db2",
@@ -339,6 +362,7 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\LightData.db2",
     "DBFilesClient\\LightParams.db2",
     "DBFilesClient\\LightSkybox.db2",
+    "DBFilesClient\\Lightning.db2",
     "DBFilesClient\\LiquidMaterial.db2",
     "DBFilesClient\\LiquidObject.db2",
     "DBFilesClient\\LiquidType.db2",
@@ -379,15 +403,22 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\Movie.db2",
     "DBFilesClient\\MovieFileData.db2",
     "DBFilesClient\\MovieVariation.db2",
+    "DBFilesClient\\MultiStateProperties.db2",
+    "DBFilesClient\\MultiTransitionProperties.db2",
+    "DBFilesClient\\MythicPlusSeasonRewardLevels.db2",
     "DBFilesClient\\NPCModelItemSlotDisplayInfo.db2",
     "DBFilesClient\\NPCSounds.db2",
     "DBFilesClient\\NameGen.db2",
     "DBFilesClient\\NamesProfanity.db2",
     "DBFilesClient\\NamesReserved.db2",
     "DBFilesClient\\NamesReservedLocale.db2",
+    "DBFilesClient\\NumTalentsAtLevel.db2",
     "DBFilesClient\\ObjectEffect.db2",
     "DBFilesClient\\ObjectEffectModifier.db2",
     "DBFilesClient\\ObjectEffectPackageElem.db2",
+    "DBFilesClient\\Occluder.db2",
+    "DBFilesClient\\OccluderLocation.db2",
+    "DBFilesClient\\OccluderNode.db2",
     "DBFilesClient\\OutlineEffect.db2",
     "DBFilesClient\\OverrideSpellData.db2",
     "DBFilesClient\\PVPBracketTypes.db2",
@@ -397,6 +428,7 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\PaperDollItemFrame.db2",
     "DBFilesClient\\ParagonReputation.db2",
     "DBFilesClient\\ParticleColor.db2",
+    "DBFilesClient\\ParticulateSound.db2",
     "DBFilesClient\\Path.db2",
     "DBFilesClient\\PathNode.db2",
     "DBFilesClient\\PathNodeProperty.db2",
@@ -411,11 +443,12 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\PowerDisplay.db2",
     "DBFilesClient\\PowerType.db2",
     "DBFilesClient\\PrestigeLevelInfo.db2",
-    "DBFilesClient\\PvpReward.db2",
     "DBFilesClient\\PvpScalingEffect.db2",
     "DBFilesClient\\PvpScalingEffectType.db2",
     "DBFilesClient\\PvpTalent.db2",
-    "DBFilesClient\\PvpTalentUnlock.db2",
+    "DBFilesClient\\PvpTalentCategory.db2",
+    "DBFilesClient\\PvpTalentSlotUnlock.db2",
+    "DBFilesClient\\PvpTier.db2",
     "DBFilesClient\\QuestFactionReward.db2",
     "DBFilesClient\\QuestFeedbackEffect.db2",
     "DBFilesClient\\QuestInfo.db2",
@@ -445,7 +478,6 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\RibbonQuality.db2",
     "DBFilesClient\\RulesetItemUpgrade.db2",
     "DBFilesClient\\SDReplacementModel.db2",
-    "DBFilesClient\\SandboxScaling.db2",
     "DBFilesClient\\ScalingStatDistribution.db2",
     "DBFilesClient\\Scenario.db2",
     "DBFilesClient\\ScenarioEventEntry.db2",
@@ -464,6 +496,7 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\SeamlessSite.db2",
     "DBFilesClient\\ServerMessages.db2",
     "DBFilesClient\\ShadowyEffect.db2",
+    "DBFilesClient\\SiegeableProperties.db2",
     "DBFilesClient\\SkillLine.db2",
     "DBFilesClient\\SkillLineAbility.db2",
     "DBFilesClient\\SkillRaceClassInfo.db2",
@@ -486,7 +519,9 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\SoundProviderPreferences.db2",
     "DBFilesClient\\SourceInfo.db2",
     "DBFilesClient\\SpamMessages.db2",
+    "DBFilesClient\\SpecSetMember.db2",
     "DBFilesClient\\SpecializationSpells.db2",
+    "DBFilesClient\\SpecializationSpellsDisplay.db2",
     "DBFilesClient\\Spell.db2",
     "DBFilesClient\\SpellActionBarPref.db2",
     "DBFilesClient\\SpellActivationOverlay.db2",
@@ -505,6 +540,7 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\SpellDispelType.db2",
     "DBFilesClient\\SpellDuration.db2",
     "DBFilesClient\\SpellEffect.db2",
+    "DBFilesClient\\SpellEffectAutoDescription.db2",
     "DBFilesClient\\SpellEffectEmission.db2",
     "DBFilesClient\\SpellEquippedItems.db2",
     "DBFilesClient\\SpellFlyout.db2",
@@ -521,6 +557,7 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\SpellMisc.db2",
     "DBFilesClient\\SpellMissile.db2",
     "DBFilesClient\\SpellMissileMotion.db2",
+    "DBFilesClient\\SpellName.db2",
     "DBFilesClient\\SpellPower.db2",
     "DBFilesClient\\SpellPowerDifficulty.db2",
     "DBFilesClient\\SpellProceduralEffect.db2",
@@ -582,19 +619,35 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\UiCamFbackTransmogWeapon.db2",
     "DBFilesClient\\UiCamera.db2",
     "DBFilesClient\\UiCameraType.db2",
-    "DBFilesClient\\UiMapPOI.db2",
+    "DBFilesClient\\UiCanvas.db2",
+    "DBFilesClient\\UiMap.db2",
+    "DBFilesClient\\UiMapArt.db2",
+    "DBFilesClient\\UiMapArtStyleLayer.db2",
+    "DBFilesClient\\UiMapArtTile.db2",
+    "DBFilesClient\\UiMapAssignment.db2",
+    "DBFilesClient\\UiMapFogOfWar.db2",
+    "DBFilesClient\\UiMapFogOfWarVisualization.db2",
+    "DBFilesClient\\UiMapGroupMember.db2",
+    "DBFilesClient\\UiMapLink.db2",
+    "DBFilesClient\\UiMapXMapArt.db2",
     "DBFilesClient\\UiModelScene.db2",
     "DBFilesClient\\UiModelSceneActor.db2",
     "DBFilesClient\\UiModelSceneActorDisplay.db2",
     "DBFilesClient\\UiModelSceneCamera.db2",
+    "DBFilesClient\\UiPartyPose.db2",
     "DBFilesClient\\UiTextureAtlas.db2",
+    "DBFilesClient\\UiTextureAtlasElement.db2",
     "DBFilesClient\\UiTextureAtlasMember.db2",
     "DBFilesClient\\UiTextureKit.db2",
+    "DBFilesClient\\UiWidget.db2",
+    "DBFilesClient\\UiWidgetConstantSource.db2",
+    "DBFilesClient\\UiWidgetDataSource.db2",
+    "DBFilesClient\\UiWidgetStringSource.db2",
+    "DBFilesClient\\UiWidgetVisualization.db2",
     "DBFilesClient\\UnitBlood.db2",
     "DBFilesClient\\UnitBloodLevels.db2",
     "DBFilesClient\\UnitCondition.db2",
     "DBFilesClient\\UnitPowerBar.db2",
-    "DBFilesClient\\UnitTest.db2",
     "DBFilesClient\\Vehicle.db2",
     "DBFilesClient\\VehicleSeat.db2",
     "DBFilesClient\\VehicleUIIndSeat.db2",
@@ -613,15 +666,14 @@ char const* DBFilesClientList[] =
     "DBFilesClient\\WeaponTrailModelDef.db2",
     "DBFilesClient\\WeaponTrailParam.db2",
     "DBFilesClient\\Weather.db2",
+    "DBFilesClient\\WeatherXParticulate.db2",
     "DBFilesClient\\WindSettings.db2",
     "DBFilesClient\\WorldBossLockout.db2",
     "DBFilesClient\\WorldChunkSounds.db2",
     "DBFilesClient\\WorldEffect.db2",
     "DBFilesClient\\WorldElapsedTimer.db2",
-    "DBFilesClient\\WorldMapArea.db2",
-    "DBFilesClient\\WorldMapContinent.db2",
     "DBFilesClient\\WorldMapOverlay.db2",
-    "DBFilesClient\\WorldMapTransforms.db2",
+    "DBFilesClient\\WorldMapOverlayTile.db2",
     "DBFilesClient\\WorldSafeLocs.db2",
     "DBFilesClient\\WorldStateExpression.db2",
     "DBFilesClient\\WorldStateUI.db2",